History

avcodec/mpegvideoenc: Move ratecontrol to MPVMainEncContext

Andreas Rheinhardt committed 4 years ago

Commit d8c79251 parent bb0a72b6 files · +140 −120Browse files

Unified · Split

6 files
  1. libavcodec/mpegvideo.h +0 −8
  2. libavcodec/mpegvideo_enc.c +40 −33
  3. libavcodec/mpegvideoenc.h +9 −1
  4. libavcodec/ratecontrol.c +42 −33
  5. libavcodec/ratecontrol.h +6 −6
  6. libavcodec/snowenc.c +43 −39
libavcodec/mpegvideo.h+0−8
@@ -42,7 +42,6 @@ · 41 unmodified lines
42#include "mpegvideoencdsp.h"42#include "mpegvideoencdsp.h"
43#include "pixblockdsp.h"43#include "pixblockdsp.h"
44#include "put_bits.h"44#include "put_bits.h"
45#include "ratecontrol.h"
46#include "qpeldsp.h"45#include "qpeldsp.h"
47#include "videodsp.h"46#include "videodsp.h"
48 47
@@ -327,13 +326,6 @@ typedef struct MpegEncContext { · 278 unmodified lines
327 int dct_count[2];326 int dct_count[2];
328 uint16_t (*dct_offset)[64];327 uint16_t (*dct_offset)[64];
329 328
330 /* bit rate control */
331 int64_t total_bits;
332 int frame_bits; ///< bits used for the current frame
333 int stuffing_bits; ///< bits used for stuffing
334 int next_lambda; ///< next lambda used for retrying to encode a frame
335 RateControlContext rc_context; ///< contains stuff only accessed in ratecontrol.c
336
337 /* statistics, used for 2-pass encoding */329 /* statistics, used for 2-pass encoding */
338 int mv_bits;330 int mv_bits;
339 int header_bits;331 int header_bits;
libavcodec/mpegvideo_enc.c+40−33
@@ -84,7 +84,7 @@ · 83 unmodified lines
84#define QMAT_SHIFT_MMX 1684#define QMAT_SHIFT_MMX 16
85#define QMAT_SHIFT 2185#define QMAT_SHIFT 21
86 86
87static int encode_picture(MpegEncContext *s, const AVPacket *pkt);87static int encode_picture(MPVMainEncContext *const s, const AVPacket *pkt);
88static int dct_quantize_refine(MpegEncContext *s, int16_t *block, int16_t *weight, int16_t *orig, int n, int qscale);88static int dct_quantize_refine(MpegEncContext *s, int16_t *block, int16_t *weight, int16_t *orig, int n, int qscale);
89static int sse_mb(MpegEncContext *s);89static int sse_mb(MpegEncContext *s);
90static void denoise_dct_c(MpegEncContext *s, int16_t *block);90static void denoise_dct_c(MpegEncContext *s, int16_t *block);
@@ -1008,7 +1008,8 @@ av_cold int ff_mpv_encode_init(AVCodecContext *avctx) · 917 unmodified lines
1008#endif1008#endif
1009 }1009 }
1010 1010
1011 if ((ret = ff_rate_control_init(s)) < 0)1011 ret = ff_rate_control_init(m);
1012 if (ret < 0)
1012 return ret;1013 return ret;
1013 1014
1014 if (m->b_frame_strategy == 2) {1015 if (m->b_frame_strategy == 2) {
@@ -1043,7 +1044,7 @@ av_cold int ff_mpv_encode_end(AVCodecContext *avctx) · 28 unmodified lines
1043 MPVMainEncContext *const m = avctx->priv_data;1044 MPVMainEncContext *const m = avctx->priv_data;
1044 MpegEncContext *const s = &m->s;1045 MpegEncContext *const s = &m->s;
1045 1046
1046 ff_rate_control_uninit(&s->rc_context);1047 ff_rate_control_uninit(&m->rc_context);
1047 1048
1048 ff_mpv_common_end(s);1049 ff_mpv_common_end(s);
1049 av_refstruct_pool_uninit(&s->picture_pool);1050 av_refstruct_pool_uninit(&s->picture_pool);
@@ -1622,7 +1623,7 @@ static int set_bframe_chain_length(MPVMainEncContext *const m) · 572 unmodified lines
1622 // FIXME check that the gop check above is +-1 correct1623 // FIXME check that the gop check above is +-1 correct
1623 av_refstruct_unref(&s->input_picture[0]);1624 av_refstruct_unref(&s->input_picture[0]);
1624 1625
1625 ff_vbv_update(s, 0);1626 ff_vbv_update(m, 0);
1626 1627
1627 return 0;1628 return 0;
1628 }1629 }
@@ -1642,15 +1643,15 @@ static int set_bframe_chain_length(MPVMainEncContext *const m) · 13 unmodified lines
1642 for (int i = 0; i < s->max_b_frames + 1; i++) {1643 for (int i = 0; i < s->max_b_frames + 1; i++) {
1643 int pict_num = s->input_picture[0]->display_picture_number + i;1644 int pict_num = s->input_picture[0]->display_picture_number + i;
1644 1645
1645 if (pict_num >= s->rc_context.num_entries)1646 if (pict_num >= m->rc_context.num_entries)
1646 break;1647 break;
1647 if (!s->input_picture[i]) {1648 if (!s->input_picture[i]) {
1648 s->rc_context.entry[pict_num - 1].new_pict_type = AV_PICTURE_TYPE_P;1649 m->rc_context.entry[pict_num - 1].new_pict_type = AV_PICTURE_TYPE_P;
1649 break;1650 break;
1650 }1651 }
1651 1652
1652 s->input_picture[i]->f->pict_type =1653 s->input_picture[i]->f->pict_type =
1653 s->rc_context.entry[pict_num].new_pict_type;1654 m->rc_context.entry[pict_num].new_pict_type;
1654 }1655 }
1655 }1656 }
1656 1657
@@ -1918,7 +1919,7 @@ int ff_mpv_encode_picture(AVCodecContext *avctx, AVPacket *pkt, · 261 unmodified lines
1918 //emms_c();1919 //emms_c();
1919 frame_start(s);1920 frame_start(s);
1920vbv_retry:1921vbv_retry:
1921 ret = encode_picture(s, pkt);1922 ret = encode_picture(m, pkt);
1922 if (growing_buffer) {1923 if (growing_buffer) {
1923 av_assert0(s->pb.buf == avctx->internal->byte_buffer);1924 av_assert0(s->pb.buf == avctx->internal->byte_buffer);
1924 pkt->data = s->pb.buf;1925 pkt->data = s->pb.buf;
@@ -1933,14 +1934,14 @@ vbv_retry: · 8 unmodified lines
1933 ff_mjpeg_encode_picture_trailer(&s->pb, s->header_bits);1934 ff_mjpeg_encode_picture_trailer(&s->pb, s->header_bits);
1934 1935
1935 if (avctx->rc_buffer_size) {1936 if (avctx->rc_buffer_size) {
1936 RateControlContext *rcc = &s->rc_context;1937 RateControlContext *rcc = &m->rc_context;
1937 int max_size = FFMAX(rcc->buffer_index * avctx->rc_max_available_vbv_use, rcc->buffer_index - 500);1938 int max_size = FFMAX(rcc->buffer_index * avctx->rc_max_available_vbv_use, rcc->buffer_index - 500);
1938 int hq = (avctx->mb_decision == FF_MB_DECISION_RD || avctx->trellis);1939 int hq = (avctx->mb_decision == FF_MB_DECISION_RD || avctx->trellis);
1939 int min_step = hq ? 1 : (1<<(FF_LAMBDA_SHIFT + 7))/139;1940 int min_step = hq ? 1 : (1<<(FF_LAMBDA_SHIFT + 7))/139;
1940 1941
1941 if (put_bits_count(&s->pb) > max_size &&1942 if (put_bits_count(&s->pb) > max_size &&
1942 s->lambda < s->lmax) {1943 s->lambda < s->lmax) {
1943 s->next_lambda = FFMAX(s->lambda + min_step, s->lambda *1944 m->next_lambda = FFMAX(s->lambda + min_step, s->lambda *
1944 (s->qscale + 1) / s->qscale);1945 (s->qscale + 1) / s->qscale);
1945 if (s->adaptive_quant) {1946 if (s->adaptive_quant) {
1946 int i;1947 int i;
@@ -1968,7 +1969,7 @@ vbv_retry: · 21 unmodified lines
1968 }1969 }
1969 1970
1970 if (avctx->flags & AV_CODEC_FLAG_PASS1)1971 if (avctx->flags & AV_CODEC_FLAG_PASS1)
1971 ff_write_pass1_stats(s);1972 ff_write_pass1_stats(m);
1972 1973
1973 for (int i = 0; i < MPV_MAX_PLANES; i++)1974 for (int i = 0; i < MPV_MAX_PLANES; i++)
1974 avctx->error[i] += s->encoding_error[i];1975 avctx->error[i] += s->encoding_error[i];
@@ -1982,10 +1983,10 @@ vbv_retry: · 7 unmodified lines
1982 s->misc_bits + s->i_tex_bits +1983 s->misc_bits + s->i_tex_bits +
1983 s->p_tex_bits);1984 s->p_tex_bits);
1984 flush_put_bits(&s->pb);1985 flush_put_bits(&s->pb);
1985 s->frame_bits = put_bits_count(&s->pb);1986 m->frame_bits = put_bits_count(&s->pb);
1986 1987
1987 stuffing_count = ff_vbv_update(s, s->frame_bits);1988 stuffing_count = ff_vbv_update(m, m->frame_bits);
1988 s->stuffing_bits = 8*stuffing_count;1989 m->stuffing_bits = 8*stuffing_count;
1989 if (stuffing_count) {1990 if (stuffing_count) {
1990 if (put_bytes_left(&s->pb, 0) < stuffing_count + 50) {1991 if (put_bytes_left(&s->pb, 0) < stuffing_count + 50) {
1991 av_log(avctx, AV_LOG_ERROR, "stuffing too large\n");1992 av_log(avctx, AV_LOG_ERROR, "stuffing too large\n");
@@ -2009,10 +2010,10 @@ vbv_retry: · 17 unmodified lines
2009 break;2010 break;
2010 default:2011 default:
2011 av_log(avctx, AV_LOG_ERROR, "vbv buffer overflow\n");2012 av_log(avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
2012 s->stuffing_bits = 0;2013 m->stuffing_bits = 0;
2013 }2014 }
2014 flush_put_bits(&s->pb);2015 flush_put_bits(&s->pb);
2015 s->frame_bits = put_bits_count(&s->pb);2016 m->frame_bits = put_bits_count(&s->pb);
2016 }2017 }
2017 2018
2018 /* update MPEG-1/2 vbv_delay for CBR */2019 /* update MPEG-1/2 vbv_delay for CBR */
@@ -2027,9 +2028,9 @@ vbv_retry: · 8 unmodified lines
2027 int vbv_delay, min_delay;2028 int vbv_delay, min_delay;
2028 double inbits = avctx->rc_max_rate *2029 double inbits = avctx->rc_max_rate *
2029 av_q2d(avctx->time_base);2030 av_q2d(avctx->time_base);
2030 int minbits = s->frame_bits - 8 *2031 int minbits = m->frame_bits - 8 *
2031 (s->vbv_delay_pos - 1);2032 (s->vbv_delay_pos - 1);
2032 double bits = s->rc_context.buffer_index + minbits - inbits;2033 double bits = m->rc_context.buffer_index + minbits - inbits;
2033 uint8_t *const vbv_delay_ptr = s->pb.buf + s->vbv_delay_pos;2034 uint8_t *const vbv_delay_ptr = s->pb.buf + s->vbv_delay_pos;
2034 2035
2035 if (bits < 0)2036 if (bits < 0)
@@ -2064,7 +2065,7 @@ vbv_retry: · 28 unmodified lines
2064 return ret;2065 return ret;
2065 }2066 }
2066 }2067 }
2067 s->total_bits += s->frame_bits;2068 m->total_bits += m->frame_bits;
2068 2069
2069 pkt->pts = s->cur_pic.ptr->f->pts;2070 pkt->pts = s->cur_pic.ptr->f->pts;
2070 pkt->duration = s->cur_pic.ptr->f->duration;2071 pkt->duration = s->cur_pic.ptr->f->duration;
@@ -2089,14 +2090,14 @@ vbv_retry: · 18 unmodified lines
2089 if (s->mb_info)2090 if (s->mb_info)
2090 av_packet_shrink_side_data(pkt, AV_PKT_DATA_H263_MB_INFO, s->mb_info_size);2091 av_packet_shrink_side_data(pkt, AV_PKT_DATA_H263_MB_INFO, s->mb_info_size);
2091 } else {2092 } else {
2092 s->frame_bits = 0;2093 m->frame_bits = 0;
2093 }2094 }
2094 2095
2095 ff_mpv_unref_picture(&s->cur_pic);2096 ff_mpv_unref_picture(&s->cur_pic);
2096 2097
2097 av_assert1((s->frame_bits & 7) == 0);2098 av_assert1((m->frame_bits & 7) == 0);
2098 2099
2099 pkt->size = s->frame_bits / 8;2100 pkt->size = m->frame_bits / 8;
2100 *got_packet = !!pkt->size;2101 *got_packet = !!pkt->size;
2101 return 0;2102 return 0;
2102}2103}
@@ -3611,12 +3612,15 @@ static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src) · 1508 unmodified lines
3611 flush_put_bits(&dst->pb);3612 flush_put_bits(&dst->pb);
3612}3613}
3613 3614
3614static int estimate_qp(MpegEncContext *s, int dry_run){3615static int estimate_qp(MPVMainEncContext *const m, int dry_run)
3615 if (s->next_lambda){3616{
3616 s->cur_pic.ptr->f->quality = s->next_lambda;3617 MpegEncContext *const s = &m->s;
3617 if(!dry_run) s->next_lambda= 0;3618
3619 if (m->next_lambda){
3620 s->cur_pic.ptr->f->quality = m->next_lambda;
3621 if(!dry_run) m->next_lambda= 0;
3618 } else if (!s->fixed_qscale) {3622 } else if (!s->fixed_qscale) {
3619 int quality = ff_rate_estimate_qscale(s, dry_run);3623 int quality = ff_rate_estimate_qscale(m, dry_run);
3620 s->cur_pic.ptr->f->quality = quality;3624 s->cur_pic.ptr->f->quality = quality;
3621 if (s->cur_pic.ptr->f->quality < 0)3625 if (s->cur_pic.ptr->f->quality < 0)
3622 return -1;3626 return -1;
@@ -3661,8 +3665,9 @@ static void set_frame_distances(MpegEncContext * s){ · 38 unmodified lines
3661 }3665 }
3662}3666}
3663 3667
3664static int encode_picture(MpegEncContext *s, const AVPacket *pkt)3668static int encode_picture(MPVMainEncContext *const m, const AVPacket *pkt)
3665{3669{
3670 MpegEncContext *const s = &m->s;
3666 int i, ret;3671 int i, ret;
3667 int bits;3672 int bits;
3668 int context_count = s->slice_context_count;3673 int context_count = s->slice_context_count;
@@ -3689,9 +3694,10 @@ static int encode_picture(MpegEncContext *s, const AVPacket *pkt) · 20 unmodified lines
3689 }3694 }
3690 3695
3691 if (s->avctx->flags & AV_CODEC_FLAG_PASS2) {3696 if (s->avctx->flags & AV_CODEC_FLAG_PASS2) {
3692 if (estimate_qp(s,1) < 0)3697 ret = estimate_qp(m, 1);
3693 return -1;3698 if (ret < 0)
3694 ff_get_2pass_fcode(s);3699 return ret;
3700 ff_get_2pass_fcode(m);
3695 } else if (!(s->avctx->flags & AV_CODEC_FLAG_QSCALE)) {3701 } else if (!(s->avctx->flags & AV_CODEC_FLAG_QSCALE)) {
3696 if(s->pict_type==AV_PICTURE_TYPE_B)3702 if(s->pict_type==AV_PICTURE_TYPE_B)
3697 s->lambda= s->last_lambda_for[s->pict_type];3703 s->lambda= s->last_lambda_for[s->pict_type];
@@ -3814,8 +3820,9 @@ static int encode_picture(MpegEncContext *s, const AVPacket *pkt) · 116 unmodified lines
3814 }3820 }
3815 }3821 }
3816 3822
3817 if (estimate_qp(s, 0) < 0)3823 ret = estimate_qp(m, 0);
3818 return -1;3824 if (ret < 0)
3825 return ret;
3819 3826
3820 if (s->qscale < 3 && s->max_qcoeff <= 128 &&3827 if (s->qscale < 3 && s->max_qcoeff <= 128 &&
3821 s->pict_type == AV_PICTURE_TYPE_I &&3828 s->pict_type == AV_PICTURE_TYPE_I &&
libavcodec/mpegvideoenc.h+9−1
@@ -32,6 +32,7 @@ · 31 unmodified lines
32 32
33#include "libavutil/opt.h"33#include "libavutil/opt.h"
34#include "mpegvideo.h"34#include "mpegvideo.h"
35#include "ratecontrol.h"
35 36
36#define MPVENC_MAX_B_FRAMES 1637#define MPVENC_MAX_B_FRAMES 16
37 38
@@ -43,6 +44,13 @@ typedef struct MPVMainEncContext { · 5 unmodified lines
43 int b_frame_strategy;44 int b_frame_strategy;
44 int b_sensitivity;45 int b_sensitivity;
45 int brd_scale;46 int brd_scale;
47
48 /* bit rate control */
49 int64_t total_bits;
50 int frame_bits; ///< bits used for the current frame
51 int stuffing_bits; ///< bits used for stuffing
52 int next_lambda; ///< next lambda used for retrying to encode a frame
53 RateControlContext rc_context; ///< contains stuff only accessed in ratecontrol.c
46} MPVMainEncContext;54} MPVMainEncContext;
47 55
48#define MAX_FCODE 756#define MAX_FCODE 7
@@ -94,7 +102,7 @@ typedef struct MPVMainEncContext { · 45 unmodified lines
94 102
95#define FF_MPV_OFFSET(x) offsetof(MpegEncContext, x)103#define FF_MPV_OFFSET(x) offsetof(MpegEncContext, x)
96#define FF_MPV_MAIN_OFFSET(x) offsetof(MPVMainEncContext, x)104#define FF_MPV_MAIN_OFFSET(x) offsetof(MPVMainEncContext, x)
97#define FF_RC_OFFSET(x) offsetof(MpegEncContext, rc_context.x)105#define FF_RC_OFFSET(x) offsetof(MPVMainEncContext, rc_context.x)
98#define FF_MPV_OPT_FLAGS (AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM)106#define FF_MPV_OPT_FLAGS (AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM)
99#define FF_MPV_COMMON_OPTS \107#define FF_MPV_COMMON_OPTS \
100FF_MPV_OPT_CMP_FUNC, \108FF_MPV_OPT_CMP_FUNC, \
libavcodec/ratecontrol.c+42−33
@@ -35,8 +35,9 @@ · 34 unmodified lines
35#include "mpegvideoenc.h"35#include "mpegvideoenc.h"
36#include "libavutil/eval.h"36#include "libavutil/eval.h"
37 37
38void ff_write_pass1_stats(MpegEncContext *s)38void ff_write_pass1_stats(MPVMainEncContext *const m)
39{39{
40 const MpegEncContext *const s = &m->s;
40 snprintf(s->avctx->stats_out, 256,41 snprintf(s->avctx->stats_out, 256,
41 "in:%d out:%d type:%d q:%d itex:%d ptex:%d mv:%d misc:%d "42 "in:%d out:%d type:%d q:%d itex:%d ptex:%d mv:%d misc:%d "
42 "fcode:%d bcode:%d mc-var:%"PRId64" var:%"PRId64" icount:%d hbits:%d;\n",43 "fcode:%d bcode:%d mc-var:%"PRId64" var:%"PRId64" icount:%d hbits:%d;\n",
@@ -101,9 +102,10 @@ static double bits2qp_cb(void *rce, double qp) · 58 unmodified lines
101 return bits2qp(rce, qp);102 return bits2qp(rce, qp);
102}103}
103 104
104static double get_diff_limited_q(MpegEncContext *s, const RateControlEntry *rce, double q)105static double get_diff_limited_q(MPVMainEncContext *m, const RateControlEntry *rce, double q)
105{106{
106 RateControlContext *rcc = &s->rc_context;107 MpegEncContext *const s = &m->s;
108 RateControlContext *const rcc = &m->rc_context;
107 AVCodecContext *a = s->avctx;109 AVCodecContext *a = s->avctx;
108 const int pict_type = rce->new_pict_type;110 const int pict_type = rce->new_pict_type;
109 const double last_p_q = rcc->last_qscale_for[AV_PICTURE_TYPE_P];111 const double last_p_q = rcc->last_qscale_for[AV_PICTURE_TYPE_P];
@@ -168,10 +170,11 @@ static void get_qminmax(int *qmin_ret, int *qmax_ret, MpegEncContext *s, int pic · 58 unmodified lines
168 *qmax_ret = qmax;170 *qmax_ret = qmax;
169}171}
170 172
171static double modify_qscale(MpegEncContext *s, const RateControlEntry *rce,173static double modify_qscale(MPVMainEncContext *const m, const RateControlEntry *rce,
172 double q, int frame_num)174 double q, int frame_num)
173{175{
174 RateControlContext *rcc = &s->rc_context;176 MpegEncContext *const s = &m->s;
177 RateControlContext *const rcc = &m->rc_context;
175 const double buffer_size = s->avctx->rc_buffer_size;178 const double buffer_size = s->avctx->rc_buffer_size;
176 const double fps = get_fps(s->avctx);179 const double fps = get_fps(s->avctx);
177 const double min_rate = s->avctx->rc_min_rate / fps;180 const double min_rate = s->avctx->rc_min_rate / fps;
@@ -259,10 +262,11 @@ static double modify_qscale(MpegEncContext *s, const RateControlEntry *rce, · 81 unmodified lines
259/**262/**
260 * Modify the bitrate curve from pass1 for one frame.263 * Modify the bitrate curve from pass1 for one frame.
261 */264 */
262static double get_qscale(MpegEncContext *s, RateControlEntry *rce,265static double get_qscale(MPVMainEncContext *const m, RateControlEntry *rce,
263 double rate_factor, int frame_num)266 double rate_factor, int frame_num)
264{267{
265 RateControlContext *rcc = &s->rc_context;268 MpegEncContext *const s = &m->s;
269 RateControlContext *rcc = &m->rc_context;
266 AVCodecContext *a = s->avctx;270 AVCodecContext *a = s->avctx;
267 const int pict_type = rce->new_pict_type;271 const int pict_type = rce->new_pict_type;
268 const double mb_num = s->mb_num;272 const double mb_num = s->mb_num;
@@ -332,9 +336,10 @@ static double get_qscale(MpegEncContext *s, RateControlEntry *rce, · 63 unmodified lines
332 return q;336 return q;
333}337}
334 338
335static int init_pass2(MpegEncContext *s)339static int init_pass2(MPVMainEncContext *const m)
336{340{
337 RateControlContext *rcc = &s->rc_context;341 RateControlContext *const rcc = &m->rc_context;
342 MpegEncContext *const s = &m->s;
338 AVCodecContext *a = s->avctx;343 AVCodecContext *a = s->avctx;
339 int i, toobig;344 int i, toobig;
340 AVRational fps = get_fpsQ(s->avctx);345 AVRational fps = get_fpsQ(s->avctx);
@@ -393,7 +398,7 @@ static int init_pass2(MpegEncContext *s) · 52 unmodified lines
393 for (i = 0; i < rcc->num_entries; i++) {398 for (i = 0; i < rcc->num_entries; i++) {
394 const RateControlEntry *rce = &rcc->entry[i];399 const RateControlEntry *rce = &rcc->entry[i];
395 400
396 qscale[i] = get_qscale(s, &rcc->entry[i], rate_factor, i);401 qscale[i] = get_qscale(m, &rcc->entry[i], rate_factor, i);
397 rcc->last_qscale_for[rce->pict_type] = qscale[i];402 rcc->last_qscale_for[rce->pict_type] = qscale[i];
398 }403 }
399 av_assert0(filter_size % 2 == 1);404 av_assert0(filter_size % 2 == 1);
@@ -402,13 +407,13 @@ static int init_pass2(MpegEncContext *s) · 2 unmodified lines
402 for (i = FFMAX(0, rcc->num_entries - 300); i < rcc->num_entries; i++) {407 for (i = FFMAX(0, rcc->num_entries - 300); i < rcc->num_entries; i++) {
403 const RateControlEntry *rce = &rcc->entry[i];408 const RateControlEntry *rce = &rcc->entry[i];
404 409
405 qscale[i] = get_diff_limited_q(s, rce, qscale[i]);410 qscale[i] = get_diff_limited_q(m, rce, qscale[i]);
406 }411 }
407 412
408 for (i = rcc->num_entries - 1; i >= 0; i--) {413 for (i = rcc->num_entries - 1; i >= 0; i--) {
409 const RateControlEntry *rce = &rcc->entry[i];414 const RateControlEntry *rce = &rcc->entry[i];
410 415
411 qscale[i] = get_diff_limited_q(s, rce, qscale[i]);416 qscale[i] = get_diff_limited_q(m, rce, qscale[i]);
412 }417 }
413 418
414 /* smooth curve */419 /* smooth curve */
@@ -438,10 +443,10 @@ static int init_pass2(MpegEncContext *s) · 23 unmodified lines
438 RateControlEntry *rce = &rcc->entry[i];443 RateControlEntry *rce = &rcc->entry[i];
439 double bits;444 double bits;
440 445
441 rce->new_qscale = modify_qscale(s, rce, blurred_qscale[i], i);446 rce->new_qscale = modify_qscale(m, rce, blurred_qscale[i], i);
442 447
443 bits = qp2bits(rce, rce->new_qscale) + rce->mv_bits + rce->misc_bits;448 bits = qp2bits(rce, rce->new_qscale) + rce->mv_bits + rce->misc_bits;
444 bits += 8 * ff_vbv_update(s, bits);449 bits += 8 * ff_vbv_update(m, bits);
445 450
446 rce->expected_bits = expected_bits;451 rce->expected_bits = expected_bits;
447 expected_bits += bits;452 expected_bits += bits;
@@ -494,9 +499,10 @@ static int init_pass2(MpegEncContext *s) · 46 unmodified lines
494 return 0;499 return 0;
495}500}
496 501
497av_cold int ff_rate_control_init(MpegEncContext *s)502av_cold int ff_rate_control_init(MPVMainEncContext *const m)
498{503{
499 RateControlContext *rcc = &s->rc_context;504 MpegEncContext *const s = &m->s;
505 RateControlContext *rcc = &m->rc_context;
500 int i, res;506 int i, res;
501 static const char * const const_names[] = {507 static const char * const const_names[] = {
502 "PI",508 "PI",
@@ -632,7 +638,7 @@ av_cold int ff_rate_control_init(MpegEncContext *s) · 129 unmodified lines
632 p = next;638 p = next;
633 }639 }
634 640
635 res = init_pass2(s);641 res = init_pass2(m);
636 if (res < 0)642 if (res < 0)
637 return res;643 return res;
638 }644 }
@@ -686,7 +692,7 @@ av_cold int ff_rate_control_init(MpegEncContext *s) · 47 unmodified lines
686 rcc->mv_bits_sum[rce.pict_type] += rce.mv_bits;692 rcc->mv_bits_sum[rce.pict_type] += rce.mv_bits;
687 rcc->frame_count[rce.pict_type]++;693 rcc->frame_count[rce.pict_type]++;
688 694
689 get_qscale(s, &rce, rcc->pass1_wanted_bits / rcc->pass1_rc_eq_output_sum, i);695 get_qscale(m, &rce, rcc->pass1_wanted_bits / rcc->pass1_rc_eq_output_sum, i);
690 696
691 // FIXME misbehaves a little for variable fps697 // FIXME misbehaves a little for variable fps
692 rcc->pass1_wanted_bits += s->bit_rate / get_fps(s->avctx);698 rcc->pass1_wanted_bits += s->bit_rate / get_fps(s->avctx);
@@ -717,9 +723,10 @@ av_cold void ff_rate_control_uninit(RateControlContext *rcc) · 24 unmodified lines
717 av_freep(&rcc->cplx_tab);723 av_freep(&rcc->cplx_tab);
718}724}
719 725
720int ff_vbv_update(MpegEncContext *s, int frame_size)726int ff_vbv_update(MPVMainEncContext *m, int frame_size)
721{727{
722 RateControlContext *rcc = &s->rc_context;728 MpegEncContext *const s = &m->s;
729 RateControlContext *const rcc = &m->rc_context;
723 const double fps = get_fps(s->avctx);730 const double fps = get_fps(s->avctx);
724 const int buffer_size = s->avctx->rc_buffer_size;731 const int buffer_size = s->avctx->rc_buffer_size;
725 const double min_rate = s->avctx->rc_min_rate / fps;732 const double min_rate = s->avctx->rc_min_rate / fps;
@@ -893,9 +900,10 @@ static void adaptive_quantization(RateControlContext *const rcc, · 167 unmodified lines
893 }900 }
894}901}
895 902
896void ff_get_2pass_fcode(MpegEncContext *s)903void ff_get_2pass_fcode(MPVMainEncContext *const m)
897{904{
898 const RateControlContext *rcc = &s->rc_context;905 MpegEncContext *const s = &m->s;
906 const RateControlContext *rcc = &m->rc_context;
899 const RateControlEntry *rce = &rcc->entry[s->picture_number];907 const RateControlEntry *rce = &rcc->entry[s->picture_number];
900 908
901 s->f_code = rce->f_code;909 s->f_code = rce->f_code;
@@ -904,8 +912,10 @@ void ff_get_2pass_fcode(MpegEncContext *s) · 2 unmodified lines
904 912
905// FIXME rd or at least approx for dquant913// FIXME rd or at least approx for dquant
906 914
907float ff_rate_estimate_qscale(MpegEncContext *s, int dry_run)915float ff_rate_estimate_qscale(MPVMainEncContext *const m, int dry_run)
908{916{
917 MpegEncContext *const s = &m->s;
918 RateControlContext *rcc = &m->rc_context;
909 float q;919 float q;
910 int qmin, qmax;920 int qmin, qmax;
911 float br_compensation;921 float br_compensation;
@@ -914,7 +924,6 @@ float ff_rate_estimate_qscale(MpegEncContext *s, int dry_run) · 2 unmodified lines
914 double fps;924 double fps;
915 int picture_number = s->picture_number;925 int picture_number = s->picture_number;
916 int64_t wanted_bits;926 int64_t wanted_bits;
917 RateControlContext *rcc = &s->rc_context;
918 AVCodecContext *a = s->avctx;927 AVCodecContext *a = s->avctx;
919 RateControlEntry local_rce, *rce;928 RateControlEntry local_rce, *rce;
920 double bits;929 double bits;
@@ -931,11 +940,11 @@ float ff_rate_estimate_qscale(MpegEncContext *s, int dry_run) · 10 unmodified lines
931 const int64_t last_var =940 const int64_t last_var =
932 s->last_pict_type == AV_PICTURE_TYPE_I ? rcc->last_mb_var_sum941 s->last_pict_type == AV_PICTURE_TYPE_I ? rcc->last_mb_var_sum
933 : rcc->last_mc_mb_var_sum;942 : rcc->last_mc_mb_var_sum;
934 av_assert1(s->frame_bits >= s->stuffing_bits);943 av_assert1(m->frame_bits >= m->stuffing_bits);
935 update_predictor(&rcc->pred[s->last_pict_type],944 update_predictor(&rcc->pred[s->last_pict_type],
936 rcc->last_qscale,945 rcc->last_qscale,
937 sqrt(last_var),946 sqrt(last_var),
938 s->frame_bits - s->stuffing_bits);947 m->frame_bits - m->stuffing_bits);
939 }948 }
940 949
941 if (s->avctx->flags & AV_CODEC_FLAG_PASS2) {950 if (s->avctx->flags & AV_CODEC_FLAG_PASS2) {
@@ -970,7 +979,7 @@ float ff_rate_estimate_qscale(MpegEncContext *s, int dry_run) · 28 unmodified lines
970 wanted_bits = (int64_t)wanted_bits_double;979 wanted_bits = (int64_t)wanted_bits_double;
971 }980 }
972 981
973 diff = s->total_bits - wanted_bits;982 diff = m->total_bits - wanted_bits;
974 br_compensation = (a->bit_rate_tolerance - diff) / a->bit_rate_tolerance;983 br_compensation = (a->bit_rate_tolerance - diff) / a->bit_rate_tolerance;
975 if (br_compensation <= 0.0)984 if (br_compensation <= 0.0)
976 br_compensation = 0.001;985 br_compensation = 0.001;
@@ -984,7 +993,7 @@ float ff_rate_estimate_qscale(MpegEncContext *s, int dry_run) · 7 unmodified lines
984 993
985 q = rce->new_qscale / br_compensation;994 q = rce->new_qscale / br_compensation;
986 ff_dlog(s->avctx, "%f %f %f last:%d var:%"PRId64" type:%d//\n", q, rce->new_qscale,995 ff_dlog(s->avctx, "%f %f %f last:%d var:%"PRId64" type:%d//\n", q, rce->new_qscale,
987 br_compensation, s->frame_bits, var, pict_type);996 br_compensation, m->frame_bits, var, pict_type);
988 } else {997 } else {
989 rce->pict_type =998 rce->pict_type =
990 rce->new_pict_type = pict_type;999 rce->new_pict_type = pict_type;
@@ -1015,12 +1024,12 @@ float ff_rate_estimate_qscale(MpegEncContext *s, int dry_run) · 24 unmodified lines
1015 rate_factor = rcc->pass1_wanted_bits /1024 rate_factor = rcc->pass1_wanted_bits /
1016 rcc->pass1_rc_eq_output_sum * br_compensation;1025 rcc->pass1_rc_eq_output_sum * br_compensation;
1017 1026
1018 q = get_qscale(s, rce, rate_factor, picture_number);1027 q = get_qscale(m, rce, rate_factor, picture_number);
1019 if (q < 0)1028 if (q < 0)
1020 return -1;1029 return -1;
1021 1030
1022 av_assert0(q > 0.0);1031 av_assert0(q > 0.0);
1023 q = get_diff_limited_q(s, rce, q);1032 q = get_diff_limited_q(m, rce, q);
1024 av_assert0(q > 0.0);1033 av_assert0(q > 0.0);
1025 1034
1026 // FIXME type dependent blur like in 2-pass1035 // FIXME type dependent blur like in 2-pass
@@ -1034,7 +1043,7 @@ float ff_rate_estimate_qscale(MpegEncContext *s, int dry_run) · 7 unmodified lines
1034 }1043 }
1035 av_assert0(q > 0.0);1044 av_assert0(q > 0.0);
1036 1045
1037 q = modify_qscale(s, rce, q, picture_number);1046 q = modify_qscale(m, rce, q, picture_number);
1038 1047
1039 rcc->pass1_wanted_bits += s->bit_rate / fps;1048 rcc->pass1_wanted_bits += s->bit_rate / fps;
1040 1049
@@ -1047,8 +1056,8 @@ float ff_rate_estimate_qscale(MpegEncContext *s, int dry_run) · 6 unmodified lines
1047 "size:%d var:%"PRId64"/%"PRId64" br:%"PRId64" fps:%d\n",1056 "size:%d var:%"PRId64"/%"PRId64" br:%"PRId64" fps:%d\n",
1048 av_get_picture_type_char(pict_type),1057 av_get_picture_type_char(pict_type),
1049 qmin, q, qmax, picture_number,1058 qmin, q, qmax, picture_number,
1050 wanted_bits / 1000, s->total_bits / 1000,1059 wanted_bits / 1000, m->total_bits / 1000,
1051 br_compensation, short_term_q, s->frame_bits,1060 br_compensation, short_term_q, m->frame_bits,
1052 s->mb_var_sum, s->mc_mb_var_sum,1061 s->mb_var_sum, s->mc_mb_var_sum,
1053 s->bit_rate / 1000, (int)fps);1062 s->bit_rate / 1000, (int)fps);
1054 }1063 }
libavcodec/ratecontrol.h+6−6
@@ -93,14 +93,14 @@ typedef struct RateControlContext{ · 92 unmodified lines
93 float *cplx_tab, *bits_tab;93 float *cplx_tab, *bits_tab;
94}RateControlContext;94}RateControlContext;
95 95
96struct MpegEncContext;96typedef struct MPVMainEncContext MPVMainEncContext;
97 97
98/* rate control */98/* rate control */
99int ff_rate_control_init(struct MpegEncContext *s);99int ff_rate_control_init(MPVMainEncContext *m);
100float ff_rate_estimate_qscale(struct MpegEncContext *s, int dry_run);100float ff_rate_estimate_qscale(MPVMainEncContext *m, int dry_run);
101void ff_write_pass1_stats(struct MpegEncContext *s);101void ff_write_pass1_stats(MPVMainEncContext *m);
102int ff_vbv_update(struct MpegEncContext *s, int frame_size);102int ff_vbv_update(MPVMainEncContext *m, int frame_size);
103void ff_get_2pass_fcode(struct MpegEncContext *s);103void ff_get_2pass_fcode(MPVMainEncContext *m);
104void ff_rate_control_uninit(RateControlContext *rcc);104void ff_rate_control_uninit(RateControlContext *rcc);
105 105
106#endif /* AVCODEC_RATECONTROL_H */106#endif /* AVCODEC_RATECONTROL_H */
libavcodec/snowenc.c+43−39
@@ -61,7 +61,7 @@ typedef struct SnowEncContext { · 60 unmodified lines
61 int scenechange_threshold;61 int scenechange_threshold;
62 62
63 MECmpContext mecc;63 MECmpContext mecc;
64 MpegEncContext m; // needed for motion estimation, should not be used for anything else, the idea is to eventually make the motion estimation independent of MpegEncContext, so this will be removed then (FIXME/XXX)64 MPVMainEncContext m; // needed for motion estimation, should not be used for anything else, the idea is to eventually make the motion estimation independent of MpegEncContext, so this will be removed then (FIXME/XXX)
65 MPVPicture cur_pic, last_pic;65 MPVPicture cur_pic, last_pic;
66#define ME_CACHE_SIZE 102466#define ME_CACHE_SIZE 1024
67 unsigned me_cache[ME_CACHE_SIZE];67 unsigned me_cache[ME_CACHE_SIZE];
@@ -160,7 +160,7 @@ static av_cold int encode_init(AVCodecContext *avctx) · 92 unmodified lines
160{160{
161 SnowEncContext *const enc = avctx->priv_data;161 SnowEncContext *const enc = avctx->priv_data;
162 SnowContext *const s = &enc->com;162 SnowContext *const s = &enc->com;
163 MpegEncContext *const mpv = &enc->m;163 MpegEncContext *const mpv = &enc->m.s;
164 int plane_index, ret;164 int plane_index, ret;
165 int i;165 int i;
166 166
@@ -217,7 +217,7 @@ static av_cold int encode_init(AVCodecContext *avctx) · 50 unmodified lines
217 mcf(12,12)217 mcf(12,12)
218 218
219 ff_me_cmp_init(&enc->mecc, avctx);219 ff_me_cmp_init(&enc->mecc, avctx);
220 ret = ff_me_init(&enc->m.me, avctx, &enc->mecc, 0);220 ret = ff_me_init(&mpv->me, avctx, &enc->mecc, 0);
221 if (ret < 0)221 if (ret < 0)
222 return ret;222 return ret;
223 ff_mpegvideoencdsp_init(&enc->mpvencdsp, avctx);223 ff_mpegvideoencdsp_init(&enc->mpvencdsp, avctx);
@@ -252,7 +252,7 @@ static av_cold int encode_init(AVCodecContext *avctx) · 28 unmodified lines
252 return AVERROR(ENOMEM);252 return AVERROR(ENOMEM);
253 }253 }
254 if((avctx->flags&AV_CODEC_FLAG_PASS2) || !(avctx->flags&AV_CODEC_FLAG_QSCALE)){254 if((avctx->flags&AV_CODEC_FLAG_PASS2) || !(avctx->flags&AV_CODEC_FLAG_QSCALE)){
255 ret = ff_rate_control_init(mpv);255 ret = ff_rate_control_init(&enc->m);
256 if(ret < 0)256 if(ret < 0)
257 return ret;257 return ret;
258 }258 }
@@ -369,7 +369,7 @@ static inline int get_penalty_factor(int lambda, int lambda2, int type){ · 110 unmodified lines
369static int encode_q_branch(SnowEncContext *enc, int level, int x, int y)369static int encode_q_branch(SnowEncContext *enc, int level, int x, int y)
370{370{
371 SnowContext *const s = &enc->com;371 SnowContext *const s = &enc->com;
372 MotionEstContext *const c = &enc->m.me;372 MotionEstContext *const c = &enc->m.s.me;
373 uint8_t p_buffer[1024];373 uint8_t p_buffer[1024];
374 uint8_t i_buffer[1024];374 uint8_t i_buffer[1024];
375 uint8_t p_state[sizeof(s->block_state)];375 uint8_t p_state[sizeof(s->block_state)];
@@ -435,9 +435,9 @@ static int encode_q_branch(SnowEncContext *enc, int level, int x, int y) · 59 unmodified lines
435 last_mv[2][0]= bottom->mx;435 last_mv[2][0]= bottom->mx;
436 last_mv[2][1]= bottom->my;436 last_mv[2][1]= bottom->my;
437 437
438 enc->m.mb_stride = 2;438 enc->m.s.mb_stride = 2;
439 enc->m.mb_x =439 enc->m.s.mb_x =
440 enc->m.mb_y = 0;440 enc->m.s.mb_y = 0;
441 c->skip= 0;441 c->skip= 0;
442 442
443 av_assert1(c-> stride == stride);443 av_assert1(c-> stride == stride);
@@ -446,7 +446,7 @@ static int encode_q_branch(SnowEncContext *enc, int level, int x, int y) · 2 unmodified lines
446 c->penalty_factor = get_penalty_factor(enc->lambda, enc->lambda2, c->avctx->me_cmp);446 c->penalty_factor = get_penalty_factor(enc->lambda, enc->lambda2, c->avctx->me_cmp);
447 c->sub_penalty_factor= get_penalty_factor(enc->lambda, enc->lambda2, c->avctx->me_sub_cmp);447 c->sub_penalty_factor= get_penalty_factor(enc->lambda, enc->lambda2, c->avctx->me_sub_cmp);
448 c->mb_penalty_factor = get_penalty_factor(enc->lambda, enc->lambda2, c->avctx->mb_cmp);448 c->mb_penalty_factor = get_penalty_factor(enc->lambda, enc->lambda2, c->avctx->mb_cmp);
449 c->current_mv_penalty = c->mv_penalty[enc->m.f_code=1] + MAX_DMV;449 c->current_mv_penalty = c->mv_penalty[enc->m.s.f_code=1] + MAX_DMV;
450 450
451 c->xmin = - x*block_w - 16+3;451 c->xmin = - x*block_w - 16+3;
452 c->ymin = - y*block_w - 16+3;452 c->ymin = - y*block_w - 16+3;
@@ -482,7 +482,7 @@ static int encode_q_branch(SnowEncContext *enc, int level, int x, int y) · 29 unmodified lines
482 for(ref=0; ref<s->ref_frames; ref++){482 for(ref=0; ref<s->ref_frames; ref++){
483 init_ref(c, current_data, s->last_picture[ref]->data, NULL, block_w*x, block_w*y, 0);483 init_ref(c, current_data, s->last_picture[ref]->data, NULL, block_w*x, block_w*y, 0);
484 484
485 ref_score= ff_epzs_motion_search(&enc->m, &ref_mx, &ref_my, P, 0, /*ref_index*/ 0, last_mv,485 ref_score = ff_epzs_motion_search(&enc->m.s, &ref_mx, &ref_my, P, 0, /*ref_index*/ 0, last_mv,
486 (1<<16)>>shift, level-LOG2_MB_SIZE+4, block_w);486 (1<<16)>>shift, level-LOG2_MB_SIZE+4, block_w);
487 487
488 av_assert2(ref_mx >= c->xmin);488 av_assert2(ref_mx >= c->xmin);
@@ -490,8 +490,10 @@ static int encode_q_branch(SnowEncContext *enc, int level, int x, int y) · 1 unmodified line
490 av_assert2(ref_my >= c->ymin);490 av_assert2(ref_my >= c->ymin);
491 av_assert2(ref_my <= c->ymax);491 av_assert2(ref_my <= c->ymax);
492 492
493 ref_score= c->sub_motion_search(&enc->m, &ref_mx, &ref_my, ref_score, 0, 0, level-LOG2_MB_SIZE+4, block_w);493 ref_score = c->sub_motion_search(&enc->m.s, &ref_mx, &ref_my, ref_score,
494 ref_score= ff_get_mb_score(&enc->m, ref_mx, ref_my, 0, 0, level-LOG2_MB_SIZE+4, block_w, 0);494 0, 0, level-LOG2_MB_SIZE+4, block_w);
495 ref_score = ff_get_mb_score(&enc->m.s, ref_mx, ref_my, 0, 0,
496 level-LOG2_MB_SIZE+4, block_w, 0);
495 ref_score+= 2*av_log2(2*ref)*c->penalty_factor;497 ref_score+= 2*av_log2(2*ref)*c->penalty_factor;
496 if(s->ref_mvs[ref]){498 if(s->ref_mvs[ref]){
497 s->ref_mvs[ref][index][0]= ref_mx;499 s->ref_mvs[ref][index][0]= ref_mx;
@@ -567,7 +569,7 @@ static int encode_q_branch(SnowEncContext *enc, int level, int x, int y) · 69 unmodified lines
567 if (vard <= 64 || vard < varc)569 if (vard <= 64 || vard < varc)
568 c->scene_change_score+= ff_sqrt(vard) - ff_sqrt(varc);570 c->scene_change_score+= ff_sqrt(vard) - ff_sqrt(varc);
569 else571 else
570 c->scene_change_score += enc->m.qscale;572 c->scene_change_score += enc->m.s.qscale;
571 }573 }
572 574
573 if(level!=s->block_max_depth){575 if(level!=s->block_max_depth){
@@ -670,7 +672,7 @@ static int get_dc(SnowEncContext *enc, int mb_x, int mb_y, int plane_index) · 96 unmodified lines
670 const int obmc_stride= plane_index ? (2*block_size)>>s->chroma_h_shift : 2*block_size;672 const int obmc_stride= plane_index ? (2*block_size)>>s->chroma_h_shift : 2*block_size;
671 const int ref_stride= s->current_picture->linesize[plane_index];673 const int ref_stride= s->current_picture->linesize[plane_index];
672 const uint8_t *src = s->input_picture->data[plane_index];674 const uint8_t *src = s->input_picture->data[plane_index];
673 IDWTELEM *dst= (IDWTELEM*)enc->m.sc.obmc_scratchpad + plane_index*block_size*block_size*4; //FIXME change to unsigned675 IDWTELEM *dst= (IDWTELEM*)enc->m.s.sc.obmc_scratchpad + plane_index*block_size*block_size*4; //FIXME change to unsigned
674 const int b_stride = s->b_width << s->block_max_depth;676 const int b_stride = s->b_width << s->block_max_depth;
675 const int w= p->width;677 const int w= p->width;
676 const int h= p->height;678 const int h= p->height;
@@ -768,7 +770,7 @@ static int get_block_rd(SnowEncContext *enc, int mb_x, int mb_y, · 91 unmodified lines
768 const int ref_stride= s->current_picture->linesize[plane_index];770 const int ref_stride= s->current_picture->linesize[plane_index];
769 uint8_t *dst= s->current_picture->data[plane_index];771 uint8_t *dst= s->current_picture->data[plane_index];
770 const uint8_t *src = s->input_picture->data[plane_index];772 const uint8_t *src = s->input_picture->data[plane_index];
771 IDWTELEM *pred= (IDWTELEM*)enc->m.sc.obmc_scratchpad + plane_index*block_size*block_size*4;773 IDWTELEM *pred= (IDWTELEM*)enc->m.s.sc.obmc_scratchpad + plane_index*block_size*block_size*4;
772 uint8_t *cur = s->scratchbuf;774 uint8_t *cur = s->scratchbuf;
773 uint8_t *tmp = s->emu_edge_buffer;775 uint8_t *tmp = s->emu_edge_buffer;
774 const int b_stride = s->b_width << s->block_max_depth;776 const int b_stride = s->b_width << s->block_max_depth;
@@ -831,19 +833,19 @@ static int get_block_rd(SnowEncContext *enc, int mb_x, int mb_y, · 56 unmodified lines
831 * to improve the score of the whole frame, thus iterative motion833 * to improve the score of the whole frame, thus iterative motion
832 * estimation does not always converge. */834 * estimation does not always converge. */
833 if(s->avctx->me_cmp == FF_CMP_W97)835 if(s->avctx->me_cmp == FF_CMP_W97)
834 distortion = ff_w97_32_c(&enc->m, src + sx + sy*ref_stride, dst + sx + sy*ref_stride, ref_stride, 32);836 distortion = ff_w97_32_c(&enc->m.s, src + sx + sy*ref_stride, dst + sx + sy*ref_stride, ref_stride, 32);
835 else if(s->avctx->me_cmp == FF_CMP_W53)837 else if(s->avctx->me_cmp == FF_CMP_W53)
836 distortion = ff_w53_32_c(&enc->m, src + sx + sy*ref_stride, dst + sx + sy*ref_stride, ref_stride, 32);838 distortion = ff_w53_32_c(&enc->m.s, src + sx + sy*ref_stride, dst + sx + sy*ref_stride, ref_stride, 32);
837 else{839 else{
838 distortion = 0;840 distortion = 0;
839 for(i=0; i<4; i++){841 for(i=0; i<4; i++){
840 int off = sx+16*(i&1) + (sy+16*(i>>1))*ref_stride;842 int off = sx+16*(i&1) + (sy+16*(i>>1))*ref_stride;
841 distortion += enc->m.me.me_cmp[0](&enc->m, src + off, dst + off, ref_stride, 16);843 distortion += enc->m.s.me.me_cmp[0](&enc->m.s, src + off, dst + off, ref_stride, 16);
842 }844 }
843 }845 }
844 }else{846 }else{
845 av_assert2(block_w==8);847 av_assert2(block_w==8);
846 distortion = enc->m.me.me_cmp[0](&enc->m, src + sx + sy*ref_stride, dst + sx + sy*ref_stride, ref_stride, block_w*2);848 distortion = enc->m.s.me.me_cmp[0](&enc->m.s, src + sx + sy*ref_stride, dst + sx + sy*ref_stride, ref_stride, block_w*2);
847 }849 }
848 850
849 if(plane_index==0){851 if(plane_index==0){
@@ -909,7 +911,7 @@ static int get_4block_rd(SnowEncContext *enc, int mb_x, int mb_y, int plane_inde · 59 unmodified lines
909 }911 }
910 912
911 av_assert1(block_w== 8 || block_w==16);913 av_assert1(block_w== 8 || block_w==16);
912 distortion += enc->m.me.me_cmp[block_w==8](&enc->m, src + x + y*ref_stride, dst + x + y*ref_stride, ref_stride, block_h);914 distortion += enc->m.s.me.me_cmp[block_w==8](&enc->m.s, src + x + y*ref_stride, dst + x + y*ref_stride, ref_stride, block_h);
913 }915 }
914 916
915 if(plane_index==0){917 if(plane_index==0){
@@ -1706,11 +1708,11 @@ static int ratecontrol_1pass(SnowEncContext *enc, AVFrame *pict) · 790 unmodified lines
1706 coef_sum = (uint64_t)coef_sum * coef_sum >> 16;1708 coef_sum = (uint64_t)coef_sum * coef_sum >> 16;
1707 1709
1708 if(pict->pict_type == AV_PICTURE_TYPE_I){1710 if(pict->pict_type == AV_PICTURE_TYPE_I){
1709 enc->m.mb_var_sum = coef_sum;1711 enc->m.s.mb_var_sum = coef_sum;
1710 enc->m.mc_mb_var_sum = 0;1712 enc->m.s.mc_mb_var_sum = 0;
1711 }else{1713 }else{
1712 enc->m.mc_mb_var_sum = coef_sum;1714 enc->m.s.mc_mb_var_sum = coef_sum;
1713 enc->m.mb_var_sum = 0;1715 enc->m.s.mb_var_sum = 0;
1714 }1716 }
1715 1717
1716 pict->quality= ff_rate_estimate_qscale(&enc->m, 1);1718 pict->quality= ff_rate_estimate_qscale(&enc->m, 1);
@@ -1757,7 +1759,7 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *pkt, · 40 unmodified lines
1757{1759{
1758 SnowEncContext *const enc = avctx->priv_data;1760 SnowEncContext *const enc = avctx->priv_data;
1759 SnowContext *const s = &enc->com;1761 SnowContext *const s = &enc->com;
1760 MpegEncContext *const mpv = &enc->m;1762 MpegEncContext *const mpv = &enc->m.s;
1761 RangeCoder * const c= &s->c;1763 RangeCoder * const c= &s->c;
1762 AVCodecInternal *avci = avctx->internal;1764 AVCodecInternal *avci = avctx->internal;
1763 AVFrame *pic;1765 AVFrame *pic;
@@ -1793,10 +1795,10 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *pkt, · 29 unmodified lines
1793 1795
1794 mpv->picture_number = avctx->frame_num;1796 mpv->picture_number = avctx->frame_num;
1795 if(avctx->flags&AV_CODEC_FLAG_PASS2){1797 if(avctx->flags&AV_CODEC_FLAG_PASS2){
1796 mpv->pict_type = pic->pict_type = mpv->rc_context.entry[avctx->frame_num].new_pict_type;1798 mpv->pict_type = pic->pict_type = enc->m.rc_context.entry[avctx->frame_num].new_pict_type;
1797 s->keyframe = pic->pict_type == AV_PICTURE_TYPE_I;1799 s->keyframe = pic->pict_type == AV_PICTURE_TYPE_I;
1798 if(!(avctx->flags&AV_CODEC_FLAG_QSCALE)) {1800 if(!(avctx->flags&AV_CODEC_FLAG_QSCALE)) {
1799 pic->quality = ff_rate_estimate_qscale(mpv, 0);1801 pic->quality = ff_rate_estimate_qscale(&enc->m, 0);
1800 if (pic->quality < 0)1802 if (pic->quality < 0)
1801 return -1;1803 return -1;
1802 }1804 }
@@ -1877,7 +1879,7 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *pkt, · 74 unmodified lines
1877 1879
1878 mpv->qdsp = enc->qdsp; //move1880 mpv->qdsp = enc->qdsp; //move
1879 mpv->hdsp = s->hdsp;1881 mpv->hdsp = s->hdsp;
1880 ff_me_init_pic(&enc->m);1882 ff_me_init_pic(mpv);
1881 s->hdsp = mpv->hdsp;1883 s->hdsp = mpv->hdsp;
1882 }1884 }
1883 1885
@@ -2043,17 +2045,19 @@ redo_frame: · 159 unmodified lines
2043 2045
2044 s->current_picture->pict_type = pic->pict_type;2046 s->current_picture->pict_type = pic->pict_type;
2045 s->current_picture->quality = pic->quality;2047 s->current_picture->quality = pic->quality;
2046 mpv->frame_bits = 8 * (s->c.bytestream - s->c.bytestream_start);2048 enc->m.frame_bits = 8 * (s->c.bytestream - s->c.bytestream_start);
2047 mpv->p_tex_bits = mpv->frame_bits - mpv->misc_bits - mpv->mv_bits;2049 mpv->p_tex_bits = enc->m.frame_bits - mpv->misc_bits - mpv->mv_bits;
2048 mpv->total_bits += 8*(s->c.bytestream - s->c.bytestream_start);2050 enc->m.total_bits += 8*(s->c.bytestream - s->c.bytestream_start);
2049 enc->cur_pic.display_picture_number =2051 enc->cur_pic.display_picture_number =
2050 enc->cur_pic.coded_picture_number = avctx->frame_num;2052 enc->cur_pic.coded_picture_number = avctx->frame_num;
2051 enc->cur_pic.f->quality = pic->quality;2053 enc->cur_pic.f->quality = pic->quality;
2052 if (enc->pass1_rc)2054 if (enc->pass1_rc) {
2053 if (ff_rate_estimate_qscale(mpv, 0) < 0)2055 ret = ff_rate_estimate_qscale(&enc->m, 0);
2054 return -1;2056 if (ret < 0)
2057 return ret;
2058 }
2055 if(avctx->flags&AV_CODEC_FLAG_PASS1)2059 if(avctx->flags&AV_CODEC_FLAG_PASS1)
2056 ff_write_pass1_stats(mpv);2060 ff_write_pass1_stats(&enc->m);
2057 mpv->last_pict_type = mpv->pict_type;2061 mpv->last_pict_type = mpv->pict_type;
2058 2062
2059 emms_c();2063 emms_c();
@@ -2088,10 +2092,10 @@ static av_cold int encode_end(AVCodecContext *avctx) · 28 unmodified lines
2088 av_freep(&s->ref_scores[i]);2092 av_freep(&s->ref_scores[i]);
2089 }2093 }
2090 2094
2091 enc->m.me.temp = NULL;2095 enc->m.s.me.temp = NULL;
2092 av_freep(&enc->m.me.scratchpad);2096 av_freep(&enc->m.s.me.scratchpad);
2093 av_freep(&enc->m.me.map);2097 av_freep(&enc->m.s.me.map);
2094 av_freep(&enc->m.sc.obmc_scratchpad);2098 av_freep(&enc->m.s.sc.obmc_scratchpad);
2095 2099
2096 av_freep(&avctx->stats_out);2100 av_freep(&avctx->stats_out);
2097 2101

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t