diff --git a/libavcodec/dnxhdenc.c b/libavcodec/dnxhdenc.c
index 74989276b9..9ad95ac20a 100644
--- a/libavcodec/dnxhdenc.c
+++ b/libavcodec/dnxhdenc.c
@@ -267,30 +267,31 @@ static av_cold int dnxhd_init_qmat(DNXHDEncContext *ctx, int lbias, int cbias)
     int qscale, i;
     const uint8_t *luma_weight_table   = ctx->cid_table->luma_weight;
     const uint8_t *chroma_weight_table = ctx->cid_table->chroma_weight;
+    MPVEncContext *const s = &ctx->m.common;
 
-    if (!FF_ALLOCZ_TYPED_ARRAY(ctx->qmatrix_l,   ctx->m.avctx->qmax + 1) ||
-        !FF_ALLOCZ_TYPED_ARRAY(ctx->qmatrix_c,   ctx->m.avctx->qmax + 1) ||
-        !FF_ALLOCZ_TYPED_ARRAY(ctx->qmatrix_l16, ctx->m.avctx->qmax + 1) ||
-        !FF_ALLOCZ_TYPED_ARRAY(ctx->qmatrix_c16, ctx->m.avctx->qmax + 1))
+    if (!FF_ALLOCZ_TYPED_ARRAY(ctx->qmatrix_l,   s->avctx->qmax + 1) ||
+        !FF_ALLOCZ_TYPED_ARRAY(ctx->qmatrix_c,   s->avctx->qmax + 1) ||
+        !FF_ALLOCZ_TYPED_ARRAY(ctx->qmatrix_l16, s->avctx->qmax + 1) ||
+        !FF_ALLOCZ_TYPED_ARRAY(ctx->qmatrix_c16, s->avctx->qmax + 1))
         return AVERROR(ENOMEM);
 
     if (ctx->bit_depth == 8) {
         for (i = 1; i < 64; i++) {
-            int j = ctx->m.idsp.idct_permutation[ff_zigzag_direct[i]];
+            int j = s->idsp.idct_permutation[ff_zigzag_direct[i]];
             weight_matrix[j] = ctx->cid_table->luma_weight[i];
         }
-        ff_convert_matrix(&ctx->m, ctx->qmatrix_l, ctx->qmatrix_l16,
+        ff_convert_matrix(s, ctx->qmatrix_l, ctx->qmatrix_l16,
                           weight_matrix, ctx->intra_quant_bias, 1,
-                          ctx->m.avctx->qmax, 1);
+                          s->avctx->qmax, 1);
         for (i = 1; i < 64; i++) {
-            int j = ctx->m.idsp.idct_permutation[ff_zigzag_direct[i]];
+            int j = s->idsp.idct_permutation[ff_zigzag_direct[i]];
             weight_matrix[j] = ctx->cid_table->chroma_weight[i];
         }
-        ff_convert_matrix(&ctx->m, ctx->qmatrix_c, ctx->qmatrix_c16,
+        ff_convert_matrix(s, ctx->qmatrix_c, ctx->qmatrix_c16,
                           weight_matrix, ctx->intra_quant_bias, 1,
-                          ctx->m.avctx->qmax, 1);
+                          s->avctx->qmax, 1);
 
-        for (qscale = 1; qscale <= ctx->m.avctx->qmax; qscale++) {
+        for (qscale = 1; qscale <= s->avctx->qmax; qscale++) {
             for (i = 0; i < 64; i++) {
                 ctx->qmatrix_l[qscale][i]      <<= 2;
                 ctx->qmatrix_c[qscale][i]      <<= 2;
@@ -302,7 +303,7 @@ static av_cold int dnxhd_init_qmat(DNXHDEncContext *ctx, int lbias, int cbias)
         }
     } else {
         // 10-bit
-        for (qscale = 1; qscale <= ctx->m.avctx->qmax; qscale++) {
+        for (qscale = 1; qscale <= s->avctx->qmax; qscale++) {
             for (i = 1; i < 64; i++) {
                 int j = ff_zigzag_direct[i];
 
@@ -325,22 +326,23 @@ static av_cold int dnxhd_init_qmat(DNXHDEncContext *ctx, int lbias, int cbias)
         }
     }
 
-    ctx->m.q_chroma_intra_matrix16 = ctx->qmatrix_c16;
-    ctx->m.q_chroma_intra_matrix   = ctx->qmatrix_c;
-    ctx->m.q_intra_matrix16        = ctx->qmatrix_l16;
-    ctx->m.q_intra_matrix          = ctx->qmatrix_l;
+    s->q_chroma_intra_matrix16 = ctx->qmatrix_c16;
+    s->q_chroma_intra_matrix   = ctx->qmatrix_c;
+    s->q_intra_matrix16        = ctx->qmatrix_l16;
+    s->q_intra_matrix          = ctx->qmatrix_l;
 
     return 0;
 }
 
 static av_cold int dnxhd_init_rc(DNXHDEncContext *ctx)
 {
-    if (!FF_ALLOCZ_TYPED_ARRAY(ctx->mb_rc, (ctx->m.avctx->qmax + 1) * ctx->m.mb_num))
+    MPVEncContext *const s = &ctx->m.common;
+    if (!FF_ALLOCZ_TYPED_ARRAY(ctx->mb_rc, (s->avctx->qmax + 1) * s->mb_num))
         return AVERROR(ENOMEM);
 
-    if (ctx->m.avctx->mb_decision != FF_MB_DECISION_RD) {
-        if (!FF_ALLOCZ_TYPED_ARRAY(ctx->mb_cmp,     ctx->m.mb_num) ||
-            !FF_ALLOCZ_TYPED_ARRAY(ctx->mb_cmp_tmp, ctx->m.mb_num))
+    if (s->avctx->mb_decision != FF_MB_DECISION_RD) {
+        if (!FF_ALLOCZ_TYPED_ARRAY(ctx->mb_cmp,     s->mb_num) ||
+            !FF_ALLOCZ_TYPED_ARRAY(ctx->mb_cmp_tmp, s->mb_num))
             return AVERROR(ENOMEM);
     }
     ctx->frame_bits = (ctx->coding_unit_size -
@@ -353,6 +355,7 @@ static av_cold int dnxhd_init_rc(DNXHDEncContext *ctx)
 static av_cold int dnxhd_encode_init(AVCodecContext *avctx)
 {
     DNXHDEncContext *ctx = avctx->priv_data;
+    MPVEncContext *const s = &ctx->m.common;
     int i, ret;
 
     switch (avctx->pix_fmt) {
@@ -412,31 +415,31 @@ static av_cold int dnxhd_encode_init(AVCodecContext *avctx)
     ctx->cid_table = ff_dnxhd_get_cid_table(ctx->cid);
     av_assert0(ctx->cid_table);
 
-    ctx->m.avctx    = avctx;
-    ctx->m.mb_intra = 1;
-    ctx->m.h263_aic = 1;
+    s->avctx    = avctx;
+    s->mb_intra = 1;
+    s->h263_aic = 1;
 
     avctx->bits_per_raw_sample = ctx->bit_depth;
 
     ff_blockdsp_init(&ctx->bdsp, avctx);
-    ff_fdctdsp_init(&ctx->m.fdsp, avctx);
-    ff_mpv_idct_init(&ctx->m);
-    ff_mpegvideoencdsp_init(&ctx->m.mpvencdsp, avctx);
-    ff_pixblockdsp_init(&ctx->m.pdsp, avctx);
-    ff_dct_encode_init(&ctx->m);
+    ff_fdctdsp_init(&s->fdsp, avctx);
+    ff_mpv_idct_init(s);
+    ff_mpegvideoencdsp_init(&s->mpvencdsp, avctx);
+    ff_pixblockdsp_init(&s->pdsp, avctx);
+    ff_dct_encode_init(s);
 
     if (ctx->profile != FF_PROFILE_DNXHD)
-        ff_videodsp_init(&ctx->m.vdsp, ctx->bit_depth);
+        ff_videodsp_init(&s->vdsp, ctx->bit_depth);
 
-    if (!ctx->m.dct_quantize)
-        ctx->m.dct_quantize = ff_dct_quantize_c;
+    if (!s->dct_quantize)
+        s->dct_quantize = ff_dct_quantize_c;
 
     if (ctx->is_444 || ctx->profile == FF_PROFILE_DNXHR_HQX) {
-        ctx->m.dct_quantize     = dnxhd_10bit_dct_quantize_444;
+        s->dct_quantize     = dnxhd_10bit_dct_quantize_444;
         ctx->get_pixels_8x4_sym = dnxhd_10bit_get_pixels_8x4_sym;
         ctx->block_width_l2     = 4;
     } else if (ctx->bit_depth == 10) {
-        ctx->m.dct_quantize     = dnxhd_10bit_dct_quantize;
+        s->dct_quantize     = dnxhd_10bit_dct_quantize;
         ctx->get_pixels_8x4_sym = dnxhd_10bit_get_pixels_8x4_sym;
         ctx->block_width_l2     = 4;
     } else {
@@ -447,12 +450,12 @@ static av_cold int dnxhd_encode_init(AVCodecContext *avctx)
     if (ARCH_X86)
         ff_dnxhdenc_init_x86(ctx);
 
-    ctx->m.mb_height = (avctx->height + 15) / 16;
-    ctx->m.mb_width  = (avctx->width  + 15) / 16;
+    s->mb_height = (avctx->height + 15) / 16;
+    s->mb_width  = (avctx->width  + 15) / 16;
 
     if (avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT) {
         ctx->interlaced   = 1;
-        ctx->m.mb_height /= 2;
+        s->mb_height /= 2;
     }
 
     if (ctx->interlaced && ctx->profile != FF_PROFILE_DNXHD) {
@@ -461,7 +464,7 @@ static av_cold int dnxhd_encode_init(AVCodecContext *avctx)
         return AVERROR(EINVAL);
     }
 
-    ctx->m.mb_num = ctx->m.mb_height * ctx->m.mb_width;
+    s->mb_num = s->mb_height * s->mb_width;
 
     if (ctx->cid_table->frame_size == DNXHD_VARIABLE) {
         ctx->frame_size = ff_dnxhd_get_hr_frame_size(ctx->cid,
@@ -473,8 +476,8 @@ static av_cold int dnxhd_encode_init(AVCodecContext *avctx)
         ctx->coding_unit_size = ctx->cid_table->coding_unit_size;
     }
 
-    if (ctx->m.mb_height > 68)
-        ctx->data_offset = 0x170 + (ctx->m.mb_height << 2);
+    if (s->mb_height > 68)
+        ctx->data_offset = 0x170 + (s->mb_height << 2);
     else
         ctx->data_offset = 0x280;
 
@@ -492,10 +495,10 @@ static av_cold int dnxhd_encode_init(AVCodecContext *avctx)
     if ((ret = dnxhd_init_rc(ctx)) < 0)
         return ret;
 
-    if (!FF_ALLOCZ_TYPED_ARRAY(ctx->slice_size, ctx->m.mb_height) ||
-        !FF_ALLOCZ_TYPED_ARRAY(ctx->slice_offs, ctx->m.mb_height) ||
-        !FF_ALLOCZ_TYPED_ARRAY(ctx->mb_bits,    ctx->m.mb_num)    ||
-        !FF_ALLOCZ_TYPED_ARRAY(ctx->mb_qscale,  ctx->m.mb_num))
+    if (!FF_ALLOCZ_TYPED_ARRAY(ctx->slice_size, s->mb_height) ||
+        !FF_ALLOCZ_TYPED_ARRAY(ctx->slice_offs, s->mb_height) ||
+        !FF_ALLOCZ_TYPED_ARRAY(ctx->mb_bits,    s->mb_num)    ||
+        !FF_ALLOCZ_TYPED_ARRAY(ctx->mb_qscale,  s->mb_num))
         return AVERROR(ENOMEM);
 
     if (avctx->active_thread_type == FF_THREAD_SLICE) {
@@ -525,6 +528,7 @@ static av_cold int dnxhd_encode_init(AVCodecContext *avctx)
 static int dnxhd_write_header(AVCodecContext *avctx, uint8_t *buf)
 {
     DNXHDEncContext *ctx = avctx->priv_data;
+    MPVEncContext *const s = &ctx->m.common;
 
     memset(buf, 0, ctx->data_offset);
 
@@ -550,8 +554,8 @@ static int dnxhd_write_header(AVCodecContext *avctx, uint8_t *buf)
     buf[0x5f] = 0x01; // UDL
 
     buf[0x167] = 0x02; // reserved
-    AV_WB16(buf + 0x16a, ctx->m.mb_height * 4 + 4); // MSIPS
-    AV_WB16(buf + 0x16c, ctx->m.mb_height); // Ns
+    AV_WB16(buf + 0x16a, s->mb_height * 4 + 4); // MSIPS
+    AV_WB16(buf + 0x16c, s->mb_height); // Ns
     buf[0x16f] = 0x10; // reserved
 
     ctx->msip = buf + 0x170;
@@ -567,7 +571,7 @@ static av_always_inline void dnxhd_encode_dc(DNXHDEncContext *ctx, int diff)
     } else {
         nbits = av_log2_16bit(2 * diff);
     }
-    put_bits(&ctx->m.pb, ctx->cid_table->dc_bits[nbits] + nbits,
+    put_bits(&ctx->m.common.pb, ctx->cid_table->dc_bits[nbits] + nbits,
              (ctx->cid_table->dc_codes[nbits] << nbits) +
              av_mod_uintp2(diff, nbits));
 }
@@ -576,26 +580,27 @@ static av_always_inline
 void dnxhd_encode_block(DNXHDEncContext *ctx, int16_t *block,
                         int last_index, int n)
 {
+    MPVEncContext *const s = &ctx->m.common;
     int last_non_zero = 0;
     int slevel, i, j;
 
-    dnxhd_encode_dc(ctx, block[0] - ctx->m.last_dc[n]);
-    ctx->m.last_dc[n] = block[0];
+    dnxhd_encode_dc(ctx, block[0] - s->last_dc[n]);
+    s->last_dc[n] = block[0];
 
     for (i = 1; i <= last_index; i++) {
-        j = ctx->m.intra_scantable.permutated[i];
+        j = s->intra_scantable.permutated[i];
         slevel = block[j];
         if (slevel) {
             int run_level = i - last_non_zero - 1;
             int rlevel = slevel * (1 << 1) | !!run_level;
-            put_bits(&ctx->m.pb, ctx->vlc_bits[rlevel], ctx->vlc_codes[rlevel]);
+            put_bits(&s->pb, ctx->vlc_bits[rlevel], ctx->vlc_codes[rlevel]);
             if (run_level)
-                put_bits(&ctx->m.pb, ctx->run_bits[run_level],
+                put_bits(&s->pb, ctx->run_bits[run_level],
                          ctx->run_codes[run_level]);
             last_non_zero = i;
         }
     }
-    put_bits(&ctx->m.pb, ctx->vlc_bits[0], ctx->vlc_codes[0]); // EOB
+    put_bits(&s->pb, ctx->vlc_bits[0], ctx->vlc_codes[0]); // EOB
 }
 
 static av_always_inline
@@ -615,7 +620,7 @@ void dnxhd_unquantize_c(DNXHDEncContext *ctx, int16_t *block, int n,
     }
 
     for (i = 1; i <= last_index; i++) {
-        int j = ctx->m.intra_scantable.permutated[i];
+        int j = ctx->m.common.intra_scantable.permutated[i];
         level = block[j];
         if (level) {
             if (level < 0) {
@@ -663,7 +668,7 @@ int dnxhd_calc_ac_bits(DNXHDEncContext *ctx, int16_t *block, int last_index)
     int bits = 0;
     int i, j, level;
     for (i = 1; i <= last_index; i++) {
-        j = ctx->m.intra_scantable.permutated[i];
+        j = ctx->m.common.intra_scantable.permutated[i];
         level = block[j];
         if (level) {
             int run_level = i - last_non_zero - 1;
@@ -678,40 +683,41 @@ int dnxhd_calc_ac_bits(DNXHDEncContext *ctx, int16_t *block, int last_index)
 static av_always_inline
 void dnxhd_get_blocks(DNXHDEncContext *ctx, int mb_x, int mb_y)
 {
+    MPVEncContext *const s = &ctx->m.common;
     const int bs = ctx->block_width_l2;
     const int bw = 1 << bs;
     int dct_y_offset = ctx->dct_y_offset;
     int dct_uv_offset = ctx->dct_uv_offset;
-    int linesize = ctx->m.linesize;
-    int uvlinesize = ctx->m.uvlinesize;
+    int linesize = s->linesize;
+    int uvlinesize = s->uvlinesize;
     const uint8_t *ptr_y = ctx->thread[0]->src[0] +
-                           ((mb_y << 4) * ctx->m.linesize) + (mb_x << bs + 1);
+                           ((mb_y << 4) * s->linesize) + (mb_x << bs + 1);
     const uint8_t *ptr_u = ctx->thread[0]->src[1] +
-                           ((mb_y << 4) * ctx->m.uvlinesize) + (mb_x << bs + ctx->is_444);
+                           ((mb_y << 4) * s->uvlinesize) + (mb_x << bs + ctx->is_444);
     const uint8_t *ptr_v = ctx->thread[0]->src[2] +
-                           ((mb_y << 4) * ctx->m.uvlinesize) + (mb_x << bs + ctx->is_444);
-    PixblockDSPContext *pdsp = &ctx->m.pdsp;
-    VideoDSPContext *vdsp = &ctx->m.vdsp;
-
-    if (ctx->bit_depth != 10 && vdsp->emulated_edge_mc && ((mb_x << 4) + 16 > ctx->m.avctx->width ||
-                                                           (mb_y << 4) + 16 > ctx->m.avctx->height)) {
-        int y_w = ctx->m.avctx->width  - (mb_x << 4);
-        int y_h = ctx->m.avctx->height - (mb_y << 4);
+                           ((mb_y << 4) * s->uvlinesize) + (mb_x << bs + ctx->is_444);
+    PixblockDSPContext *pdsp = &s->pdsp;
+    VideoDSPContext *vdsp = &s->vdsp;
+
+    if (ctx->bit_depth != 10 && vdsp->emulated_edge_mc && ((mb_x << 4) + 16 > s->avctx->width ||
+                                                           (mb_y << 4) + 16 > s->avctx->height)) {
+        int y_w = s->avctx->width  - (mb_x << 4);
+        int y_h = s->avctx->height - (mb_y << 4);
         int uv_w = (y_w + 1) / 2;
         int uv_h = y_h;
         linesize = 16;
         uvlinesize = 8;
 
         vdsp->emulated_edge_mc(&ctx->edge_buf_y[0], ptr_y,
-                               linesize, ctx->m.linesize,
+                               linesize, s->linesize,
                                linesize, 16,
                                0, 0, y_w, y_h);
         vdsp->emulated_edge_mc(&ctx->edge_buf_uv[0][0], ptr_u,
-                               uvlinesize, ctx->m.uvlinesize,
+                               uvlinesize, s->uvlinesize,
                                uvlinesize, 16,
                                0, 0, uv_w, uv_h);
         vdsp->emulated_edge_mc(&ctx->edge_buf_uv[1][0], ptr_v,
-                               uvlinesize, ctx->m.uvlinesize,
+                               uvlinesize, s->uvlinesize,
                                uvlinesize, 16,
                                0, 0, uv_w, uv_h);
 
@@ -720,25 +726,25 @@ void dnxhd_get_blocks(DNXHDEncContext *ctx, int mb_x, int mb_y)
         ptr_y = &ctx->edge_buf_y[0];
         ptr_u = &ctx->edge_buf_uv[0][0];
         ptr_v = &ctx->edge_buf_uv[1][0];
-    } else if (ctx->bit_depth == 10 && vdsp->emulated_edge_mc && ((mb_x << 4) + 16 > ctx->m.avctx->width ||
-                                                                  (mb_y << 4) + 16 > ctx->m.avctx->height)) {
-        int y_w = ctx->m.avctx->width  - (mb_x << 4);
-        int y_h = ctx->m.avctx->height - (mb_y << 4);
+    } else if (ctx->bit_depth == 10 && vdsp->emulated_edge_mc && ((mb_x << 4) + 16 > s->avctx->width ||
+                                                                  (mb_y << 4) + 16 > s->avctx->height)) {
+        int y_w = s->avctx->width  - (mb_x << 4);
+        int y_h = s->avctx->height - (mb_y << 4);
         int uv_w = ctx->is_444 ? y_w : (y_w + 1) / 2;
         int uv_h = y_h;
         linesize = 32;
         uvlinesize = 16 + 16 * ctx->is_444;
 
         vdsp->emulated_edge_mc(&ctx->edge_buf_y[0], ptr_y,
-                               linesize, ctx->m.linesize,
+                               linesize, s->linesize,
                                linesize / 2, 16,
                                0, 0, y_w, y_h);
         vdsp->emulated_edge_mc(&ctx->edge_buf_uv[0][0], ptr_u,
-                               uvlinesize, ctx->m.uvlinesize,
+                               uvlinesize, s->uvlinesize,
                                uvlinesize / 2, 16,
                                0, 0, uv_w, uv_h);
         vdsp->emulated_edge_mc(&ctx->edge_buf_uv[1][0], ptr_v,
-                               uvlinesize, ctx->m.uvlinesize,
+                               uvlinesize, s->uvlinesize,
                                uvlinesize / 2, 16,
                                0, 0, uv_w, uv_h);
 
@@ -755,7 +761,7 @@ void dnxhd_get_blocks(DNXHDEncContext *ctx, int mb_x, int mb_y)
         pdsp->get_pixels(ctx->blocks[2], ptr_u,      uvlinesize);
         pdsp->get_pixels(ctx->blocks[3], ptr_v,      uvlinesize);
 
-        if (mb_y + 1 == ctx->m.mb_height && ctx->m.avctx->height == 1080) {
+        if (mb_y + 1 == s->mb_height && s->avctx->height == 1080) {
             if (ctx->interlaced) {
                 ctx->get_pixels_8x4_sym(ctx->blocks[4],
                                         ptr_y + dct_y_offset,
@@ -821,17 +827,18 @@ static int dnxhd_calc_bits_thread(AVCodecContext *avctx, void *arg,
                                   int jobnr, int threadnr)
 {
     DNXHDEncContext *ctx = avctx->priv_data;
+    MPVEncContext *const s = &ctx->m.common;
     int mb_y = jobnr, mb_x;
     int qscale = ctx->qscale;
     LOCAL_ALIGNED_16(int16_t, block, [64]);
     ctx = ctx->thread[threadnr];
 
-    ctx->m.last_dc[0] =
-    ctx->m.last_dc[1] =
-    ctx->m.last_dc[2] = 1 << (ctx->bit_depth + 2);
+    s->last_dc[0] =
+    s->last_dc[1] =
+    s->last_dc[2] = 1 << (ctx->bit_depth + 2);
 
-    for (mb_x = 0; mb_x < ctx->m.mb_width; mb_x++) {
-        unsigned mb = mb_y * ctx->m.mb_width + mb_x;
+    for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
+        unsigned mb = mb_y * s->mb_width + mb_x;
         int ssd     = 0;
         int ac_bits = 0;
         int dc_bits = 0;
@@ -845,12 +852,12 @@ static int dnxhd_calc_bits_thread(AVCodecContext *avctx, void *arg,
             int n = dnxhd_switch_matrix(ctx, i);
 
             memcpy(block, src_block, 64 * sizeof(*block));
-            last_index = ctx->m.dct_quantize(&ctx->m, block,
+            last_index = s->dct_quantize(s, block,
                                              ctx->is_444 ? 4 * (n > 0): 4 & (2*i),
                                              qscale, &overflow);
             ac_bits   += dnxhd_calc_ac_bits(ctx, block, last_index);
 
-            diff = block[0] - ctx->m.last_dc[n];
+            diff = block[0] - s->last_dc[n];
             if (diff < 0)
                 nbits = av_log2_16bit(-2 * diff);
             else
@@ -859,16 +866,16 @@ static int dnxhd_calc_bits_thread(AVCodecContext *avctx, void *arg,
             av_assert1(nbits < ctx->bit_depth + 4);
             dc_bits += ctx->cid_table->dc_bits[nbits] + nbits;
 
-            ctx->m.last_dc[n] = block[0];
+            s->last_dc[n] = block[0];
 
             if (avctx->mb_decision == FF_MB_DECISION_RD || !RC_VARIANCE) {
                 dnxhd_unquantize_c(ctx, block, i, qscale, last_index);
-                ctx->m.idsp.idct(block);
+                s->idsp.idct(block);
                 ssd += dnxhd_ssd_block(block, src_block);
             }
         }
-        ctx->mb_rc[(qscale * ctx->m.mb_num) + mb].ssd  = ssd;
-        ctx->mb_rc[(qscale * ctx->m.mb_num) + mb].bits = ac_bits + dc_bits + 12 +
+        ctx->mb_rc[(qscale * s->mb_num) + mb].ssd  = ssd;
+        ctx->mb_rc[(qscale * s->mb_num) + mb].bits = ac_bits + dc_bits + 12 +
                                      (1 + ctx->is_444) * 8 * ctx->vlc_bits[0];
     }
     return 0;
@@ -878,50 +885,52 @@ static int dnxhd_encode_thread(AVCodecContext *avctx, void *arg,
                                int jobnr, int threadnr)
 {
     DNXHDEncContext *ctx = avctx->priv_data;
+    MPVEncContext *const s = &ctx->m.common;
     int mb_y = jobnr, mb_x;
     ctx = ctx->thread[threadnr];
-    init_put_bits(&ctx->m.pb, (uint8_t *)arg + ctx->data_offset + ctx->slice_offs[jobnr],
+    init_put_bits(&s->pb, (uint8_t *)arg + ctx->data_offset + ctx->slice_offs[jobnr],
                   ctx->slice_size[jobnr]);
 
-    ctx->m.last_dc[0] =
-    ctx->m.last_dc[1] =
-    ctx->m.last_dc[2] = 1 << (ctx->bit_depth + 2);
-    for (mb_x = 0; mb_x < ctx->m.mb_width; mb_x++) {
-        unsigned mb = mb_y * ctx->m.mb_width + mb_x;
+    s->last_dc[0] =
+    s->last_dc[1] =
+    s->last_dc[2] = 1 << (ctx->bit_depth + 2);
+    for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
+        unsigned mb = mb_y * s->mb_width + mb_x;
         int qscale = ctx->mb_qscale[mb];
         int i;
 
-        put_bits(&ctx->m.pb, 11, qscale);
-        put_bits(&ctx->m.pb, 1, avctx->pix_fmt == AV_PIX_FMT_YUV444P10);
+        put_bits(&s->pb, 11, qscale);
+        put_bits(&s->pb, 1, avctx->pix_fmt == AV_PIX_FMT_YUV444P10);
 
         dnxhd_get_blocks(ctx, mb_x, mb_y);
 
         for (i = 0; i < 8 + 4 * ctx->is_444; i++) {
             int16_t *block = ctx->blocks[i];
             int overflow, n = dnxhd_switch_matrix(ctx, i);
-            int last_index = ctx->m.dct_quantize(&ctx->m, block,
+            int last_index = s->dct_quantize(s, block,
                                                  ctx->is_444 ? (((i >> 1) % 3) < 1 ? 0 : 4): 4 & (2*i),
                                                  qscale, &overflow);
 
             dnxhd_encode_block(ctx, block, last_index, n);
         }
     }
-    if (put_bits_count(&ctx->m.pb) & 31)
-        put_bits(&ctx->m.pb, 32 - (put_bits_count(&ctx->m.pb) & 31), 0);
-    flush_put_bits(&ctx->m.pb);
+    if (put_bits_count(&s->pb) & 31)
+        put_bits(&s->pb, 32 - (put_bits_count(&s->pb) & 31), 0);
+    flush_put_bits(&s->pb);
     return 0;
 }
 
 static void dnxhd_setup_threads_slices(DNXHDEncContext *ctx)
 {
+    MPVEncContext *const s = &ctx->m.common;
     int mb_y, mb_x;
     int offset = 0;
-    for (mb_y = 0; mb_y < ctx->m.mb_height; mb_y++) {
+    for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
         int thread_size;
         ctx->slice_offs[mb_y] = offset;
         ctx->slice_size[mb_y] = 0;
-        for (mb_x = 0; mb_x < ctx->m.mb_width; mb_x++) {
-            unsigned mb = mb_y * ctx->m.mb_width + mb_x;
+        for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
+            unsigned mb = mb_y * s->mb_width + mb_x;
             ctx->slice_size[mb_y] += ctx->mb_bits[mb];
         }
         ctx->slice_size[mb_y]   = (ctx->slice_size[mb_y] + 31) & ~31;
@@ -935,28 +944,29 @@ static int dnxhd_mb_var_thread(AVCodecContext *avctx, void *arg,
                                int jobnr, int threadnr)
 {
     DNXHDEncContext *ctx = avctx->priv_data;
+    MPVEncContext *const s = &ctx->m.common;
     int mb_y = jobnr, mb_x, x, y;
-    int partial_last_row = (mb_y == ctx->m.mb_height - 1) &&
+    int partial_last_row = (mb_y == s->mb_height - 1) &&
                            ((avctx->height >> ctx->interlaced) & 0xF);
 
     ctx = ctx->thread[threadnr];
     if (ctx->bit_depth == 8) {
-        uint8_t *pix = ctx->thread[0]->src[0] + ((mb_y << 4) * ctx->m.linesize);
-        for (mb_x = 0; mb_x < ctx->m.mb_width; ++mb_x, pix += 16) {
-            unsigned mb = mb_y * ctx->m.mb_width + mb_x;
+        uint8_t *pix = ctx->thread[0]->src[0] + ((mb_y << 4) * s->linesize);
+        for (mb_x = 0; mb_x < s->mb_width; ++mb_x, pix += 16) {
+            unsigned mb = mb_y * s->mb_width + mb_x;
             int sum;
             int varc;
 
             if (!partial_last_row && mb_x * 16 <= avctx->width - 16 && (avctx->width % 16) == 0) {
-                sum  = ctx->m.mpvencdsp.pix_sum(pix, ctx->m.linesize);
-                varc = ctx->m.mpvencdsp.pix_norm1(pix, ctx->m.linesize);
+                sum  = s->mpvencdsp.pix_sum(pix, s->linesize);
+                varc = s->mpvencdsp.pix_norm1(pix, s->linesize);
             } else {
                 int bw = FFMIN(avctx->width - 16 * mb_x, 16);
                 int bh = FFMIN((avctx->height >> ctx->interlaced) - 16 * mb_y, 16);
                 sum = varc = 0;
                 for (y = 0; y < bh; y++) {
                     for (x = 0; x < bw; x++) {
-                        uint8_t val = pix[x + y * ctx->m.linesize];
+                        uint8_t val = pix[x + y * s->linesize];
                         sum  += val;
                         varc += val * val;
                     }
@@ -968,11 +978,11 @@ static int dnxhd_mb_var_thread(AVCodecContext *avctx, void *arg,
             ctx->mb_cmp[mb].mb    = mb;
         }
     } else { // 10-bit
-        const int linesize = ctx->m.linesize >> 1;
-        for (mb_x = 0; mb_x < ctx->m.mb_width; ++mb_x) {
+        const int linesize = s->linesize >> 1;
+        for (mb_x = 0; mb_x < s->mb_width; ++mb_x) {
             uint16_t *pix = (uint16_t *)ctx->thread[0]->src[0] +
                             ((mb_y << 4) * linesize) + (mb_x << 4);
-            unsigned mb  = mb_y * ctx->m.mb_width + mb_x;
+            unsigned mb  = mb_y * s->mb_width + mb_x;
             int sum = 0;
             int sqsum = 0;
             int bw = FFMIN(avctx->width - 16 * mb_x, 16);
@@ -1001,6 +1011,7 @@ static int dnxhd_mb_var_thread(AVCodecContext *avctx, void *arg,
 
 static int dnxhd_encode_rdo(AVCodecContext *avctx, DNXHDEncContext *ctx)
 {
+    MPVEncContext *const s = &ctx->m.common;
     int lambda, up_step, down_step;
     int last_lower = INT_MAX, last_higher = 0;
     int x, y, q;
@@ -1008,7 +1019,7 @@ static int dnxhd_encode_rdo(AVCodecContext *avctx, DNXHDEncContext *ctx)
     for (q = 1; q < avctx->qmax; q++) {
         ctx->qscale = q;
         avctx->execute2(avctx, dnxhd_calc_bits_thread,
-                        NULL, NULL, ctx->m.mb_height);
+                        NULL, NULL, s->mb_height);
     }
     up_step = down_step = 2 << LAMBDA_FRAC_BITS;
     lambda  = ctx->lambda;
@@ -1020,14 +1031,14 @@ static int dnxhd_encode_rdo(AVCodecContext *avctx, DNXHDEncContext *ctx)
             lambda++;
             end = 1; // need to set final qscales/bits
         }
-        for (y = 0; y < ctx->m.mb_height; y++) {
-            for (x = 0; x < ctx->m.mb_width; x++) {
+        for (y = 0; y < s->mb_height; y++) {
+            for (x = 0; x < s->mb_width; x++) {
                 unsigned min = UINT_MAX;
                 int qscale = 1;
-                int mb     = y * ctx->m.mb_width + x;
+                int mb     = y * s->mb_width + x;
                 int rc = 0;
                 for (q = 1; q < avctx->qmax; q++) {
-                    int i = (q*ctx->m.mb_num) + mb;
+                    int i = (q*s->mb_num) + mb;
                     unsigned score = ctx->mb_rc[i].bits * lambda +
                                      ((unsigned) ctx->mb_rc[i].ssd << LAMBDA_FRAC_BITS);
                     if (score < min) {
@@ -1078,6 +1089,7 @@ static int dnxhd_encode_rdo(AVCodecContext *avctx, DNXHDEncContext *ctx)
 
 static int dnxhd_find_qscale(DNXHDEncContext *ctx)
 {
+    MPVEncContext *const s = &ctx->m.common;
     int bits = 0;
     int up_step = 1;
     int down_step = 1;
@@ -1091,11 +1103,11 @@ static int dnxhd_find_qscale(DNXHDEncContext *ctx)
         bits = 0;
         ctx->qscale = qscale;
         // XXX avoid recalculating bits
-        ctx->m.avctx->execute2(ctx->m.avctx, dnxhd_calc_bits_thread,
-                               NULL, NULL, ctx->m.mb_height);
-        for (y = 0; y < ctx->m.mb_height; y++) {
-            for (x = 0; x < ctx->m.mb_width; x++)
-                bits += ctx->mb_rc[(qscale*ctx->m.mb_num) + (y*ctx->m.mb_width+x)].bits;
+        s->avctx->execute2(s->avctx, dnxhd_calc_bits_thread,
+                               NULL, NULL, s->mb_height);
+        for (y = 0; y < s->mb_height; y++) {
+            for (x = 0; x < s->mb_width; x++)
+                bits += ctx->mb_rc[(qscale*s->mb_num) + (y*s->mb_width+x)].bits;
             bits = (bits+31)&~31; // padding
             if (bits > ctx->frame_bits)
                 break;
@@ -1124,7 +1136,7 @@ static int dnxhd_find_qscale(DNXHDEncContext *ctx)
             else
                 qscale += up_step++;
             down_step = 1;
-            if (qscale >= ctx->m.avctx->qmax)
+            if (qscale >= s->avctx->qmax)
                 return AVERROR(EINVAL);
         }
     }
@@ -1190,25 +1202,26 @@ static void radix_sort(RCCMPEntry *data, RCCMPEntry *tmp, int size)
 
 static int dnxhd_encode_fast(AVCodecContext *avctx, DNXHDEncContext *ctx)
 {
+    MPVEncContext *const s = &ctx->m.common;
     int max_bits = 0;
     int ret, x, y;
     if ((ret = dnxhd_find_qscale(ctx)) < 0)
         return ret;
-    for (y = 0; y < ctx->m.mb_height; y++) {
-        for (x = 0; x < ctx->m.mb_width; x++) {
-            int mb = y * ctx->m.mb_width + x;
-            int rc = (ctx->qscale * ctx->m.mb_num ) + mb;
+    for (y = 0; y < s->mb_height; y++) {
+        for (x = 0; x < s->mb_width; x++) {
+            int mb = y * s->mb_width + x;
+            int rc = (ctx->qscale * s->mb_num ) + mb;
             int delta_bits;
             ctx->mb_qscale[mb] = ctx->qscale;
             ctx->mb_bits[mb] = ctx->mb_rc[rc].bits;
             max_bits += ctx->mb_rc[rc].bits;
             if (!RC_VARIANCE) {
                 delta_bits = ctx->mb_rc[rc].bits -
-                             ctx->mb_rc[rc + ctx->m.mb_num].bits;
+                             ctx->mb_rc[rc + s->mb_num].bits;
                 ctx->mb_cmp[mb].mb = mb;
                 ctx->mb_cmp[mb].value =
                     delta_bits ? ((ctx->mb_rc[rc].ssd -
-                                   ctx->mb_rc[rc + ctx->m.mb_num].ssd) * 100) /
+                                   ctx->mb_rc[rc + s->mb_num].ssd) * 100) /
                                   delta_bits
                                : INT_MIN; // avoid increasing qscale
             }
@@ -1218,15 +1231,15 @@ static int dnxhd_encode_fast(AVCodecContext *avctx, DNXHDEncContext *ctx)
     if (!ret) {
         if (RC_VARIANCE)
             avctx->execute2(avctx, dnxhd_mb_var_thread,
-                            NULL, NULL, ctx->m.mb_height);
-        radix_sort(ctx->mb_cmp, ctx->mb_cmp_tmp, ctx->m.mb_num);
-        for (x = 0; x < ctx->m.mb_num && max_bits > ctx->frame_bits; x++) {
+                            NULL, NULL, s->mb_height);
+        radix_sort(ctx->mb_cmp, ctx->mb_cmp_tmp, s->mb_num);
+        for (x = 0; x < s->mb_num && max_bits > ctx->frame_bits; x++) {
             int mb = ctx->mb_cmp[x].mb;
-            int rc = (ctx->qscale * ctx->m.mb_num ) + mb;
+            int rc = (ctx->qscale * s->mb_num ) + mb;
             max_bits -= ctx->mb_rc[rc].bits -
-                        ctx->mb_rc[rc + ctx->m.mb_num].bits;
+                        ctx->mb_rc[rc + s->mb_num].bits;
             ctx->mb_qscale[mb] = ctx->qscale + 1;
-            ctx->mb_bits[mb]   = ctx->mb_rc[rc + ctx->m.mb_num].bits;
+            ctx->mb_bits[mb]   = ctx->mb_rc[rc + s->mb_num].bits;
         }
     }
     return 0;
@@ -1234,13 +1247,13 @@ static int dnxhd_encode_fast(AVCodecContext *avctx, DNXHDEncContext *ctx)
 
 static void dnxhd_load_picture(DNXHDEncContext *ctx, const AVFrame *frame)
 {
-    int i;
+    MPVEncContext *const s = &ctx->m.common;
 
-    for (i = 0; i < ctx->m.avctx->thread_count; i++) {
-        ctx->thread[i]->m.linesize    = frame->linesize[0] << ctx->interlaced;
-        ctx->thread[i]->m.uvlinesize  = frame->linesize[1] << ctx->interlaced;
-        ctx->thread[i]->dct_y_offset  = ctx->m.linesize  *8;
-        ctx->thread[i]->dct_uv_offset = ctx->m.uvlinesize*8;
+    for (int i = 0; i < s->avctx->thread_count; i++) {
+        ctx->thread[i]->m.common.linesize    = frame->linesize[0] << ctx->interlaced;
+        ctx->thread[i]->m.common.uvlinesize  = frame->linesize[1] << ctx->interlaced;
+        ctx->thread[i]->dct_y_offset  = s->linesize  *8;
+        ctx->thread[i]->dct_uv_offset = s->uvlinesize*8;
     }
 
     ctx->cur_field = frame->interlaced_frame && !frame->top_field_first;
@@ -1250,6 +1263,7 @@ static int dnxhd_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
                                 const AVFrame *frame, int *got_packet)
 {
     DNXHDEncContext *ctx = avctx->priv_data;
+    MPVEncContext *const s = &ctx->m.common;
     int first_field = 1;
     int offset, i, ret;
     uint8_t *buf;
@@ -1282,13 +1296,13 @@ encode_coding_unit:
     dnxhd_setup_threads_slices(ctx);
 
     offset = 0;
-    for (i = 0; i < ctx->m.mb_height; i++) {
+    for (i = 0; i < s->mb_height; i++) {
         AV_WB32(ctx->msip + i * 4, offset);
         offset += ctx->slice_size[i];
         av_assert1(!(ctx->slice_size[i] & 3));
     }
 
-    avctx->execute2(avctx, dnxhd_encode_thread, buf, NULL, ctx->m.mb_height);
+    avctx->execute2(avctx, dnxhd_encode_thread, buf, NULL, s->mb_height);
 
     av_assert1(ctx->data_offset + offset + 4 <= ctx->coding_unit_size);
     memset(buf + ctx->data_offset + offset, 0,
diff --git a/libavcodec/flvenc.c b/libavcodec/flvenc.c
index 41e04e1abe..ba6bce029e 100644
--- a/libavcodec/flvenc.c
+++ b/libavcodec/flvenc.c
@@ -23,8 +23,9 @@
 #include "mpegvideodata.h"
 #include "mpegvideoenc.h"
 
-void ff_flv_encode_picture_header(MPVMainEncContext *s, int picture_number)
+void ff_flv_encode_picture_header(MPVMainEncContext *m, int picture_number)
 {
+    MPVEncContext *const s = &m->common;
     int format;
 
     align_put_bits(&s->pb);
diff --git a/libavcodec/h261enc.c b/libavcodec/h261enc.c
index 5c9664ea57..9c8d9d1b08 100644
--- a/libavcodec/h261enc.c
+++ b/libavcodec/h261enc.c
@@ -60,9 +60,10 @@ int ff_h261_get_picture_format(int width, int height)
         return AVERROR(EINVAL);
 }
 
-void ff_h261_encode_picture_header(MPVMainEncContext *s, int picture_number)
+void ff_h261_encode_picture_header(MPVMainEncContext *m, int picture_number)
 {
-    H261EncContext *const h = (H261EncContext *)s;
+    H261EncContext *const h = (H261EncContext *)m;
+    MPVEncContext  *const s = &m->common;
     int format, temp_ref;
 
     align_put_bits(&s->pb);
@@ -175,9 +176,8 @@ static inline int get_cbp(MPVEncContext *s, int16_t block[6][64])
  * @param block the 8x8 block
  * @param n block index (0-3 are luma, 4-5 are chroma)
  */
-static void h261_encode_block(H261EncContext *h, int16_t *block, int n)
+static void h261_encode_block(MPVEncContext *s, int16_t *block, int n)
 {
-    MPVEncContext *const s = &h->s;
     int level, run, i, j, last_index, last_non_zero, sign, slevel, code;
     RLTable *rl;
 
@@ -326,7 +326,7 @@ void ff_h261_encode_mb(MPVEncContext *s, int16_t block[6][64],
     }
     for (i = 0; i < 6; i++)
         /* encode each block */
-        h261_encode_block(h, block[i], i);
+        h261_encode_block(s, block[i], i);
 
     if (!IS_16X16(com->mtype)) {
         s->last_mv[0][0][0] = 0;
@@ -381,9 +381,10 @@ static av_cold void h261_encode_init_static(void)
     init_uni_h261_rl_tab(&ff_h261_rl_tcoeff, uni_h261_rl_len);
 }
 
-av_cold void ff_h261_encode_init(MPVMainEncContext *s)
+av_cold void ff_h261_encode_init(MPVMainEncContext *m)
 {
-    H261EncContext *const h = (H261EncContext*)s;
+    H261EncContext *const h = (H261EncContext*)m;
+    MPVEncContext  *const s = &m->common;
     static AVOnce init_static_once = AV_ONCE_INIT;
 
     s->private_ctx = &h->common;
diff --git a/libavcodec/ituh263enc.c b/libavcodec/ituh263enc.c
index e0b42dd442..97173bfdc6 100644
--- a/libavcodec/ituh263enc.c
+++ b/libavcodec/ituh263enc.c
@@ -102,8 +102,9 @@ av_const int ff_h263_aspect_to_info(AVRational aspect){
     return FF_ASPECT_EXTENDED;
 }
 
-void ff_h263_encode_picture_header(MPVMainEncContext *s, int picture_number)
+void ff_h263_encode_picture_header(MPVMainEncContext *m, int picture_number)
 {
+    MPVEncContext *const s = &m->common;
     int format, coded_frame_rate, coded_frame_rate_base, i, temp_ref;
     int best_clock_code=1;
     int best_divisor=60;
@@ -266,12 +267,13 @@ void ff_h263_encode_gob_header(MPVEncContext *s, int mb_line)
 /**
  * modify qscale so that encoding is actually possible in H.263 (limit difference to -2..2)
  */
-void ff_clean_h263_qscales(MPVMainEncContext *s)
+void ff_clean_h263_qscales(MPVMainEncContext *m)
 {
+    MPVEncContext *const s = &m->common;
     int i;
     int8_t * const qscale_table = s->current_picture.qscale_table;
 
-    ff_init_qscale_tab(s);
+    ff_init_qscale_tab(m);
 
     for(i=1; i<s->mb_num; i++){
         if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i-1] ] >2)
@@ -812,8 +814,9 @@ static av_cold void h263_encode_init_static(void)
     init_mv_penalty_and_fcode();
 }
 
-av_cold void ff_h263_encode_init(MPVMainEncContext *s)
+av_cold void ff_h263_encode_init(MPVMainEncContext *m)
 {
+    MPVEncContext *const s = &m->common;
     static AVOnce init_static_once = AV_ONCE_INIT;
 
     s->me.mv_penalty= mv_penalty; // FIXME exact table for MSMPEG4 & H.263+
@@ -878,7 +881,7 @@ void ff_h263_encode_mba(MPVEncContext *s)
     put_bits(&s->pb, ff_mba_length[i], mb_pos);
 }
 
-#define OFFSET(x) offsetof(MPVMainEncContext, x)
+#define OFFSET(x) offsetof(MPVMainEncContext, common.x)
 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
 static const AVOption h263_options[] = {
     { "obmc",         "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
diff --git a/libavcodec/mjpegenc.c b/libavcodec/mjpegenc.c
index 596accfc50..fd87186fbc 100644
--- a/libavcodec/mjpegenc.c
+++ b/libavcodec/mjpegenc.c
@@ -75,8 +75,9 @@ static av_cold void init_uni_ac_vlc(const uint8_t huff_size_ac[256],
     }
 }
 
-static void mjpeg_encode_picture_header(MPVMainEncContext *s)
+static void mjpeg_encode_picture_header(MPVMainEncContext *m)
 {
+    MPVEncContext *const s = &m->common;
     ff_mjpeg_encode_picture_header(s->avctx, &s->pb, s->mjpeg_ctx,
                                    &s->intra_scantable, 0,
                                    s->intra_matrix, s->chroma_intra_matrix,
@@ -87,13 +88,13 @@ static void mjpeg_encode_picture_header(MPVMainEncContext *s)
         s->thread_context[i]->esc_pos = 0;
 }
 
-void ff_mjpeg_amv_encode_picture_header(MPVMainEncContext *s)
+void ff_mjpeg_amv_encode_picture_header(MPVMainEncContext *main)
 {
-    MJPEGEncContext *const m = (MJPEGEncContext*)s;
-    av_assert2(s->mjpeg_ctx == &m->mjpeg);
+    MJPEGEncContext *const m = (MJPEGEncContext*)main;
+    av_assert2(main->common.mjpeg_ctx == &m->mjpeg);
     /* s->huffman == HUFFMAN_TABLE_OPTIMAL can only be true for MJPEG. */
     if (!CONFIG_MJPEG_ENCODER || m->mjpeg.huffman != HUFFMAN_TABLE_OPTIMAL)
-        mjpeg_encode_picture_header(s);
+        mjpeg_encode_picture_header(main);
 }
 
 #if CONFIG_MJPEG_ENCODER
@@ -235,7 +236,9 @@ int ff_mjpeg_encode_stuffing(MPVEncContext *s)
         s->intra_chroma_ac_vlc_length      =
         s->intra_chroma_ac_vlc_last_length = m->uni_chroma_ac_vlc_len;
 
-        mjpeg_encode_picture_header(s);
+        /* HUFFMAN_TABLE_OPTIMAL is incompatible with slice threading,
+         * therefore the following cast is allowed. */
+        mjpeg_encode_picture_header((MPVMainEncContext*)s);
         mjpeg_encode_picture_frame(s);
     }
 #endif
@@ -260,7 +263,7 @@ fail:
     return ret;
 }
 
-static int alloc_huffman(MPVMainEncContext *s)
+static int alloc_huffman(MPVEncContext *s)
 {
     MJpegContext *m = s->mjpeg_ctx;
     size_t num_mbs, num_blocks, num_codes;
@@ -288,9 +291,10 @@ static int alloc_huffman(MPVMainEncContext *s)
     return 0;
 }
 
-av_cold int ff_mjpeg_encode_init(MPVMainEncContext *s)
+av_cold int ff_mjpeg_encode_init(MPVMainEncContext *main)
 {
-    MJpegContext *const m = &((MJPEGEncContext*)s)->mjpeg;
+    MJpegContext *const m = &((MJPEGEncContext*)main)->mjpeg;
+    MPVEncContext *const s = &main->common;
     int ret, use_slices;
 
     s->mjpeg_ctx = m;
@@ -589,7 +593,7 @@ void ff_mjpeg_encode_mb(MPVEncContext *s, int16_t block[12][64])
 static int amv_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
                               const AVFrame *pic_arg, int *got_packet)
 {
-    MPVMainEncContext *const s = avctx->priv_data;
+    MPVEncContext *const s = avctx->priv_data;
     AVFrame *pic;
     int i, ret;
     int chroma_h_shift, chroma_v_shift;
diff --git a/libavcodec/mpeg12enc.c b/libavcodec/mpeg12enc.c
index 34183cd1d5..4b878b2f90 100644
--- a/libavcodec/mpeg12enc.c
+++ b/libavcodec/mpeg12enc.c
@@ -122,7 +122,8 @@ av_cold void ff_mpeg1_init_uni_ac_vlc(const RLTable *rl, uint8_t *uni_ac_vlc_len
 #if CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER
 static int find_frame_rate_index(MPEG12EncContext *mpeg12)
 {
-    MPVMainEncContext *const s = &mpeg12->mpeg;
+    MPVMainEncContext *const m = &mpeg12->mpeg;
+    MPVEncContext     *const s = &m->common;
     int i;
     AVRational bestq = (AVRational) {0, 0};
     AVRational ext;
@@ -163,7 +164,8 @@ static int find_frame_rate_index(MPEG12EncContext *mpeg12)
 static av_cold int encode_init(AVCodecContext *avctx)
 {
     MPEG12EncContext *const mpeg12 = avctx->priv_data;
-    MPVMainEncContext *const s = &mpeg12->mpeg;
+    MPVMainEncContext *const m = &mpeg12->mpeg;
+    MPVEncContext     *const s = &m->common;
     int ret;
     int max_size = avctx->codec_id == AV_CODEC_ID_MPEG2VIDEO ? 16383 : 4095;
 
@@ -263,9 +265,10 @@ static void put_header(MPVEncContext *s, int header)
 }
 
 /* put sequence header if needed */
-static void mpeg1_encode_sequence_header(MPVMainEncContext *s)
+static void mpeg1_encode_sequence_header(MPVMainEncContext *m)
 {
-    MPEG12EncContext *const mpeg12 = (MPEG12EncContext*)s;
+    MPEG12EncContext *const mpeg12 = (MPEG12EncContext*)m;
+    MPVEncContext    *const      s = &m->common;
     unsigned int vbv_buffer_size, fps, v;
     int constraint_parameter_flag;
     AVRational framerate = ff_mpeg12_frame_rate_tab[mpeg12->frame_rate_index];
@@ -451,11 +454,12 @@ void ff_mpeg1_encode_slice_header(MPVEncContext *s)
     put_bits(&s->pb, 1, 0);
 }
 
-void ff_mpeg1_encode_picture_header(MPVMainEncContext *s, int picture_number)
+void ff_mpeg1_encode_picture_header(MPVMainEncContext *m, int picture_number)
 {
-    MPEG12EncContext *const mpeg12 = (MPEG12EncContext*)s;
+    MPEG12EncContext *const mpeg12 = (MPEG12EncContext*)m;
+    MPVEncContext    *const      s = &m->common;
     AVFrameSideData *side_data;
-    mpeg1_encode_sequence_header(s);
+    mpeg1_encode_sequence_header(m);
 
     /* MPEG-1 picture header */
     put_header(s, PICTURE_START_CODE);
@@ -1131,11 +1135,12 @@ static av_cold void mpeg12_encode_init_static(void)
             fcode_tab[mv + MAX_MV] = f_code;
 }
 
-av_cold void ff_mpeg1_encode_init(MPVMainEncContext *s)
+av_cold void ff_mpeg1_encode_init(MPVMainEncContext *m)
 {
+    MPVEncContext *const s = &m->common;
     static AVOnce init_static_once = AV_ONCE_INIT;
 
-    ff_mpeg12_common_init(s);
+    ff_mpeg12_common_init(&m->common);
 
     s->me.mv_penalty = mv_penalty;
     s->fcode_tab     = fcode_tab;
diff --git a/libavcodec/mpeg4videoenc.c b/libavcodec/mpeg4videoenc.c
index 03d53ab56b..c7b0b3ec02 100644
--- a/libavcodec/mpeg4videoenc.c
+++ b/libavcodec/mpeg4videoenc.c
@@ -216,12 +216,13 @@ static inline int decide_ac_pred(MPVEncContext *s, int16_t block[6][64],
 /**
  * modify mb_type & qscale so that encoding is actually possible in MPEG-4
  */
-void ff_clean_mpeg4_qscales(MPVMainEncContext *s)
+void ff_clean_mpeg4_qscales(MPVMainEncContext *m)
 {
+    MPVEncContext *const s = &m->common;
     int i;
     int8_t *const qscale_table = s->current_picture.qscale_table;
 
-    ff_clean_h263_qscales(s);
+    ff_clean_h263_qscales(m);
 
     if (s->pict_type == AV_PICTURE_TYPE_B) {
         int odd = 0;
@@ -876,8 +877,9 @@ void ff_mpeg4_stuffing(PutBitContext *pbc)
 }
 
 /* must be called before writing the header */
-void ff_set_mpeg4_time(MPVMainEncContext *s)
+void ff_set_mpeg4_time(MPVMainEncContext *m)
 {
+    MPVEncContext *const s = &m->common;
     if (s->pict_type == AV_PICTURE_TYPE_B) {
         ff_mpeg4_init_direct_mv(s);
     } else {
@@ -886,8 +888,9 @@ void ff_set_mpeg4_time(MPVMainEncContext *s)
     }
 }
 
-static void mpeg4_encode_gop_header(MPVMainEncContext *s)
+static void mpeg4_encode_gop_header(MPVMainEncContext *m)
 {
+    MPVEncContext *const s = &m->common;
     int64_t hours, minutes, seconds;
     int64_t time;
 
@@ -916,8 +919,9 @@ static void mpeg4_encode_gop_header(MPVMainEncContext *s)
     ff_mpeg4_stuffing(&s->pb);
 }
 
-static void mpeg4_encode_visual_object_header(MPVMainEncContext *s)
+static void mpeg4_encode_visual_object_header(MPVMainEncContext *m)
 {
+    MPVEncContext *const s = &m->common;
     int profile_and_level_indication;
     int vo_ver_id;
 
@@ -960,10 +964,11 @@ static void mpeg4_encode_visual_object_header(MPVMainEncContext *s)
     ff_mpeg4_stuffing(&s->pb);
 }
 
-static void mpeg4_encode_vol_header(MPVMainEncContext *s,
+static void mpeg4_encode_vol_header(MPVMainEncContext *m,
                                     int vo_number,
                                     int vol_number)
 {
+    MPVEncContext *const s = &m->common;
     int vo_ver_id, vo_type, aspect_ratio_info;
 
     if (s->max_b_frames || s->quarter_sample) {
@@ -1061,20 +1066,21 @@ static void mpeg4_encode_vol_header(MPVMainEncContext *s,
 }
 
 /* write MPEG-4 VOP header */
-int ff_mpeg4_encode_picture_header(MPVMainEncContext *s, int picture_number)
+int ff_mpeg4_encode_picture_header(MPVMainEncContext *m, int picture_number)
 {
+    MPVEncContext *const s = &m->common;
     uint64_t time_incr;
     int64_t time_div, time_mod;
 
     if (s->pict_type == AV_PICTURE_TYPE_I) {
         if (!(s->avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER)) {
             if (s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT)  // HACK, the reference sw is buggy
-                mpeg4_encode_visual_object_header(s);
+                mpeg4_encode_visual_object_header(m);
             if (s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT || picture_number == 0)  // HACK, the reference sw is buggy
-                mpeg4_encode_vol_header(s, 0, 0);
+                mpeg4_encode_vol_header(m, 0, 0);
         }
         if (!(s->workaround_bugs & FF_BUG_MS))
-            mpeg4_encode_gop_header(s);
+            mpeg4_encode_gop_header(m);
     }
 
     s->partitioned_frame = s->data_partitioning && s->pict_type != AV_PICTURE_TYPE_B;
@@ -1284,7 +1290,8 @@ static av_cold void mpeg4_encode_init_static(void)
 static av_cold int encode_init(AVCodecContext *avctx)
 {
     static AVOnce init_static_once = AV_ONCE_INIT;
-    MPVMainEncContext *const s = avctx->priv_data;
+    MPVMainEncContext *const m = avctx->priv_data;
+    MPVEncContext     *const s = &m->common;
     int ret;
 
     if (avctx->width >= (1<<13) || avctx->height >= (1<<13)) {
@@ -1315,8 +1322,8 @@ static av_cold int encode_init(AVCodecContext *avctx)
         init_put_bits(&s->pb, s->avctx->extradata, 1024);
 
         if (!(s->workaround_bugs & FF_BUG_MS))
-            mpeg4_encode_visual_object_header(s);
-        mpeg4_encode_vol_header(s, 0, 0);
+            mpeg4_encode_visual_object_header(m);
+        mpeg4_encode_vol_header(m, 0, 0);
 
 //            ff_mpeg4_stuffing(&s->pb); ?
         flush_put_bits(&s->pb);
@@ -1376,13 +1383,13 @@ void ff_mpeg4_encode_video_packet_header(MPVEncContext *s)
     put_bits(&s->pb, 1, 0); /* no HEC */
 }
 
-#define OFFSET(x) offsetof(MPVMainEncContext, x)
+#define OFFSET(x) offsetof(MPVMainEncContext, common.x)
 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
 static const AVOption options[] = {
-    { "data_partitioning", "Use data partitioning.",      OFFSET(data_partitioning), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
-    { "alternate_scan",    "Enable alternate scantable.", OFFSET(alternate_scan),    AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
+    { "data_partitioning", "Use data partitioning.",      FF_MPV_OFFSET(data_partitioning), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
+    { "alternate_scan",    "Enable alternate scantable.", FF_MPV_OFFSET(alternate_scan),    AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
     { "mpeg_quant",        "Use MPEG quantizers instead of H.263",
-      OFFSET(mpeg_quant), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, 1, VE },
+      FF_MPV_OFFSET(mpeg_quant), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, 1, VE },
     FF_MPV_COMMON_BFRAME_OPTS
     FF_MPV_COMMON_OPTS
 #if FF_API_MPEGVIDEO_OPTS
diff --git a/libavcodec/mpegvideo_enc.c b/libavcodec/mpegvideo_enc.c
index 5bf135bccf..5f607d9e11 100644
--- a/libavcodec/mpegvideo_enc.c
+++ b/libavcodec/mpegvideo_enc.c
@@ -237,8 +237,9 @@ void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix)
 /**
  * init s->current_picture.qscale_table from s->lambda_table
  */
-void ff_init_qscale_tab(MPVMainEncContext *s)
+void ff_init_qscale_tab(MPVMainEncContext *m)
 {
+    MPVEncContext *const s = &m->common;
     int8_t * const qscale_table = s->current_picture.qscale_table;
     int i;
 
@@ -278,11 +279,13 @@ static void mpv_encode_init_static(void)
  * Set the given MPVMainEncContext to defaults for encoding.
  * the changed fields will not depend upon the prior state of the MPVMainEncContext.
  */
-static void mpv_encode_defaults(MPVMainEncContext *s)
+static void mpv_encode_defaults(MPVMainEncContext *m)
 {
+    MPVMainContext *const com = &m->common;
+    MPVEncContext *const s = com;
     static AVOnce init_static_once = AV_ONCE_INIT;
 
-    ff_mpv_common_defaults(s);
+    ff_mpv_common_defaults(com);
 
     ff_thread_once(&init_static_once, mpv_encode_init_static);
 
@@ -314,11 +317,12 @@ av_cold int ff_dct_encode_init(MPVEncContext *s)
 /* init video encoder */
 av_cold int ff_mpv_encode_init(AVCodecContext *avctx)
 {
-    MPVMainEncContext *const s = avctx->priv_data;
+    MPVMainEncContext *const m = avctx->priv_data;
+    MPVMainContext *const s = &m->common;
     AVCPBProperties *cpb_props;
     int i, ret;
 
-    mpv_encode_defaults(s);
+    mpv_encode_defaults(m);
 
     switch (avctx->pix_fmt) {
     case AV_PIX_FMT_YUVJ444P:
@@ -667,7 +671,7 @@ av_cold int ff_mpv_encode_init(AVCodecContext *avctx)
     case AV_CODEC_ID_AMV:
         s->out_format = FMT_MJPEG;
         s->intra_only = 1; /* force intra only for jpeg */
-        if ((ret = ff_mjpeg_encode_init(s)) < 0)
+        if ((ret = ff_mjpeg_encode_init(m)) < 0)
             return ret;
         avctx->delay = 0;
         s->low_delay = 1;
@@ -678,7 +682,7 @@ av_cold int ff_mpv_encode_init(AVCodecContext *avctx)
         s->intra_only = 1; /* force intra only for SHQ */
         if (!CONFIG_SPEEDHQ_ENCODER)
             return AVERROR_ENCODER_NOT_FOUND;
-        if ((ret = ff_speedhq_encode_init(s)) < 0)
+        if ((ret = ff_speedhq_encode_init(m)) < 0)
             return ret;
         avctx->delay = 0;
         s->low_delay = 1;
@@ -851,14 +855,14 @@ av_cold int ff_mpv_encode_init(AVCodecContext *avctx)
     ff_set_cmp(&s->mecc, s->mecc.frame_skip_cmp, s->frame_skip_cmp);
 
     if (CONFIG_H261_ENCODER && s->out_format == FMT_H261) {
-        ff_h261_encode_init(s);
+        ff_h261_encode_init(m);
     } else if ((CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
                && s->out_format == FMT_MPEG1) {
-        ff_mpeg1_encode_init(s);
+        ff_mpeg1_encode_init(m);
     } else if (CONFIG_H263_ENCODER && s->out_format == FMT_H263) {
-        ff_h263_encode_init(s);
+        ff_h263_encode_init(m);
         if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version)
-            ff_msmpeg4_encode_init(s);
+            ff_msmpeg4_encode_init(m);
     }
 
     /* init q matrix */
@@ -897,7 +901,7 @@ av_cold int ff_mpv_encode_init(AVCodecContext *avctx)
                           31, 0);
     }
 
-    if ((ret = ff_rate_control_init(s)) < 0)
+    if ((ret = ff_rate_control_init(m)) < 0)
         return ret;
 
     if (s->b_frame_strategy == 2) {
@@ -929,12 +933,13 @@ av_cold int ff_mpv_encode_init(AVCodecContext *avctx)
 
 av_cold int ff_mpv_encode_end(AVCodecContext *avctx)
 {
-    MPVMainEncContext *const s = avctx->priv_data;
+    MPVMainEncContext *const m = avctx->priv_data;
+    MPVMainContext  *const s = &m->common;
     int i;
 
-    ff_rate_control_uninit(s);
+    ff_rate_control_uninit(m);
 
-    ff_mpv_common_end(s);
+    ff_mpv_common_end(&m->common);
 
     for (i = 0; i < FF_ARRAY_ELEMS(s->tmp_frames); i++)
         av_frame_free(&s->tmp_frames[i]);
@@ -972,7 +977,7 @@ static int get_sae(uint8_t *src, int ref, int stride)
     return acc;
 }
 
-static int get_intra_count(MPVMainEncContext *s, uint8_t *src,
+static int get_intra_count(MPVEncContext *s, uint8_t *src,
                            uint8_t *ref, int stride)
 {
     int x, y, w, h;
@@ -995,7 +1000,7 @@ static int get_intra_count(MPVMainEncContext *s, uint8_t *src,
     return acc;
 }
 
-static int alloc_picture(MPVMainEncContext *s, Picture *pic, int shared)
+static int alloc_picture(MPVEncContext *s, Picture *pic, int shared)
 {
     return ff_alloc_picture(s->avctx, pic, &s->me, &s->sc, shared, 1,
                             s->chroma_x_shift, s->chroma_y_shift, s->out_format,
@@ -1003,8 +1008,10 @@ static int alloc_picture(MPVMainEncContext *s, Picture *pic, int shared)
                             &s->linesize, &s->uvlinesize);
 }
 
-static int load_input_picture(MPVMainEncContext *s, const AVFrame *pic_arg)
+static int load_input_picture(MPVMainEncContext *m, const AVFrame *pic_arg)
 {
+    MPVMainContext *const com = &m->common;
+    MPVEncContext *const s = com;
     Picture *pic = NULL;
     int64_t pts;
     int i, display_picture_number = 0, ret;
@@ -1154,8 +1161,9 @@ static int load_input_picture(MPVMainEncContext *s, const AVFrame *pic_arg)
     return 0;
 }
 
-static int skip_check(MPVMainEncContext *s, Picture *p, Picture *ref)
+static int skip_check(MPVMainEncContext *m, Picture *p, Picture *ref)
 {
+    MPVEncContext *const s = &m->common;
     int x, y, plane;
     int score = 0;
     int64_t score64 = 0;
@@ -1216,8 +1224,9 @@ static int encode_frame(AVCodecContext *c, AVFrame *frame, AVPacket *pkt)
     return size;
 }
 
-static int estimate_best_b_count(MPVMainEncContext *s)
+static int estimate_best_b_count(MPVMainEncContext *m)
 {
+    MPVEncContext *const s = &m->common;
     AVPacket *pkt;
     const int scale = s->brd_scale;
     int width  = s->width  >> scale;
@@ -1362,8 +1371,9 @@ fail:
     return best_b_count;
 }
 
-static int select_input_picture(MPVMainEncContext *s)
+static int select_input_picture(MPVMainEncContext *m)
 {
+    MPVEncContext *const s = &m->common;
     int i, ret;
 
     for (i = 1; i < MAX_PICTURE_COUNT; i++)
@@ -1375,11 +1385,11 @@ static int select_input_picture(MPVMainEncContext *s)
         if (s->frame_skip_threshold || s->frame_skip_factor) {
             if (s->picture_in_gop_number < s->gop_size &&
                 s->next_picture_ptr &&
-                skip_check(s, s->input_picture[0], s->next_picture_ptr)) {
+                skip_check(m, s->input_picture[0], s->next_picture_ptr)) {
                 // FIXME check that the gop check above is +-1 correct
                 av_frame_unref(s->input_picture[0]->f);
 
-                ff_vbv_update(s, 0);
+                ff_vbv_update(m, 0);
 
                 goto no_output_pic;
             }
@@ -1439,7 +1449,7 @@ static int select_input_picture(MPVMainEncContext *s)
                     s->input_picture[i]->b_frame_score = 0;
                 }
             } else if (s->b_frame_strategy == 2) {
-                b_frames = estimate_best_b_count(s);
+                b_frames = estimate_best_b_count(m);
                 if (b_frames < 0)
                     return b_frames;
             }
@@ -1539,8 +1549,9 @@ no_output_pic:
     return 0;
 }
 
-static void frame_end(MPVMainEncContext *s)
+static void frame_end(MPVMainEncContext *m)
 {
+    MPVEncContext *const s = &m->common;
     if (s->unrestricted_mv &&
         s->current_picture.reference &&
         !s->intra_only) {
@@ -1576,8 +1587,9 @@ static void frame_end(MPVMainEncContext *s)
         s->last_non_b_pict_type = s->pict_type;
 }
 
-static void update_noise_reduction(MPVMainEncContext *s)
+static void update_noise_reduction(MPVMainEncContext *m)
 {
+    MPVEncContext *const s = &m->common;
     int intra, i;
 
     for (intra = 0; intra < 2; intra++) {
@@ -1597,8 +1609,9 @@ static void update_noise_reduction(MPVMainEncContext *s)
     }
 }
 
-static int frame_start(MPVMainEncContext *s)
+static int frame_start(MPVMainEncContext *m)
 {
+    MPVEncContext *const s = &m->common;
     int ret;
 
     /* mark & release old frames */
@@ -1662,7 +1675,7 @@ static int frame_start(MPVMainEncContext *s)
 
     if (s->dct_error_sum) {
         av_assert2(s->noise_reduction && s->encoding);
-        update_noise_reduction(s);
+        update_noise_reduction(m);
     }
 
     return 0;
@@ -1671,7 +1684,8 @@ static int frame_start(MPVMainEncContext *s)
 int ff_mpv_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
                           const AVFrame *pic_arg, int *got_packet)
 {
-    MPVMainEncContext *const s = avctx->priv_data;
+    MPVMainEncContext *const m = avctx->priv_data;
+    MPVEncContext *const s = &m->common;
     int i, stuffing_count, ret;
     int context_count = s->slice_context_count;
 
@@ -1679,10 +1693,10 @@ int ff_mpv_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
 
     s->picture_in_gop_number++;
 
-    if (load_input_picture(s, pic_arg) < 0)
+    if (load_input_picture(m, pic_arg) < 0)
         return -1;
 
-    if (select_input_picture(s) < 0) {
+    if (select_input_picture(m) < 0) {
         return -1;
     }
 
@@ -1713,11 +1727,11 @@ int ff_mpv_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
 
         s->pict_type = s->new_picture.f->pict_type;
         //emms_c();
-        ret = frame_start(s);
+        ret = frame_start(m);
         if (ret < 0)
             return ret;
 vbv_retry:
-        ret = encode_picture(s, s->picture_number);
+        ret = encode_picture(m, s->picture_number);
         if (growing_buffer) {
             av_assert0(s->pb.buf == avctx->internal->byte_buffer);
             pkt->data = s->pb.buf;
@@ -1726,7 +1740,7 @@ vbv_retry:
         if (ret < 0)
             return -1;
 
-        frame_end(s);
+        frame_end(m);
 
        if ((CONFIG_MJPEG_ENCODER || CONFIG_AMV_ENCODER) && s->out_format == FMT_MJPEG)
             ff_mjpeg_encode_picture_trailer(&s->pb, s->header_bits);
@@ -1774,7 +1788,7 @@ vbv_retry:
         }
 
         if (avctx->flags & AV_CODEC_FLAG_PASS1)
-            ff_write_pass1_stats(s);
+            ff_write_pass1_stats(m);
 
         for (i = 0; i < 4; i++) {
             s->current_picture_ptr->encoding_error[i] = s->current_picture.encoding_error[i];
@@ -1792,7 +1806,7 @@ vbv_retry:
         flush_put_bits(&s->pb);
         s->frame_bits  = put_bits_count(&s->pb);
 
-        stuffing_count = ff_vbv_update(s, s->frame_bits);
+        stuffing_count = ff_vbv_update(m, s->frame_bits);
         s->stuffing_bits = 8*stuffing_count;
         if (stuffing_count) {
             if (put_bytes_left(&s->pb, 0) < stuffing_count + 50) {
@@ -3431,14 +3445,15 @@ static void merge_context_after_encode(MPVEncContext *dst, MPVEncContext *src)
     flush_put_bits(&dst->pb);
 }
 
-static int estimate_qp(MPVMainEncContext *s, int dry_run)
+static int estimate_qp(MPVMainEncContext *m, int dry_run)
 {
+    MPVEncContext *const s = &m->common;
     if (s->next_lambda){
         s->current_picture_ptr->f->quality =
         s->current_picture.f->quality = s->next_lambda;
         if(!dry_run) s->next_lambda= 0;
     } else if (!s->fixed_qscale) {
-        int quality = ff_rate_estimate_qscale(s, dry_run);
+        int quality = ff_rate_estimate_qscale(m, dry_run);
         s->current_picture_ptr->f->quality =
         s->current_picture.f->quality = quality;
         if (s->current_picture.f->quality < 0)
@@ -3449,16 +3464,16 @@ static int estimate_qp(MPVMainEncContext *s, int dry_run)
         switch(s->codec_id){
         case AV_CODEC_ID_MPEG4:
             if (CONFIG_MPEG4_ENCODER)
-                ff_clean_mpeg4_qscales(s);
+                ff_clean_mpeg4_qscales(m);
             break;
         case AV_CODEC_ID_H263:
         case AV_CODEC_ID_H263P:
         case AV_CODEC_ID_FLV1:
             if (CONFIG_H263_ENCODER)
-                ff_clean_h263_qscales(s);
+                ff_clean_h263_qscales(m);
             break;
         default:
-            ff_init_qscale_tab(s);
+            ff_init_qscale_tab(m);
         }
 
         s->lambda= s->lambda_table[0];
@@ -3470,8 +3485,9 @@ static int estimate_qp(MPVMainEncContext *s, int dry_run)
 }
 
 /* must be called before writing the header */
-static void set_frame_distances(MPVMainEncContext *s)
+static void set_frame_distances(MPVMainEncContext *m)
 {
+    MPVEncContext *const s = &m->common;
     av_assert1(s->current_picture_ptr->f->pts != AV_NOPTS_VALUE);
     s->time = s->current_picture_ptr->f->pts * s->avctx->time_base.num;
 
@@ -3485,8 +3501,9 @@ static void set_frame_distances(MPVMainEncContext *s)
     }
 }
 
-static int encode_picture(MPVMainEncContext *s, int picture_number)
+static int encode_picture(MPVMainEncContext *m, int picture_number)
 {
+    MPVEncContext *const s = &m->common;
     int i, ret;
     int bits;
     int context_count = s->slice_context_count;
@@ -3500,9 +3517,9 @@ static int encode_picture(MPVMainEncContext *s, int picture_number)
     /* we need to initialize some time vars before we can encode B-frames */
     // RAL: Condition added for MPEG1VIDEO
     if (s->out_format == FMT_MPEG1 || (s->h263_pred && !s->msmpeg4_version))
-        set_frame_distances(s);
+        set_frame_distances(m);
     if(CONFIG_MPEG4_ENCODER && s->codec_id == AV_CODEC_ID_MPEG4)
-        ff_set_mpeg4_time(s);
+        ff_set_mpeg4_time(m);
 
     s->me.scene_change_score=0;
 
@@ -3517,9 +3534,9 @@ static int encode_picture(MPVMainEncContext *s, int picture_number)
     }
 
     if (s->avctx->flags & AV_CODEC_FLAG_PASS2) {
-        if (estimate_qp(s,1) < 0)
+        if (estimate_qp(m, 1) < 0)
             return -1;
-        ff_get_2pass_fcode(s);
+        ff_get_2pass_fcode(m);
     } else if (!(s->avctx->flags & AV_CODEC_FLAG_QSCALE)) {
         if(s->pict_type==AV_PICTURE_TYPE_B)
             s->lambda= s->last_lambda_for[s->pict_type];
@@ -3637,7 +3654,7 @@ static int encode_picture(MPVMainEncContext *s, int picture_number)
         }
     }
 
-    if (estimate_qp(s, 0) < 0)
+    if (estimate_qp(m, 0) < 0)
         return -1;
 
     if (s->qscale < 3 && s->max_qcoeff <= 128 &&
@@ -3711,41 +3728,41 @@ static int encode_picture(MPVMainEncContext *s, int picture_number)
     switch(s->out_format) {
 #if CONFIG_MJPEG_ENCODER || CONFIG_AMV_ENCODER
     case FMT_MJPEG:
-        ff_mjpeg_amv_encode_picture_header(s);
+        ff_mjpeg_amv_encode_picture_header(m);
         break;
 #endif
     case FMT_SPEEDHQ:
         if (CONFIG_SPEEDHQ_ENCODER)
-            ff_speedhq_encode_picture_header(s);
+            ff_speedhq_encode_picture_header(m);
         break;
     case FMT_H261:
         if (CONFIG_H261_ENCODER)
-            ff_h261_encode_picture_header(s, picture_number);
+            ff_h261_encode_picture_header(m, picture_number);
         break;
     case FMT_H263:
         if (CONFIG_WMV2_ENCODER && s->codec_id == AV_CODEC_ID_WMV2)
-            ff_wmv2_encode_picture_header(s, picture_number);
+            ff_wmv2_encode_picture_header(m, picture_number);
         else if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version)
-            ff_msmpeg4_encode_picture_header(s, picture_number);
+            ff_msmpeg4_encode_picture_header(m, picture_number);
         else if (CONFIG_MPEG4_ENCODER && s->h263_pred) {
-            ret = ff_mpeg4_encode_picture_header(s, picture_number);
+            ret = ff_mpeg4_encode_picture_header(m, picture_number);
             if (ret < 0)
                 return ret;
         } else if (CONFIG_RV10_ENCODER && s->codec_id == AV_CODEC_ID_RV10) {
-            ret = ff_rv10_encode_picture_header(s, picture_number);
+            ret = ff_rv10_encode_picture_header(m, picture_number);
             if (ret < 0)
                 return ret;
         }
         else if (CONFIG_RV20_ENCODER && s->codec_id == AV_CODEC_ID_RV20)
-            ff_rv20_encode_picture_header(s, picture_number);
+            ff_rv20_encode_picture_header(m, picture_number);
         else if (CONFIG_FLV_ENCODER && s->codec_id == AV_CODEC_ID_FLV1)
-            ff_flv_encode_picture_header(s, picture_number);
+            ff_flv_encode_picture_header(m, picture_number);
         else if (CONFIG_H263_ENCODER)
-            ff_h263_encode_picture_header(s, picture_number);
+            ff_h263_encode_picture_header(m, picture_number);
         break;
     case FMT_MPEG1:
         if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
-            ff_mpeg1_encode_picture_header(s, picture_number);
+            ff_mpeg1_encode_picture_header(m, picture_number);
         break;
     default:
         av_assert0(0);
diff --git a/libavcodec/mpegvideoenc.h b/libavcodec/mpegvideoenc.h
index 0b63487291..37375132d7 100644
--- a/libavcodec/mpegvideoenc.h
+++ b/libavcodec/mpegvideoenc.h
@@ -33,7 +33,9 @@
 #include "mpegvideo.h"
 
 typedef MPVContext MPVEncContext;
-typedef MPVContext MPVMainEncContext;
+typedef struct MPVMainEncContext {
+    MPVMainContext common;
+} MPVMainEncContext;
 
 #define UNI_AC_ENC_INDEX(run,level) ((run)*128 + (level))
 
@@ -62,7 +64,8 @@ typedef MPVContext MPVMainEncContext;
 { "chroma", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_CMP_CHROMA }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS, "cmp_func" }, \
 { "msad",   "Sum of absolute differences, median predicted", 0, AV_OPT_TYPE_CONST, {.i64 = FF_CMP_MEDIAN_SAD }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS, "cmp_func" }
 
-#define FF_MPV_OFFSET(x) offsetof(MPVMainEncContext, x)
+#define FF_MPV_MAIN_OFFSET(x) offsetof(MPVMainEncContext, x)
+#define FF_MPV_OFFSET(x) FF_MPV_MAIN_OFFSET(common.x)
 #define FF_MPV_OPT_FLAGS (AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM)
 #define FF_MPV_COMMON_OPTS \
 FF_MPV_OPT_CMP_FUNC, \
diff --git a/libavcodec/msmpeg4enc.c b/libavcodec/msmpeg4enc.c
index 1a2e24f703..7c1fa0a1e3 100644
--- a/libavcodec/msmpeg4enc.c
+++ b/libavcodec/msmpeg4enc.c
@@ -134,11 +134,12 @@ static av_cold void msmpeg4_encode_init_static(void)
     }
 }
 
-av_cold void ff_msmpeg4_encode_init(MPVMainEncContext *s)
+av_cold void ff_msmpeg4_encode_init(MPVMainEncContext *m)
 {
     static AVOnce init_static_once = AV_ONCE_INIT;
+    MPVEncContext *const s = &m->common;
 
-    ff_msmpeg4_common_init(s);
+    ff_msmpeg4_common_init(&m->common);
     if (s->msmpeg4_version >= 4) {
         s->min_qcoeff = -255;
         s->max_qcoeff =  255;
@@ -150,7 +151,7 @@ av_cold void ff_msmpeg4_encode_init(MPVMainEncContext *s)
 
 static void find_best_tables(MSMPEG4EncContext *ms)
 {
-    MPVEncContext *const s = &ms->s;
+    MPVEncContext *const s = &ms->s.common;
     int i;
     int best        = 0, best_size        = INT_MAX;
     int chroma_best = 0, best_chroma_size = INT_MAX;
@@ -214,9 +215,10 @@ static void find_best_tables(MSMPEG4EncContext *ms)
 }
 
 /* write MSMPEG4 compatible frame header */
-void ff_msmpeg4_encode_picture_header(MPVMainEncContext *s, int picture_number)
+void ff_msmpeg4_encode_picture_header(MPVMainEncContext *m, int picture_number)
 {
-    MSMPEG4EncContext *const ms = (MSMPEG4EncContext*)s;
+    MSMPEG4EncContext *const ms = (MSMPEG4EncContext*)m;
+    MPVEncContext     *const  s = &m->common;
 
     find_best_tables(ms);
 
diff --git a/libavcodec/ratecontrol.c b/libavcodec/ratecontrol.c
index c5088d6790..4c326741df 100644
--- a/libavcodec/ratecontrol.c
+++ b/libavcodec/ratecontrol.c
@@ -35,8 +35,9 @@
 #include "mpegvideoenc.h"
 #include "libavutil/eval.h"
 
-void ff_write_pass1_stats(MPVMainEncContext *s)
+void ff_write_pass1_stats(MPVMainEncContext *m)
 {
+    MPVEncContext *const s = &m->common;
     snprintf(s->avctx->stats_out, 256,
              "in:%d out:%d type:%d q:%d itex:%d ptex:%d mv:%d misc:%d "
              "fcode:%d bcode:%d mc-var:%"PRId64" var:%"PRId64" icount:%d skipcount:%d hbits:%d;\n",
@@ -77,8 +78,9 @@ static inline double bits2qp(RateControlEntry *rce, double bits)
     return rce->qscale * (double)(rce->i_tex_bits + rce->p_tex_bits + 1) / bits;
 }
 
-static double get_diff_limited_q(MPVMainEncContext *s, RateControlEntry *rce, double q)
+static double get_diff_limited_q(MPVMainEncContext *m, RateControlEntry *rce, double q)
 {
+    MPVEncContext    *const s = &m->common;
     RateControlContext *rcc   = &s->rc_context;
     AVCodecContext *a         = s->avctx;
     const int pict_type       = rce->new_pict_type;
@@ -116,7 +118,7 @@ static double get_diff_limited_q(MPVMainEncContext *s, RateControlEntry *rce, do
 /**
  * Get the qmin & qmax for pict_type.
  */
-static void get_qminmax(int *qmin_ret, int *qmax_ret, MPVMainEncContext *s, int pict_type)
+static void get_qminmax(int *qmin_ret, int *qmax_ret, MPVEncContext *s, int pict_type)
 {
     int qmin = s->lmin;
     int qmax = s->lmax;
@@ -144,9 +146,10 @@ static void get_qminmax(int *qmin_ret, int *qmax_ret, MPVMainEncContext *s, int
     *qmax_ret = qmax;
 }
 
-static double modify_qscale(MPVMainEncContext *s, RateControlEntry *rce,
+static double modify_qscale(MPVMainEncContext *m, RateControlEntry *rce,
                             double q, int frame_num)
 {
+    MPVEncContext   *const s = &m->common;
     RateControlContext *rcc  = &s->rc_context;
     const double buffer_size = s->avctx->rc_buffer_size;
     const double fps         = get_fps(s->avctx);
@@ -235,9 +238,10 @@ static double modify_qscale(MPVMainEncContext *s, RateControlEntry *rce,
 /**
  * Modify the bitrate curve from pass1 for one frame.
  */
-static double get_qscale(MPVMainEncContext *s, RateControlEntry *rce,
+static double get_qscale(MPVMainEncContext *m, RateControlEntry *rce,
                          double rate_factor, int frame_num)
 {
+    MPVEncContext  *const s = &m->common;
     RateControlContext *rcc = &s->rc_context;
     AVCodecContext *a       = s->avctx;
     const int pict_type     = rce->new_pict_type;
@@ -308,8 +312,9 @@ static double get_qscale(MPVMainEncContext *s, RateControlEntry *rce,
     return q;
 }
 
-static int init_pass2(MPVMainEncContext *s)
+static int init_pass2(MPVMainEncContext *m)
 {
+    MPVEncContext  *const s = &m->common;
     RateControlContext *rcc = &s->rc_context;
     AVCodecContext *a       = s->avctx;
     int i, toobig;
@@ -368,7 +373,7 @@ static int init_pass2(MPVMainEncContext *s)
         for (i = 0; i < rcc->num_entries; i++) {
             RateControlEntry *rce = &rcc->entry[i];
 
-            qscale[i] = get_qscale(s, &rcc->entry[i], rate_factor, i);
+            qscale[i] = get_qscale(m, &rcc->entry[i], rate_factor, i);
             rcc->last_qscale_for[rce->pict_type] = qscale[i];
         }
         av_assert0(filter_size % 2 == 1);
@@ -377,13 +382,13 @@ static int init_pass2(MPVMainEncContext *s)
         for (i = FFMAX(0, rcc->num_entries - 300); i < rcc->num_entries; i++) {
             RateControlEntry *rce = &rcc->entry[i];
 
-            qscale[i] = get_diff_limited_q(s, rce, qscale[i]);
+            qscale[i] = get_diff_limited_q(m, rce, qscale[i]);
         }
 
         for (i = rcc->num_entries - 1; i >= 0; i--) {
             RateControlEntry *rce = &rcc->entry[i];
 
-            qscale[i] = get_diff_limited_q(s, rce, qscale[i]);
+            qscale[i] = get_diff_limited_q(m, rce, qscale[i]);
         }
 
         /* smooth curve */
@@ -413,10 +418,10 @@ static int init_pass2(MPVMainEncContext *s)
             RateControlEntry *rce = &rcc->entry[i];
             double bits;
 
-            rce->new_qscale = modify_qscale(s, rce, blurred_qscale[i], i);
+            rce->new_qscale = modify_qscale(m, rce, blurred_qscale[i], i);
 
             bits  = qp2bits(rce, rce->new_qscale) + rce->mv_bits + rce->misc_bits;
-            bits += 8 * ff_vbv_update(s, bits);
+            bits += 8 * ff_vbv_update(m, bits);
 
             rce->expected_bits = expected_bits;
             expected_bits     += bits;
@@ -469,8 +474,9 @@ static int init_pass2(MPVMainEncContext *s)
     return 0;
 }
 
-av_cold int ff_rate_control_init(MPVMainEncContext *s)
+av_cold int ff_rate_control_init(MPVMainEncContext *m)
 {
+    MPVEncContext  *const s = &m->common;
     RateControlContext *rcc = &s->rc_context;
     int i, res;
     static const char * const const_names[] = {
@@ -603,8 +609,8 @@ av_cold int ff_rate_control_init(MPVMainEncContext *s)
             p = next;
         }
 
-        if (init_pass2(s) < 0) {
-            ff_rate_control_uninit(s);
+        if (init_pass2(m) < 0) {
+            ff_rate_control_uninit(m);
             return -1;
         }
     }
@@ -658,7 +664,7 @@ av_cold int ff_rate_control_init(MPVMainEncContext *s)
                 rcc->mv_bits_sum[rce.pict_type] += rce.mv_bits;
                 rcc->frame_count[rce.pict_type]++;
 
-                get_qscale(s, &rce, rcc->pass1_wanted_bits / rcc->pass1_rc_eq_output_sum, i);
+                get_qscale(m, &rce, rcc->pass1_wanted_bits / rcc->pass1_rc_eq_output_sum, i);
 
                 // FIXME misbehaves a little for variable fps
                 rcc->pass1_wanted_bits += s->bit_rate / get_fps(s->avctx);
@@ -669,8 +675,9 @@ av_cold int ff_rate_control_init(MPVMainEncContext *s)
     return 0;
 }
 
-av_cold void ff_rate_control_uninit(MPVMainEncContext *s)
+av_cold void ff_rate_control_uninit(MPVMainEncContext *m)
 {
+    MPVEncContext  *const s = &m->common;
     RateControlContext *rcc = &s->rc_context;
     emms_c();
 
@@ -678,8 +685,9 @@ av_cold void ff_rate_control_uninit(MPVMainEncContext *s)
     av_freep(&rcc->entry);
 }
 
-int ff_vbv_update(MPVMainEncContext *s, int frame_size)
+int ff_vbv_update(MPVMainEncContext *m, int frame_size)
 {
+    MPVEncContext  *const s = &m->common;
     RateControlContext *rcc = &s->rc_context;
     const double fps        = get_fps(s->avctx);
     const int buffer_size   = s->avctx->rc_buffer_size;
@@ -737,8 +745,9 @@ static void update_predictor(Predictor *p, double q, double var, double size)
     p->coeff += new_coeff;
 }
 
-static void adaptive_quantization(MPVMainEncContext *s, double q)
+static void adaptive_quantization(MPVMainEncContext *m, double q)
 {
+    MPVEncContext *const s = &m->common;
     int i;
     const float lumi_masking         = s->avctx->lumi_masking / (128.0 * 128.0);
     const float dark_masking         = s->avctx->dark_masking / (128.0 * 128.0);
@@ -854,8 +863,9 @@ static void adaptive_quantization(MPVMainEncContext *s, double q)
     }
 }
 
-void ff_get_2pass_fcode(MPVMainEncContext *s)
+void ff_get_2pass_fcode(MPVMainEncContext *m)
 {
+    MPVEncContext  *const s = &m->common;
     RateControlContext *rcc = &s->rc_context;
     RateControlEntry *rce   = &rcc->entry[s->picture_number];
 
@@ -865,8 +875,9 @@ void ff_get_2pass_fcode(MPVMainEncContext *s)
 
 // FIXME rd or at least approx for dquant
 
-float ff_rate_estimate_qscale(MPVMainEncContext *s, int dry_run)
+float ff_rate_estimate_qscale(MPVMainEncContext *m, int dry_run)
 {
+    MPVEncContext *const s = &m->common;
     float q;
     int qmin, qmax;
     float br_compensation;
@@ -971,12 +982,12 @@ float ff_rate_estimate_qscale(MPVMainEncContext *s, int dry_run)
         rate_factor = rcc->pass1_wanted_bits /
                       rcc->pass1_rc_eq_output_sum * br_compensation;
 
-        q = get_qscale(s, rce, rate_factor, picture_number);
+        q = get_qscale(m, rce, rate_factor, picture_number);
         if (q < 0)
             return -1;
 
         av_assert0(q > 0.0);
-        q = get_diff_limited_q(s, rce, q);
+        q = get_diff_limited_q(m, rce, q);
         av_assert0(q > 0.0);
 
         // FIXME type dependent blur like in 2-pass
@@ -990,7 +1001,7 @@ float ff_rate_estimate_qscale(MPVMainEncContext *s, int dry_run)
         }
         av_assert0(q > 0.0);
 
-        q = modify_qscale(s, rce, q, picture_number);
+        q = modify_qscale(m, rce, q, picture_number);
 
         rcc->pass1_wanted_bits += s->bit_rate / fps;
 
@@ -1015,7 +1026,7 @@ float ff_rate_estimate_qscale(MPVMainEncContext *s, int dry_run)
         q = qmax;
 
     if (s->adaptive_quant)
-        adaptive_quantization(s, q);
+        adaptive_quantization(m, q);
     else
         q = (int)(q + 0.5);
 
diff --git a/libavcodec/ratecontrol.h b/libavcodec/ratecontrol.h
index 23f41dcca2..6b29a0a94d 100644
--- a/libavcodec/ratecontrol.h
+++ b/libavcodec/ratecontrol.h
@@ -86,7 +86,6 @@ typedef struct RateControlContext{
     AVExpr * rc_eq_eval;
 }RateControlContext;
 
-#define MPVMainEncContext MPVContext
 struct MPVMainEncContext;
 
 /* rate control */
@@ -96,6 +95,5 @@ void ff_write_pass1_stats(struct MPVMainEncContext *m);
 void ff_rate_control_uninit(struct MPVMainEncContext *m);
 int ff_vbv_update(struct MPVMainEncContext *m, int frame_size);
 void ff_get_2pass_fcode(struct MPVMainEncContext *m);
-#undef MPVMainEncContext
 
 #endif /* AVCODEC_RATECONTROL_H */
diff --git a/libavcodec/rv10enc.c b/libavcodec/rv10enc.c
index 6c9305d7fe..ddbea6298c 100644
--- a/libavcodec/rv10enc.c
+++ b/libavcodec/rv10enc.c
@@ -29,8 +29,9 @@
 #include "put_bits.h"
 #include "rv10enc.h"
 
-int ff_rv10_encode_picture_header(MPVMainEncContext *s, int picture_number)
+int ff_rv10_encode_picture_header(MPVMainEncContext *m, int picture_number)
 {
+    MPVEncContext *const s = &m->common;
     int full_frame= 0;
 
     align_put_bits(&s->pb);
diff --git a/libavcodec/rv20enc.c b/libavcodec/rv20enc.c
index a4b4bad277..06f6751549 100644
--- a/libavcodec/rv20enc.c
+++ b/libavcodec/rv20enc.c
@@ -32,8 +32,9 @@
 #include "put_bits.h"
 #include "rv10enc.h"
 
-void ff_rv20_encode_picture_header(MPVMainEncContext *s, int picture_number)
+void ff_rv20_encode_picture_header(MPVMainEncContext *m, int picture_number)
 {
+    MPVEncContext *const s = &m->common;
     put_bits(&s->pb, 2, s->pict_type); //I 0 vs. 1 ?
     put_bits(&s->pb, 1, 0);     /* unknown bit */
     put_bits(&s->pb, 5, s->qscale);
diff --git a/libavcodec/snow.c b/libavcodec/snow.c
index 0a500695ce..de9741a888 100644
--- a/libavcodec/snow.c
+++ b/libavcodec/snow.c
@@ -689,6 +689,7 @@ int ff_snow_frame_start(SnowContext *s){
 av_cold void ff_snow_common_end(SnowContext *s)
 {
     int plane_index, level, orientation, i;
+    MPVEncContext *const m = &s->m.common;
 
     av_freep(&s->spatial_dwt_buffer);
     av_freep(&s->temp_dwt_buffer);
@@ -696,11 +697,11 @@ av_cold void ff_snow_common_end(SnowContext *s)
     av_freep(&s->temp_idwt_buffer);
     av_freep(&s->run_buffer);
 
-    s->m.me.temp= NULL;
-    av_freep(&s->m.me.scratchpad);
-    av_freep(&s->m.me.map);
-    av_freep(&s->m.me.score_map);
-    av_freep(&s->m.sc.obmc_scratchpad);
+    m->me.temp = NULL;
+    av_freep(&m->me.scratchpad);
+    av_freep(&m->me.map);
+    av_freep(&m->me.score_map);
+    av_freep(&m->sc.obmc_scratchpad);
 
     av_freep(&s->block);
     av_freep(&s->scratchbuf);
diff --git a/libavcodec/snowenc.c b/libavcodec/snowenc.c
index e169ae601d..028b6b91aa 100644
--- a/libavcodec/snowenc.c
+++ b/libavcodec/snowenc.c
@@ -39,6 +39,7 @@
 static av_cold int encode_init(AVCodecContext *avctx)
 {
     SnowContext *s = avctx->priv_data;
+    MPVEncContext *const mpv = &s->m.common;
     int plane_index, ret;
     int i;
 
@@ -72,18 +73,18 @@ static av_cold int encode_init(AVCodecContext *avctx)
 
     s->version=0;
 
-    s->m.avctx   = avctx;
-    s->m.bit_rate= avctx->bit_rate;
-    s->m.lmin    = avctx->mb_lmin;
-    s->m.lmax    = avctx->mb_lmax;
-    s->m.mb_num  = (avctx->width * avctx->height + 255) / 256; // For ratecontrol
-
-    s->m.me.temp      =
-    s->m.me.scratchpad = av_calloc(avctx->width + 64, 2*16*2*sizeof(uint8_t));
-    s->m.me.map       = av_mallocz(ME_MAP_SIZE*sizeof(uint32_t));
-    s->m.me.score_map = av_mallocz(ME_MAP_SIZE*sizeof(uint32_t));
-    s->m.sc.obmc_scratchpad= av_mallocz(MB_SIZE*MB_SIZE*12*sizeof(uint32_t));
-    if (!s->m.me.scratchpad || !s->m.me.map || !s->m.me.score_map || !s->m.sc.obmc_scratchpad)
+    mpv->avctx   = avctx;
+    mpv->bit_rate= avctx->bit_rate;
+    mpv->lmin    = avctx->mb_lmin;
+    mpv->lmax    = avctx->mb_lmax;
+    mpv->mb_num  = (avctx->width * avctx->height + 255) / 256; // For ratecontrol
+
+    mpv->me.temp      =
+    mpv->me.scratchpad = av_calloc(avctx->width + 64, 2*16*2*sizeof(uint8_t));
+    mpv->me.map       = av_mallocz(ME_MAP_SIZE*sizeof(uint32_t));
+    mpv->me.score_map = av_mallocz(ME_MAP_SIZE*sizeof(uint32_t));
+    mpv->sc.obmc_scratchpad= av_mallocz(MB_SIZE*MB_SIZE*12*sizeof(uint32_t));
+    if (!mpv->me.scratchpad || !mpv->me.map || !mpv->me.score_map || !mpv->sc.obmc_scratchpad)
         return AVERROR(ENOMEM);
 
     ff_h263_encode_init(&s->m); //mv_penalty
@@ -216,6 +217,7 @@ static inline int get_penalty_factor(int lambda, int lambda2, int type){
 #define FLAG_QPEL   1 //must be 1
 
 static int encode_q_branch(SnowContext *s, int level, int x, int y){
+    MPVEncContext *const mpv = &s->m.common;
     uint8_t p_buffer[1024];
     uint8_t i_buffer[1024];
     uint8_t p_state[sizeof(s->block_state)];
@@ -252,7 +254,7 @@ static int encode_q_branch(SnowContext *s, int level, int x, int y){
     int16_t last_mv[3][2];
     int qpel= !!(s->avctx->flags & AV_CODEC_FLAG_QPEL); //unused
     const int shift= 1+qpel;
-    MotionEstContext *c= &s->m.me;
+    MotionEstContext *c= &mpv->me;
     int ref_context= av_log2(2*left->ref) + av_log2(2*top->ref);
     int mx_context= av_log2(2*FFABS(left->mx - top->mx));
     int my_context= av_log2(2*FFABS(left->my - top->my));
@@ -281,9 +283,9 @@ static int encode_q_branch(SnowContext *s, int level, int x, int y){
     last_mv[2][0]= bottom->mx;
     last_mv[2][1]= bottom->my;
 
-    s->m.mb_stride=2;
-    s->m.mb_x=
-    s->m.mb_y= 0;
+    mpv->mb_stride=2;
+    mpv->mb_x=
+    mpv->mb_y= 0;
     c->skip= 0;
 
     av_assert1(c->  stride ==   stride);
@@ -292,7 +294,7 @@ static int encode_q_branch(SnowContext *s, int level, int x, int y){
     c->penalty_factor    = get_penalty_factor(s->lambda, s->lambda2, c->avctx->me_cmp);
     c->sub_penalty_factor= get_penalty_factor(s->lambda, s->lambda2, c->avctx->me_sub_cmp);
     c->mb_penalty_factor = get_penalty_factor(s->lambda, s->lambda2, c->avctx->mb_cmp);
-    c->current_mv_penalty= c->mv_penalty[s->m.f_code=1] + MAX_DMV;
+    c->current_mv_penalty= c->mv_penalty[mpv->f_code=1] + MAX_DMV;
 
     c->xmin = - x*block_w - 16+3;
     c->ymin = - y*block_w - 16+3;
@@ -323,16 +325,16 @@ static int encode_q_branch(SnowContext *s, int level, int x, int y){
     for(ref=0; ref<s->ref_frames; ref++){
         init_ref(c, current_data, s->last_picture[ref]->data, NULL, block_w*x, block_w*y, 0);
 
-        ref_score= ff_epzs_motion_search(&s->m, &ref_mx, &ref_my, P, 0, /*ref_index*/ 0, last_mv,
-                                         (1<<16)>>shift, level-LOG2_MB_SIZE+4, block_w);
+        ref_score = ff_epzs_motion_search(mpv, &ref_mx, &ref_my, P, 0, /*ref_index*/ 0, last_mv,
+                                          (1<<16)>>shift, level-LOG2_MB_SIZE+4, block_w);
 
         av_assert2(ref_mx >= c->xmin);
         av_assert2(ref_mx <= c->xmax);
         av_assert2(ref_my >= c->ymin);
         av_assert2(ref_my <= c->ymax);
 
-        ref_score= c->sub_motion_search(&s->m, &ref_mx, &ref_my, ref_score, 0, 0, level-LOG2_MB_SIZE+4, block_w);
-        ref_score= ff_get_mb_score(&s->m, ref_mx, ref_my, 0, 0, level-LOG2_MB_SIZE+4, block_w, 0);
+        ref_score = c->sub_motion_search(mpv, &ref_mx, &ref_my, ref_score, 0, 0, level-LOG2_MB_SIZE+4, block_w);
+        ref_score = ff_get_mb_score(mpv, ref_mx, ref_my, 0, 0, level-LOG2_MB_SIZE+4, block_w, 0);
         ref_score+= 2*av_log2(2*ref)*c->penalty_factor;
         if(s->ref_mvs[ref]){
             s->ref_mvs[ref][index][0]= ref_mx;
@@ -408,7 +410,7 @@ static int encode_q_branch(SnowContext *s, int level, int x, int y){
         if (vard <= 64 || vard < varc)
             c->scene_change_score+= ff_sqrt(vard) - ff_sqrt(varc);
         else
-            c->scene_change_score+= s->m.qscale;
+            c->scene_change_score+= mpv->qscale;
     }
 
     if(level!=s->block_max_depth){
@@ -509,7 +511,7 @@ static int get_dc(SnowContext *s, int mb_x, int mb_y, int plane_index){
     const int obmc_stride= plane_index ? (2*block_size)>>s->chroma_h_shift : 2*block_size;
     const int ref_stride= s->current_picture->linesize[plane_index];
     uint8_t *src= s-> input_picture->data[plane_index];
-    IDWTELEM *dst= (IDWTELEM*)s->m.sc.obmc_scratchpad + plane_index*block_size*block_size*4; //FIXME change to unsigned
+    IDWTELEM *dst= (IDWTELEM*)s->m.common.sc.obmc_scratchpad + plane_index*block_size*block_size*4; //FIXME change to unsigned
     const int b_stride = s->b_width << s->block_max_depth;
     const int w= p->width;
     const int h= p->height;
@@ -596,6 +598,7 @@ static inline int get_block_bits(SnowContext *s, int x, int y, int w){
 }
 
 static int get_block_rd(SnowContext *s, int mb_x, int mb_y, int plane_index, uint8_t (*obmc_edged)[MB_SIZE * 2]){
+    MPVEncContext *const mpv = &s->m.common;
     Plane *p= &s->plane[plane_index];
     const int block_size = MB_SIZE >> s->block_max_depth;
     const int block_w    = plane_index ? block_size>>s->chroma_h_shift : block_size;
@@ -604,7 +607,7 @@ static int get_block_rd(SnowContext *s, int mb_x, int mb_y, int plane_index, uin
     const int ref_stride= s->current_picture->linesize[plane_index];
     uint8_t *dst= s->current_picture->data[plane_index];
     uint8_t *src= s->  input_picture->data[plane_index];
-    IDWTELEM *pred= (IDWTELEM*)s->m.sc.obmc_scratchpad + plane_index*block_size*block_size*4;
+    IDWTELEM *pred= (IDWTELEM*)mpv->sc.obmc_scratchpad + plane_index*block_size*block_size*4;
     uint8_t *cur = s->scratchbuf;
     uint8_t *tmp = s->emu_edge_buffer;
     const int b_stride = s->b_width << s->block_max_depth;
@@ -667,19 +670,19 @@ static int get_block_rd(SnowContext *s, int mb_x, int mb_y, int plane_index, uin
          * to improve the score of the whole frame, thus iterative motion
          * estimation does not always converge. */
         if(s->avctx->me_cmp == FF_CMP_W97)
-            distortion = ff_w97_32_c(&s->m, src + sx + sy*ref_stride, dst + sx + sy*ref_stride, ref_stride, 32);
+            distortion = ff_w97_32_c(mpv, src + sx + sy*ref_stride, dst + sx + sy*ref_stride, ref_stride, 32);
         else if(s->avctx->me_cmp == FF_CMP_W53)
-            distortion = ff_w53_32_c(&s->m, src + sx + sy*ref_stride, dst + sx + sy*ref_stride, ref_stride, 32);
+            distortion = ff_w53_32_c(mpv, src + sx + sy*ref_stride, dst + sx + sy*ref_stride, ref_stride, 32);
         else{
             distortion = 0;
             for(i=0; i<4; i++){
                 int off = sx+16*(i&1) + (sy+16*(i>>1))*ref_stride;
-                distortion += s->mecc.me_cmp[0](&s->m, src + off, dst + off, ref_stride, 16);
+                distortion += s->mecc.me_cmp[0](mpv, src + off, dst + off, ref_stride, 16);
             }
         }
     }else{
         av_assert2(block_w==8);
-        distortion = s->mecc.me_cmp[0](&s->m, src + sx + sy*ref_stride, dst + sx + sy*ref_stride, ref_stride, block_w*2);
+        distortion = s->mecc.me_cmp[0](mpv, src + sx + sy*ref_stride, dst + sx + sy*ref_stride, ref_stride, block_w*2);
     }
 
     if(plane_index==0){
@@ -697,6 +700,7 @@ static int get_block_rd(SnowContext *s, int mb_x, int mb_y, int plane_index, uin
 }
 
 static int get_4block_rd(SnowContext *s, int mb_x, int mb_y, int plane_index){
+    MPVEncContext *const mpv = &s->m.common;
     int i, y2;
     Plane *p= &s->plane[plane_index];
     const int block_size = MB_SIZE >> s->block_max_depth;
@@ -743,7 +747,7 @@ static int get_4block_rd(SnowContext *s, int mb_x, int mb_y, int plane_index){
         }
 
         av_assert1(block_w== 8 || block_w==16);
-        distortion += s->mecc.me_cmp[block_w==8](&s->m, src + x + y*ref_stride, dst + x + y*ref_stride, ref_stride, block_h);
+        distortion += s->mecc.me_cmp[block_w==8](mpv, src + x + y*ref_stride, dst + x + y*ref_stride, ref_stride, block_h);
     }
 
     if(plane_index==0){
@@ -1477,6 +1481,7 @@ static int qscale2qlog(int qscale){
 
 static int ratecontrol_1pass(SnowContext *s, AVFrame *pict)
 {
+    MPVEncContext *const mpv = &s->m.common;
     /* Estimate the frame's complexity as a sum of weighted dwt coefficients.
      * FIXME we know exact mv bits at this point,
      * but ratecontrol isn't set up to include them. */
@@ -1511,11 +1516,11 @@ static int ratecontrol_1pass(SnowContext *s, AVFrame *pict)
     coef_sum = (uint64_t)coef_sum * coef_sum >> 16;
 
     if(pict->pict_type == AV_PICTURE_TYPE_I){
-        s->m.current_picture.mb_var_sum= coef_sum;
-        s->m.current_picture.mc_mb_var_sum= 0;
+        mpv->current_picture.mb_var_sum= coef_sum;
+        mpv->current_picture.mc_mb_var_sum= 0;
     }else{
-        s->m.current_picture.mc_mb_var_sum= coef_sum;
-        s->m.current_picture.mb_var_sum= 0;
+        mpv->current_picture.mc_mb_var_sum= coef_sum;
+        mpv->current_picture.mb_var_sum= 0;
     }
 
     pict->quality= ff_rate_estimate_qscale(&s->m, 1);
@@ -1557,6 +1562,7 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
                         const AVFrame *pict, int *got_packet)
 {
     SnowContext *s = avctx->priv_data;
+    MPVEncContext *const mpv = &s->m.common;
     RangeCoder * const c= &s->c;
     AVFrame *pic;
     const int width= s->avctx->width;
@@ -1589,9 +1595,9 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
     pic->pict_type = pict->pict_type;
     pic->quality = pict->quality;
 
-    s->m.picture_number= avctx->frame_number;
+    mpv->picture_number= avctx->frame_number;
     if(avctx->flags&AV_CODEC_FLAG_PASS2){
-        s->m.pict_type = pic->pict_type = s->m.rc_context.entry[avctx->frame_number].new_pict_type;
+        mpv->pict_type = pic->pict_type = mpv->rc_context.entry[avctx->frame_number].new_pict_type;
         s->keyframe = pic->pict_type == AV_PICTURE_TYPE_I;
         if(!(avctx->flags&AV_CODEC_FLAG_QSCALE)) {
             pic->quality = ff_rate_estimate_qscale(&s->m, 0);
@@ -1600,7 +1606,7 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
         }
     }else{
         s->keyframe= avctx->gop_size==0 || avctx->frame_number % avctx->gop_size == 0;
-        s->m.pict_type = pic->pict_type = s->keyframe ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;
+        mpv->pict_type = pic->pict_type = s->keyframe ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;
     }
 
     if(s->pass1_rc && avctx->frame_number == 0)
@@ -1634,9 +1640,9 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
 
     ff_snow_frame_start(s);
 
-    s->m.current_picture_ptr= &s->m.current_picture;
-    s->m.current_picture.f = s->current_picture;
-    s->m.current_picture.f->pts = pict->pts;
+    mpv->current_picture_ptr= &mpv->current_picture;
+    mpv->current_picture.f = s->current_picture;
+    mpv->current_picture.f->pts = pict->pts;
     if(pic->pict_type == AV_PICTURE_TYPE_P){
         int block_width = (width +15)>>4;
         int block_height= (height+15)>>4;
@@ -1645,37 +1651,37 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
         av_assert0(s->current_picture->data[0]);
         av_assert0(s->last_picture[0]->data[0]);
 
-        s->m.avctx= s->avctx;
-        s->m.   last_picture.f = s->last_picture[0];
-        s->m.    new_picture.f = s->input_picture;
-        s->m.   last_picture_ptr= &s->m.   last_picture;
-        s->m.linesize = stride;
-        s->m.uvlinesize= s->current_picture->linesize[1];
-        s->m.width = width;
-        s->m.height= height;
-        s->m.mb_width = block_width;
-        s->m.mb_height= block_height;
-        s->m.mb_stride=   s->m.mb_width+1;
-        s->m.b8_stride= 2*s->m.mb_width+1;
-        s->m.f_code=1;
-        s->m.pict_type = pic->pict_type;
-        s->m.motion_est= s->motion_est;
-        s->m.me.scene_change_score=0;
-        s->m.me.dia_size = avctx->dia_size;
-        s->m.quarter_sample= (s->avctx->flags & AV_CODEC_FLAG_QPEL)!=0;
-        s->m.out_format= FMT_H263;
-        s->m.unrestricted_mv= 1;
-
-        s->m.lambda = s->lambda;
-        s->m.qscale= (s->m.lambda*139 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7);
-        s->lambda2= s->m.lambda2= (s->m.lambda*s->m.lambda + FF_LAMBDA_SCALE/2) >> FF_LAMBDA_SHIFT;
-
-        s->m.mecc= s->mecc; //move
-        s->m.qdsp= s->qdsp; //move
-        s->m.hdsp = s->hdsp;
-        ff_init_me(&s->m);
-        s->hdsp = s->m.hdsp;
-        s->mecc= s->m.mecc;
+        mpv->avctx= s->avctx;
+        mpv->   last_picture.f = s->last_picture[0];
+        mpv->    new_picture.f = s->input_picture;
+        mpv->   last_picture_ptr= &mpv->   last_picture;
+        mpv->linesize = stride;
+        mpv->uvlinesize= s->current_picture->linesize[1];
+        mpv->width = width;
+        mpv->height= height;
+        mpv->mb_width = block_width;
+        mpv->mb_height= block_height;
+        mpv->mb_stride=   mpv->mb_width+1;
+        mpv->b8_stride= 2*mpv->mb_width+1;
+        mpv->f_code=1;
+        mpv->pict_type = pic->pict_type;
+        mpv->motion_est= s->motion_est;
+        mpv->me.scene_change_score=0;
+        mpv->me.dia_size = avctx->dia_size;
+        mpv->quarter_sample= (s->avctx->flags & AV_CODEC_FLAG_QPEL)!=0;
+        mpv->out_format= FMT_H263;
+        mpv->unrestricted_mv= 1;
+
+        mpv->lambda = s->lambda;
+        mpv->qscale= (mpv->lambda*139 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7);
+        s->lambda2= mpv->lambda2= (mpv->lambda*mpv->lambda + FF_LAMBDA_SCALE/2) >> FF_LAMBDA_SHIFT;
+
+        mpv->mecc= s->mecc; //move
+        mpv->qdsp= s->qdsp; //move
+        mpv->hdsp = s->hdsp;
+        ff_init_me(mpv);
+        s->hdsp = mpv->hdsp;
+        s->mecc= mpv->mecc;
     }
 
     if(s->pass1_rc){
@@ -1696,7 +1702,7 @@ redo_frame:
         return AVERROR(EINVAL);
     }
 
-    s->m.pict_type = pic->pict_type;
+    mpv->pict_type = pic->pict_type;
     s->qbias = pic->pict_type == AV_PICTURE_TYPE_P ? 2 : 0;
 
     ff_snow_common_init_after_header(avctx);
@@ -1708,9 +1714,9 @@ redo_frame:
     }
 
     encode_header(s);
-    s->m.misc_bits = 8*(s->c.bytestream - s->c.bytestream_start);
+    mpv->misc_bits = 8*(s->c.bytestream - s->c.bytestream_start);
     encode_blocks(s, 1);
-    s->m.mv_bits = 8*(s->c.bytestream - s->c.bytestream_start) - s->m.misc_bits;
+    mpv->mv_bits = 8*(s->c.bytestream - s->c.bytestream_start) - mpv->misc_bits;
 
     for(plane_index=0; plane_index < s->nb_planes; plane_index++){
         Plane *p= &s->plane[plane_index];
@@ -1732,7 +1738,7 @@ redo_frame:
             if(   plane_index==0
                && pic->pict_type == AV_PICTURE_TYPE_P
                && !(avctx->flags&AV_CODEC_FLAG_PASS2)
-               && s->m.me.scene_change_score > s->scenechange_threshold){
+               && mpv->me.scene_change_score > s->scenechange_threshold){
                 ff_init_range_encoder(c, pkt->data, pkt->size);
                 ff_build_rac_states(c, (1LL<<32)/20, 256-8);
                 pic->pict_type= AV_PICTURE_TYPE_I;
@@ -1841,18 +1847,18 @@ redo_frame:
     s->current_picture->coded_picture_number = avctx->frame_number;
     s->current_picture->pict_type = pic->pict_type;
     s->current_picture->quality = pic->quality;
-    s->m.frame_bits = 8*(s->c.bytestream - s->c.bytestream_start);
-    s->m.p_tex_bits = s->m.frame_bits - s->m.misc_bits - s->m.mv_bits;
-    s->m.current_picture.f->display_picture_number =
-    s->m.current_picture.f->coded_picture_number   = avctx->frame_number;
-    s->m.current_picture.f->quality                = pic->quality;
-    s->m.total_bits += 8*(s->c.bytestream - s->c.bytestream_start);
+    mpv->frame_bits = 8*(s->c.bytestream - s->c.bytestream_start);
+    mpv->p_tex_bits = mpv->frame_bits - mpv->misc_bits - mpv->mv_bits;
+    mpv->current_picture.f->display_picture_number =
+    mpv->current_picture.f->coded_picture_number   = avctx->frame_number;
+    mpv->current_picture.f->quality                = pic->quality;
+    mpv->total_bits += 8*(s->c.bytestream - s->c.bytestream_start);
     if(s->pass1_rc)
         if (ff_rate_estimate_qscale(&s->m, 0) < 0)
             return -1;
     if(avctx->flags&AV_CODEC_FLAG_PASS1)
         ff_write_pass1_stats(&s->m);
-    s->m.last_pict_type = s->m.pict_type;
+    mpv->last_pict_type = mpv->pict_type;
 
     emms_c();
 
@@ -1901,7 +1907,7 @@ static const AVOption options[] = {
      "defined in the section 'Expression Evaluation', the following functions are available: "
      "bits2qp(bits), qp2bits(qp). Also the following constants are available: iTex pTex tex mv "
      "fCode iCount mcVar var isI isP isB avgQP qComp avgIITex avgPITex avgPPTex avgBPTex avgTex.",
-                                                                                  OFFSET(m.rc_eq), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, VE },
+                                                                                  OFFSET(m.common.rc_eq), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, VE },
     { NULL },
 };
 
diff --git a/libavcodec/speedhqenc.c b/libavcodec/speedhqenc.c
index be80065a32..6f89927d68 100644
--- a/libavcodec/speedhqenc.c
+++ b/libavcodec/speedhqenc.c
@@ -89,8 +89,9 @@ static av_cold void speedhq_init_static_data(void)
     ff_mpeg1_init_uni_ac_vlc(&ff_rl_speedhq, uni_speedhq_ac_vlc_len);
 }
 
-av_cold int ff_speedhq_encode_init(MPVMainEncContext *s)
+av_cold int ff_speedhq_encode_init(MPVMainEncContext *m)
 {
+    MPVEncContext *const s = &m->common;
     static AVOnce init_static_once = AV_ONCE_INIT;
 
     if (s->width > 65500 || s->height > 65500) {
@@ -125,9 +126,10 @@ av_cold int ff_speedhq_encode_init(MPVMainEncContext *s)
     return 0;
 }
 
-void ff_speedhq_encode_picture_header(MPVMainEncContext *s)
+void ff_speedhq_encode_picture_header(MPVMainEncContext *m)
 {
-    SpeedHQEncContext *ctx = (SpeedHQEncContext*)s;
+    SpeedHQEncContext *ctx = (SpeedHQEncContext*)m;
+    MPVEncContext *const s = &m->common;
 
     put_bits_le(&s->pb, 8, 100 - s->qscale * 2);  /* FIXME why doubled */
     put_bits_le(&s->pb, 24, 4);  /* no second field */
diff --git a/libavcodec/svq1enc.c b/libavcodec/svq1enc.c
index 7af82bb3ac..5e26c1073a 100644
--- a/libavcodec/svq1enc.c
+++ b/libavcodec/svq1enc.c
@@ -253,6 +253,7 @@ static int svq1_encode_plane(SVQ1EncContext *s, int plane,
                              unsigned char *decoded_plane,
                              int width, int height, int src_stride, int stride)
 {
+    MPVEncContext *const mpv = &s->m.common;
     int x, y;
     int i;
     int block_width, block_height;
@@ -271,64 +272,64 @@ static int svq1_encode_plane(SVQ1EncContext *s, int plane,
     block_height = (height + 15) / 16;
 
     if (s->pict_type == AV_PICTURE_TYPE_P) {
-        s->m.avctx                         = s->avctx;
-        s->m.current_picture_ptr           = &s->m.current_picture;
-        s->m.last_picture_ptr              = &s->m.last_picture;
-        s->m.last_picture.f->data[0]        = ref_plane;
-        s->m.linesize                      =
-        s->m.last_picture.f->linesize[0]    =
-        s->m.new_picture.f->linesize[0]     =
-        s->m.current_picture.f->linesize[0] = stride;
-        s->m.width                         = width;
-        s->m.height                        = height;
-        s->m.mb_width                      = block_width;
-        s->m.mb_height                     = block_height;
-        s->m.mb_stride                     = s->m.mb_width + 1;
-        s->m.b8_stride                     = 2 * s->m.mb_width + 1;
-        s->m.f_code                        = 1;
-        s->m.pict_type                     = s->pict_type;
-        s->m.motion_est                    = s->motion_est;
-        s->m.me.scene_change_score         = 0;
-        // s->m.out_format                    = FMT_H263;
-        // s->m.unrestricted_mv               = 1;
-        s->m.lambda                        = s->quality;
-        s->m.qscale                        = s->m.lambda * 139 +
+        mpv->avctx                         = s->avctx;
+        mpv->current_picture_ptr           = &mpv->current_picture;
+        mpv->last_picture_ptr              = &mpv->last_picture;
+        mpv->last_picture.f->data[0]        = ref_plane;
+        mpv->linesize                      =
+        mpv->last_picture.f->linesize[0]    =
+        mpv->new_picture.f->linesize[0]     =
+        mpv->current_picture.f->linesize[0] = stride;
+        mpv->width                         = width;
+        mpv->height                        = height;
+        mpv->mb_width                      = block_width;
+        mpv->mb_height                     = block_height;
+        mpv->mb_stride                     = mpv->mb_width + 1;
+        mpv->b8_stride                     = 2 * mpv->mb_width + 1;
+        mpv->f_code                        = 1;
+        mpv->pict_type                     = s->pict_type;
+        mpv->motion_est                    = s->motion_est;
+        mpv->me.scene_change_score         = 0;
+        // mpv->out_format                    = FMT_H263;
+        // mpv->unrestricted_mv               = 1;
+        mpv->lambda                        = s->quality;
+        mpv->qscale                        = mpv->lambda * 139 +
                                              FF_LAMBDA_SCALE * 64 >>
                                              FF_LAMBDA_SHIFT + 7;
-        s->m.lambda2                       = s->m.lambda * s->m.lambda +
+        mpv->lambda2                       = mpv->lambda * mpv->lambda +
                                              FF_LAMBDA_SCALE / 2 >>
                                              FF_LAMBDA_SHIFT;
 
         if (!s->motion_val8[plane]) {
-            s->motion_val8[plane]  = av_mallocz((s->m.b8_stride *
+            s->motion_val8[plane]  = av_mallocz((mpv->b8_stride *
                                                  block_height * 2 + 2) *
                                                 2 * sizeof(int16_t));
-            s->motion_val16[plane] = av_mallocz((s->m.mb_stride *
+            s->motion_val16[plane] = av_mallocz((mpv->mb_stride *
                                                  (block_height + 2) + 1) *
                                                 2 * sizeof(int16_t));
             if (!s->motion_val8[plane] || !s->motion_val16[plane])
                 return AVERROR(ENOMEM);
         }
 
-        s->m.mb_type = s->mb_type;
+        mpv->mb_type = s->mb_type;
 
         // dummies, to avoid segfaults
-        s->m.current_picture.mb_mean   = (uint8_t *)s->dummy;
-        s->m.current_picture.mb_var    = (uint16_t *)s->dummy;
-        s->m.current_picture.mc_mb_var = (uint16_t *)s->dummy;
-        s->m.current_picture.mb_type = s->dummy;
-
-        s->m.current_picture.motion_val[0]   = s->motion_val8[plane] + 2;
-        s->m.p_mv_table                      = s->motion_val16[plane] +
-                                               s->m.mb_stride + 1;
-        s->m.mecc                            = s->mecc; // move
-        ff_init_me(&s->m);
-
-        s->m.me.dia_size      = s->avctx->dia_size;
-        s->m.first_slice_line = 1;
+        mpv->current_picture.mb_mean   = (uint8_t *)s->dummy;
+        mpv->current_picture.mb_var    = (uint16_t *)s->dummy;
+        mpv->current_picture.mc_mb_var = (uint16_t *)s->dummy;
+        mpv->current_picture.mb_type = s->dummy;
+
+        mpv->current_picture.motion_val[0]   = s->motion_val8[plane] + 2;
+        mpv->p_mv_table                      = s->motion_val16[plane] +
+                                               mpv->mb_stride + 1;
+        mpv->mecc                            = s->mecc; // move
+        ff_init_me(mpv);
+
+        mpv->me.dia_size      = s->avctx->dia_size;
+        mpv->first_slice_line = 1;
         for (y = 0; y < block_height; y++) {
-            s->m.new_picture.f->data[0] = src - y * 16 * stride; // ugly
-            s->m.mb_y                  = y;
+            mpv->new_picture.f->data[0] = src - y * 16 * stride; // ugly
+            mpv->mb_y                  = y;
 
             for (i = 0; i < 16 && i + 16 * y < height; i++) {
                 memcpy(&src[i * stride], &src_plane[(i + 16 * y) * src_stride],
@@ -341,20 +342,20 @@ static int svq1_encode_plane(SVQ1EncContext *s, int plane,
                        16 * block_width);
 
             for (x = 0; x < block_width; x++) {
-                s->m.mb_x = x;
-                init_block_index(&s->m);
+                mpv->mb_x = x;
+                init_block_index(mpv);
 
-                ff_estimate_p_frame_motion(&s->m, x, y);
+                ff_estimate_p_frame_motion(mpv, x, y);
             }
-            s->m.first_slice_line = 0;
+            mpv->first_slice_line = 0;
         }
 
-        ff_fix_long_p_mvs(&s->m, CANDIDATE_MB_TYPE_INTRA);
-        ff_fix_long_mvs(&s->m, NULL, 0, s->m.p_mv_table, s->m.f_code,
+        ff_fix_long_p_mvs(mpv, CANDIDATE_MB_TYPE_INTRA);
+        ff_fix_long_mvs(mpv, NULL, 0, mpv->p_mv_table, mpv->f_code,
                         CANDIDATE_MB_TYPE_INTER, 0);
     }
 
-    s->m.first_slice_line = 1;
+    mpv->first_slice_line = 1;
     for (y = 0; y < block_height; y++) {
         for (i = 0; i < 16 && i + 16 * y < height; i++) {
             memcpy(&src[i * stride], &src_plane[(i + 16 * y) * src_stride],
@@ -365,7 +366,7 @@ static int svq1_encode_plane(SVQ1EncContext *s, int plane,
         for (; i < 16 && i + 16 * y < 16 * block_height; i++)
             memcpy(&src[i * stride], &src[(i - 1) * stride], 16 * block_width);
 
-        s->m.mb_y = y;
+        mpv->mb_y = y;
         for (x = 0; x < block_width; x++) {
             uint8_t reorder_buffer[2][6][7 * 32];
             int count[2][6];
@@ -380,11 +381,11 @@ static int svq1_encode_plane(SVQ1EncContext *s, int plane,
                 return -1;
             }
 
-            s->m.mb_x = x;
-            init_block_index(&s->m);
+            mpv->mb_x = x;
+            init_block_index(mpv);
 
             if (s->pict_type == AV_PICTURE_TYPE_I ||
-                (s->m.mb_type[x + y * s->m.mb_stride] &
+                (mpv->mb_type[x + y * mpv->mb_stride] &
                  CANDIDATE_MB_TYPE_INTRA)) {
                 for (i = 0; i < 6; i++)
                     init_put_bits(&s->reorder_pb[i], reorder_buffer[0][i],
@@ -410,8 +411,8 @@ static int svq1_encode_plane(SVQ1EncContext *s, int plane,
                 int mx, my, pred_x, pred_y, dxy;
                 int16_t *motion_ptr;
 
-                motion_ptr = ff_h263_pred_motion(&s->m, 0, 0, &pred_x, &pred_y);
-                if (s->m.mb_type[x + y * s->m.mb_stride] &
+                motion_ptr = ff_h263_pred_motion(mpv, 0, 0, &pred_x, &pred_y);
+                if (mpv->mb_type[x + y * mpv->mb_stride] &
                     CANDIDATE_MB_TYPE_INTER) {
                     for (i = 0; i < 6; i++)
                         init_put_bits(&s->reorder_pb[i], reorder_buffer[1][i],
@@ -419,16 +420,16 @@ static int svq1_encode_plane(SVQ1EncContext *s, int plane,
 
                     put_bits(&s->reorder_pb[5], vlc[1], vlc[0]);
 
-                    s->m.pb = s->reorder_pb[5];
+                    mpv->pb = s->reorder_pb[5];
                     mx      = motion_ptr[0];
                     my      = motion_ptr[1];
                     av_assert1(mx     >= -32 && mx     <= 31);
                     av_assert1(my     >= -32 && my     <= 31);
                     av_assert1(pred_x >= -32 && pred_x <= 31);
                     av_assert1(pred_y >= -32 && pred_y <= 31);
-                    ff_h263_encode_motion(&s->m.pb, mx - pred_x, 1);
-                    ff_h263_encode_motion(&s->m.pb, my - pred_y, 1);
-                    s->reorder_pb[5] = s->m.pb;
+                    ff_h263_encode_motion(&mpv->pb, mx - pred_x, 1);
+                    ff_h263_encode_motion(&mpv->pb, my - pred_y, 1);
+                    s->reorder_pb[5] = mpv->pb;
                     score[1]        += lambda * put_bits_count(&s->reorder_pb[5]);
 
                     dxy = (mx & 1) + 2 * (my & 1);
@@ -463,10 +464,10 @@ static int svq1_encode_plane(SVQ1EncContext *s, int plane,
                     motion_ptr[1]                      =
                     motion_ptr[2]                      =
                     motion_ptr[3]                      =
-                    motion_ptr[0 + 2 * s->m.b8_stride] =
-                    motion_ptr[1 + 2 * s->m.b8_stride] =
-                    motion_ptr[2 + 2 * s->m.b8_stride] =
-                    motion_ptr[3 + 2 * s->m.b8_stride] = 0;
+                    motion_ptr[0 + 2 * mpv->b8_stride] =
+                    motion_ptr[1 + 2 * mpv->b8_stride] =
+                    motion_ptr[2 + 2 * mpv->b8_stride] =
+                    motion_ptr[3 + 2 * mpv->b8_stride] = 0;
                 }
             }
 
@@ -479,7 +480,7 @@ static int svq1_encode_plane(SVQ1EncContext *s, int plane,
             if (best == 0)
                 s->hdsp.put_pixels_tab[0][0](decoded, temp, stride, 16);
         }
-        s->m.first_slice_line = 0;
+        mpv->first_slice_line = 0;
     }
     return 0;
 }
@@ -487,6 +488,7 @@ static int svq1_encode_plane(SVQ1EncContext *s, int plane,
 static av_cold int svq1_encode_end(AVCodecContext *avctx)
 {
     SVQ1EncContext *const s = avctx->priv_data;
+    MPVEncContext *const mpv = &s->m.common;
     int i;
 
     if (avctx->frame_number)
@@ -494,12 +496,12 @@ static av_cold int svq1_encode_end(AVCodecContext *avctx)
                s->rd_total / (double)(avctx->width * avctx->height *
                                       avctx->frame_number));
 
-    s->m.mb_type = NULL;
-    ff_mpv_common_end(&s->m);
+    mpv->mb_type = NULL;
+    ff_mpv_common_end(&s->m.common);
 
-    av_freep(&s->m.me.scratchpad);
-    av_freep(&s->m.me.map);
-    av_freep(&s->m.me.score_map);
+    av_freep(&mpv->me.scratchpad);
+    av_freep(&mpv->me.map);
+    av_freep(&mpv->me.score_map);
     av_freep(&s->mb_type);
     av_freep(&s->dummy);
     av_freep(&s->scratchbuf);
@@ -518,6 +520,7 @@ static av_cold int svq1_encode_end(AVCodecContext *avctx)
 static av_cold int svq1_encode_init(AVCodecContext *avctx)
 {
     SVQ1EncContext *const s = avctx->priv_data;
+    MPVEncContext *const mpv = &s->m.common;
     int ret;
 
     if (avctx->width >= 4096 || avctx->height >= 4096) {
@@ -527,7 +530,7 @@ static av_cold int svq1_encode_init(AVCodecContext *avctx)
 
     ff_hpeldsp_init(&s->hdsp, avctx->flags);
     ff_me_cmp_init(&s->mecc, avctx);
-    ff_mpegvideoencdsp_init(&s->m.mpvencdsp, avctx);
+    ff_mpegvideoencdsp_init(&mpv->mpvencdsp, avctx);
 
     s->current_picture = av_frame_alloc();
     s->last_picture    = av_frame_alloc();
@@ -545,26 +548,26 @@ static av_cold int svq1_encode_init(AVCodecContext *avctx)
     s->c_block_height = (s->frame_height / 4 + 15) / 16;
 
     s->avctx               = avctx;
-    s->m.avctx             = avctx;
+    mpv->avctx             = avctx;
 
-    if ((ret = ff_mpv_common_init(&s->m)) < 0) {
+    if ((ret = ff_mpv_common_init(&s->m.common)) < 0) {
         return ret;
     }
 
-    s->m.picture_structure = PICT_FRAME;
-    s->m.me.temp           =
-    s->m.me.scratchpad     = av_mallocz((avctx->width + 64) *
+    mpv->picture_structure = PICT_FRAME;
+    mpv->me.temp           =
+    mpv->me.scratchpad     = av_mallocz((avctx->width + 64) *
                                         2 * 16 * 2 * sizeof(uint8_t));
-    s->m.me.map            = av_mallocz(ME_MAP_SIZE * sizeof(uint32_t));
-    s->m.me.score_map      = av_mallocz(ME_MAP_SIZE * sizeof(uint32_t));
+    mpv->me.map            = av_mallocz(ME_MAP_SIZE * sizeof(uint32_t));
+    mpv->me.score_map      = av_mallocz(ME_MAP_SIZE * sizeof(uint32_t));
     s->mb_type             = av_mallocz((s->y_block_width + 1) *
                                         s->y_block_height * sizeof(int16_t));
     s->dummy               = av_mallocz((s->y_block_width + 1) *
                                         s->y_block_height * sizeof(int32_t));
     s->ssd_int8_vs_int16   = ssd_int8_vs_int16_c;
 
-    if (!s->m.me.temp || !s->m.me.scratchpad || !s->m.me.map ||
-        !s->m.me.score_map || !s->mb_type || !s->dummy) {
+    if (!mpv->me.temp || !mpv->me.scratchpad || !mpv->me.map ||
+        !mpv->me.score_map || !s->mb_type || !s->dummy) {
         return AVERROR(ENOMEM);
     }
 
diff --git a/libavcodec/wmv2enc.c b/libavcodec/wmv2enc.c
index cd35fd19b1..11d566fe5a 100644
--- a/libavcodec/wmv2enc.c
+++ b/libavcodec/wmv2enc.c
@@ -43,7 +43,7 @@ typedef struct WMV2EncContext {
 
 static int encode_ext_header(WMV2EncContext *w)
 {
-    MPVMainEncContext *const s = &w->msmpeg4.s;
+    MPVEncContext *const s = &w->msmpeg4.s.common;
     PutBitContext pb;
     int code;
 
@@ -70,13 +70,14 @@ static int encode_ext_header(WMV2EncContext *w)
 static av_cold int wmv2_encode_init(AVCodecContext *avctx)
 {
     WMV2EncContext *const w = avctx->priv_data;
-    MPVMainEncContext *const s = &w->msmpeg4.s;
+    MPVMainEncContext *const m = &w->msmpeg4.s;
+    MPVEncContext     *const s = &m->common;
 
     s->private_ctx = &w->common;
     if (ff_mpv_encode_init(avctx) < 0)
         return -1;
 
-    ff_wmv2_common_init(s);
+    ff_wmv2_common_init(&m->common);
 
     avctx->extradata_size = 4;
     avctx->extradata      = av_mallocz(avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
@@ -88,9 +89,10 @@ static av_cold int wmv2_encode_init(AVCodecContext *avctx)
     return 0;
 }
 
-int ff_wmv2_encode_picture_header(MPVMainEncContext *s, int picture_number)
+int ff_wmv2_encode_picture_header(MPVMainEncContext *m, int picture_number)
 {
-    WMV2EncContext *const w = (WMV2EncContext *) s;
+    WMV2EncContext *const w = (WMV2EncContext *) m;
+    MPVEncContext  *const s = &m->common;
 
     put_bits(&s->pb, 1, s->pict_type - 1);
     if (s->pict_type == AV_PICTURE_TYPE_I)
