[FFmpeg-devel] [PATCH 01/41] avcodec/mpegvideo_enc: Allow slices only for slice-thread-able codecs

[FFmpeg-devel] [PATCH 01/41] avcodec/mpegvideo_enc: Allow slices only for slice-thread-able codecs

[Andreas Rheinhardt]

One can use slices without slice-threading. The results for
mpegvideo-encoders are abysmal: AMV, SpeedHQ, H.263, RV10, RV20,
MSMPEG4v2, MSMPEG4v3 and WMV1 produce broken files.
WMV2 meanwhile expects the MpegEncContext given to ff_wmv2_encode_mb()
to be at the beginning of a Wmv2Context (a structure that this encoder
shares with the WMV2 decoder), yet this is only true for the
main context and not for the slice contexts, leading to segfaults.
SpeedHQ additionally triggers an av_assert2, because it is not
byte-aligned at a position where it ought to be byte-aligned.

Given that no codec not supporting slice threading works this commit
disallows using slices unless the encoder supports slice threading.

Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
---
 libavcodec/mpegvideo_enc.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/libavcodec/mpegvideo_enc.c b/libavcodec/mpegvideo_enc.c
index 33f2937217..6df2a46eaa 100644
--- a/libavcodec/mpegvideo_enc.c
+++ b/libavcodec/mpegvideo_enc.c
@@ -599,7 +599,7 @@ av_cold int ff_mpv_encode_init(AVCodecContext *avctx)
     }
 
     if (avctx->slices > 1 &&
-        (avctx->codec_id == AV_CODEC_ID_FLV1 || avctx->codec_id == AV_CODEC_ID_H261)) {
+        !(avctx->codec->capabilities & AV_CODEC_CAP_SLICE_THREADS)) {
         av_log(avctx, AV_LOG_ERROR, "Multiple slices are not supported by this codec\n");
         return AVERROR(EINVAL);
     }
-- 
2.32.0

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

[FFmpeg-devel] [PATCH 02/41] avcodec/mjpegenc: Remove nonsense assert

[Andreas Rheinhardt]

Writing optimal huffman tables is incompatible with using slices
and hence commit 884506dfe2e29a5b2bd2905ca4f17e277e32acb1
that added writing optimal huffman tables also added an assert
that the slice context count is always 1.
Yet this was always wrong: a) The MJPEG-encoder has (and had)
the AV_CODEC_CAP_SLICE_THREADS capability, so asserting that
it always uses one slice context is incorrect.
b) This commit did not add any proper checks that ensured that
optimal huffman tables are never used together with multiple slices.
This only happened with 03eb0515c12637dbd20c2e3ca8503d7b47cf583a.
c) This assert is at the wrong place: ff_mjpeg_encode_init() is
called before the actual slice_context_count is set. This is
the reason why this assert was never triggered.

Therefore this commit removes this assert.

Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
---
 libavcodec/mjpegenc.c | 2 --
 1 file changed, 2 deletions(-)

diff --git a/libavcodec/mjpegenc.c b/libavcodec/mjpegenc.c
index d15b9ece50..022f171c9e 100644
--- a/libavcodec/mjpegenc.c
+++ b/libavcodec/mjpegenc.c
@@ -293,8 +293,6 @@ av_cold int ff_mjpeg_encode_init(MpegEncContext *s)
 
     s->mjpeg_ctx = m;
 
-    av_assert0(s->slice_context_count == 1);
-
     if (s->codec_id == AV_CODEC_ID_AMV || (s->avctx->active_thread_type & FF_THREAD_SLICE))
         m->huffman = HUFFMAN_TABLE_DEFAULT;
 
-- 
2.32.0

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

Re: [FFmpeg-devel] [PATCH 02/41] avcodec/mjpegenc: Remove nonsense assert

[Michael Niedermayer]

[-- Attachment #1.1: Type: text/plain, Size: 974 bytes --]

On Sun, Jan 30, 2022 at 07:27:10AM +0100, Andreas Rheinhardt wrote:
> Writing optimal huffman tables is incompatible with using slices

Fundamentally, this should not be i think

CCITT Rec. T.81 says

"If a table specification for a
given destination occurs more than once in the compressed image data, each specification shall replace the previous
specification. The quantization table specification shall not be altered between progressive DCT scans of a given
component."

This explicitly mentions quatization tables but not huffman tables so it
seems allowed that they can be changed 

[...]
-- 
Michael     GnuPG fingerprint: 9FF2128B147EF6730BADF133611EC787040B0FAB

If you drop bombs on a foreign country and kill a hundred thousand
innocent people, expect your government to call the consequence
"unprovoked inhuman terrorist attacks" and use it to justify dropping
more bombs and killing more people. The technology changed, the idea is old.

[-- Attachment #1.2: signature.asc --]
[-- Type: application/pgp-signature, Size: 195 bytes --]

[-- Attachment #2: Type: text/plain, Size: 251 bytes --]

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

Re: [FFmpeg-devel] [PATCH 02/41] avcodec/mjpegenc: Remove nonsense assert

[Andreas Rheinhardt]

Michael Niedermayer:
> On Sun, Jan 30, 2022 at 07:27:10AM +0100, Andreas Rheinhardt wrote:
>> Writing optimal huffman tables is incompatible with using slices
> 
> Fundamentally, this should not be i think
> 
> CCITT Rec. T.81 says
> 
> "If a table specification for a
> given destination occurs more than once in the compressed image data, each specification shall replace the previous
> specification. The quantization table specification shall not be altered between progressive DCT scans of a given
> component."
> 
> This explicitly mentions quatization tables but not huffman tables so it
> seems allowed that they can be changed 
> 

The intention of the quoted passage was to state a limitation of our
current code, not a limitation of the format.

- Andreas
_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

[FFmpeg-devel] [PATCH 03/41] avcodec/mjpegenc: Fix files with slices > 1, but threads == 1

[Andreas Rheinhardt]

In the aforementioned case mpegvideo_enc.c calls
ff_mjpeg_encode_stuffing() at the end of every line which
pads the output to byte-alignment and escapes it;
yet it does not write the restart-markers (and also not
the DRI marker when writing the header) and so the output files
are broken.

Fix this by writing these markers depending upon the number of
slices and not the number of threads in use; this also makes
the output of the encoder reproducible given a slice count
and is therefore important if encoder tests that actually use
-threads auto are added in the future.

Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
---
 libavcodec/ljpegenc.c        |  2 +-
 libavcodec/mjpegenc.c        | 12 ++++++++----
 libavcodec/mjpegenc_common.c | 10 ++++++----
 libavcodec/mjpegenc_common.h |  3 ++-
 4 files changed, 17 insertions(+), 10 deletions(-)

diff --git a/libavcodec/ljpegenc.c b/libavcodec/ljpegenc.c
index e15f448f90..7c53da7bc3 100644
--- a/libavcodec/ljpegenc.c
+++ b/libavcodec/ljpegenc.c
@@ -239,7 +239,7 @@ static int ljpeg_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
     init_put_bits(&pb, pkt->data, pkt->size);
 
     ff_mjpeg_encode_picture_header(avctx, &pb, NULL, &s->scantable,
-                                   s->pred, s->matrix, s->matrix);
+                                   s->pred, s->matrix, s->matrix, 0);
 
     header_bits = put_bits_count(&pb);
 
diff --git a/libavcodec/mjpegenc.c b/libavcodec/mjpegenc.c
index 022f171c9e..6a47503ab4 100644
--- a/libavcodec/mjpegenc.c
+++ b/libavcodec/mjpegenc.c
@@ -78,7 +78,8 @@ static void mjpeg_encode_picture_header(MpegEncContext *s)
 {
     ff_mjpeg_encode_picture_header(s->avctx, &s->pb, s->mjpeg_ctx,
                                    &s->intra_scantable, 0,
-                                   s->intra_matrix, s->chroma_intra_matrix);
+                                   s->intra_matrix, s->chroma_intra_matrix,
+                                   s->slice_context_count > 1);
 
     s->esc_pos = put_bytes_count(&s->pb, 0);
     for (int i = 1; i < s->slice_context_count; i++)
@@ -247,7 +248,7 @@ int ff_mjpeg_encode_stuffing(MpegEncContext *s)
 
     ff_mjpeg_escape_FF(pbc, s->esc_pos);
 
-    if ((s->avctx->active_thread_type & FF_THREAD_SLICE) && mb_y < s->mb_height - 1)
+    if (s->slice_context_count > 1 && mb_y < s->mb_height - 1)
         put_marker(pbc, RST0 + (mb_y&7));
     s->esc_pos = put_bytes_count(pbc, 0);
 
@@ -289,11 +290,14 @@ static int alloc_huffman(MpegEncContext *s)
 av_cold int ff_mjpeg_encode_init(MpegEncContext *s)
 {
     MJpegContext *const m = &((MJPEGEncContext*)s)->mjpeg;
-    int ret;
+    int ret, use_slices;
 
     s->mjpeg_ctx = m;
+    use_slices = s->avctx->slices > 0 ? s->avctx->slices > 1 :
+                 (s->avctx->active_thread_type & FF_THREAD_SLICE) &&
+                 s->avctx->thread_count > 1;
 
-    if (s->codec_id == AV_CODEC_ID_AMV || (s->avctx->active_thread_type & FF_THREAD_SLICE))
+    if (s->codec_id == AV_CODEC_ID_AMV || use_slices)
         m->huffman = HUFFMAN_TABLE_DEFAULT;
 
     if (s->mpv_flags & FF_MPV_FLAG_QP_RD) {
diff --git a/libavcodec/mjpegenc_common.c b/libavcodec/mjpegenc_common.c
index 995e2b7670..86b6568902 100644
--- a/libavcodec/mjpegenc_common.c
+++ b/libavcodec/mjpegenc_common.c
@@ -60,7 +60,7 @@ static void jpeg_table_header(AVCodecContext *avctx, PutBitContext *p,
                               ScanTable *intra_scantable,
                               uint16_t luma_intra_matrix[64],
                               uint16_t chroma_intra_matrix[64],
-                              int hsample[3])
+                              int hsample[3], int use_slices)
 {
     int i, j, size;
     uint8_t *ptr;
@@ -91,7 +91,7 @@ static void jpeg_table_header(AVCodecContext *avctx, PutBitContext *p,
         }
     }
 
-    if(avctx->active_thread_type & FF_THREAD_SLICE){
+    if (use_slices) {
         put_marker(p, DRI);
         put_bits(p, 16, 4);
         put_bits(p, 16, (avctx->width-1)/(8*hsample[0]) + 1);
@@ -216,7 +216,8 @@ void ff_mjpeg_encode_picture_header(AVCodecContext *avctx, PutBitContext *pb,
                                     MJpegContext *m,
                                     ScanTable *intra_scantable, int pred,
                                     uint16_t luma_intra_matrix[64],
-                                    uint16_t chroma_intra_matrix[64])
+                                    uint16_t chroma_intra_matrix[64],
+                                    int use_slices)
 {
     const int lossless = !m;
     int hsample[4], vsample[4];
@@ -236,7 +237,8 @@ void ff_mjpeg_encode_picture_header(AVCodecContext *avctx, PutBitContext *pb,
     jpeg_put_comments(avctx, pb);
 
     jpeg_table_header(avctx, pb, m, intra_scantable,
-                      luma_intra_matrix, chroma_intra_matrix, hsample);
+                      luma_intra_matrix, chroma_intra_matrix, hsample,
+                      use_slices);
 
     switch (avctx->codec_id) {
     case AV_CODEC_ID_MJPEG:  put_marker(pb, SOF0 ); break;
diff --git a/libavcodec/mjpegenc_common.h b/libavcodec/mjpegenc_common.h
index ac753bf153..ba7c4f93fa 100644
--- a/libavcodec/mjpegenc_common.h
+++ b/libavcodec/mjpegenc_common.h
@@ -33,7 +33,8 @@ void ff_mjpeg_encode_picture_header(AVCodecContext *avctx, PutBitContext *pb,
                                     struct MJpegContext *m,
                                     ScanTable *intra_scantable, int pred,
                                     uint16_t luma_intra_matrix[64],
-                                    uint16_t chroma_intra_matrix[64]);
+                                    uint16_t chroma_intra_matrix[64],
+                                    int use_slices);
 void ff_mjpeg_encode_picture_trailer(PutBitContext *pb, int header_bits);
 void ff_mjpeg_escape_FF(PutBitContext *pb, int start);
 void ff_mjpeg_build_huffman_codes(uint8_t *huff_size, uint16_t *huff_code,
-- 
2.32.0

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

[FFmpeg-devel] [PATCH 04/41] avcodec/mpegvideo: Enable private contexts

[Andreas Rheinhardt]

MpegEncContext is used by many different codecs and
every one of these uses just a subset of its fields.
If one tries to separate this and e.g. add a real MpegContext
and extension structures (say MpegDecContext and MpegEncContext),
one runs into two difficulties:

a) Some code is shared between decoder and encoder of
the same format and they therefore use the same contexts,
either MpegEncContext itself or identical extensions thereof.
The latter is the case for H.261 as well as WMV2.
b) In case of slice threading, the generic code can only allocate
and initialize the structure it knows about; right now this is
an MpegEncContext. If the codec has an even more extensive structure,
it is only available for the main thread's MpegEncContext.
Fixing this would involve making ff_mpv_common_init() aware
of the size the size of slice context to allocate and would be
part of separating the main thread's context from the slice contexts
in general.

This commit only intends to tackle the first issue by adding
a pointer to MpegEncContext that codecs can set to a common
context so that the aforementioned codecs can use this context
(together with the MpegEncContext) in their common code.
This will allow to move fields only used by the main thread
to more specialized contexts.

Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
---
 libavcodec/mpegvideo.h     | 3 +++
 libavcodec/mpegvideo_dec.c | 2 ++
 2 files changed, 5 insertions(+)

diff --git a/libavcodec/mpegvideo.h b/libavcodec/mpegvideo.h
index 84d79d2e59..5e406b9a9c 100644
--- a/libavcodec/mpegvideo.h
+++ b/libavcodec/mpegvideo.h
@@ -84,6 +84,9 @@ typedef struct MpegEncContext {
      *          offsets used in ASM. */
 
     struct AVCodecContext *avctx;
+    /* The following pointer is intended for codecs sharing code
+     * between decoder and encoder and in need of a common context to do so. */
+    void *private_ctx;
     /* the following parameters must be initialized before encoding */
     int width, height;///< picture size. must be a multiple of 16
     int gop_size;
diff --git a/libavcodec/mpegvideo_dec.c b/libavcodec/mpegvideo_dec.c
index 1e238bd1e1..dc38f6b267 100644
--- a/libavcodec/mpegvideo_dec.c
+++ b/libavcodec/mpegvideo_dec.c
@@ -62,10 +62,12 @@ int ff_mpeg_update_thread_context(AVCodecContext *dst,
     // FIXME can parameters change on I-frames?
     // in that case dst may need a reinit
     if (!s->context_initialized) {
+        void *private_ctx = s->private_ctx;
         int err;
         memcpy(s, s1, sizeof(*s));
 
         s->avctx                 = dst;
+        s->private_ctx           = private_ctx;
         s->bitstream_buffer      = NULL;
         s->bitstream_buffer_size = s->allocated_bitstream_buffer_size = 0;
 
-- 
2.32.0

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

[FFmpeg-devel] [PATCH 05/41] avcodec/h261: Separate decode and encode contexts

[Andreas Rheinhardt]

Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
---
 libavcodec/h261.c    |  2 +-
 libavcodec/h261.h    |  8 ------
 libavcodec/h261dec.c | 59 +++++++++++++++++++++++++++-----------------
 libavcodec/h261enc.c | 54 +++++++++++++++++++++++++---------------
 4 files changed, 72 insertions(+), 51 deletions(-)

diff --git a/libavcodec/h261.c b/libavcodec/h261.c
index 1290c040cd..7dfaee7dc4 100644
--- a/libavcodec/h261.c
+++ b/libavcodec/h261.c
@@ -60,7 +60,7 @@ static void h261_loop_filter(uint8_t *src, int stride)
 
 void ff_h261_loop_filter(MpegEncContext *s)
 {
-    H261Context *h       = (H261Context *)s;
+    H261Context *const h = s->private_ctx;
     const int linesize   = s->linesize;
     const int uvlinesize = s->uvlinesize;
     uint8_t *dest_y      = s->dest[0];
diff --git a/libavcodec/h261.h b/libavcodec/h261.h
index 25728a295d..ff1903e508 100644
--- a/libavcodec/h261.h
+++ b/libavcodec/h261.h
@@ -35,15 +35,7 @@
  * H261Context
  */
 typedef struct H261Context {
-    MpegEncContext s;
-
-    int current_mba;
-    int mba_diff;
     int mtype;
-    int current_mv_x;
-    int current_mv_y;
-    int gob_number;
-    int gob_start_code_skipped; // 1 if gob start code is already read before gob header is read
 } H261Context;
 
 #define MB_TYPE_H261_FIL 0x800000
diff --git a/libavcodec/h261dec.c b/libavcodec/h261dec.c
index 2fd8d94df1..17f1067b15 100644
--- a/libavcodec/h261dec.c
+++ b/libavcodec/h261dec.c
@@ -47,6 +47,19 @@ static VLC h261_mtype_vlc;
 static VLC h261_mv_vlc;
 static VLC h261_cbp_vlc;
 
+typedef struct H261DecContext {
+    MpegEncContext s;
+
+    H261Context common;
+
+    int current_mba;
+    int mba_diff;
+    int current_mv_x;
+    int current_mv_y;
+    int gob_number;
+    int gob_start_code_skipped; // 1 if gob start code is already read before gob header is read
+} H261DecContext;
+
 static av_cold void h261_decode_init_static(void)
 {
     INIT_VLC_STATIC(&h261_mba_vlc, H261_MBA_VLC_BITS, 35,
@@ -67,9 +80,10 @@ static av_cold void h261_decode_init_static(void)
 static av_cold int h261_decode_init(AVCodecContext *avctx)
 {
     static AVOnce init_static_once = AV_ONCE_INIT;
-    H261Context *h          = avctx->priv_data;
+    H261DecContext *const h = avctx->priv_data;
     MpegEncContext *const s = &h->s;
 
+    s->private_ctx = &h->common;
     // set defaults
     ff_mpv_decode_init(s, avctx);
 
@@ -89,7 +103,7 @@ static av_cold int h261_decode_init(AVCodecContext *avctx)
  * Decode the group of blocks header or slice header.
  * @return <0 if an error occurred
  */
-static int h261_decode_gob_header(H261Context *h)
+static int h261_decode_gob_header(H261DecContext *h)
 {
     unsigned int val;
     MpegEncContext *const s = &h->s;
@@ -143,7 +157,7 @@ static int h261_decode_gob_header(H261Context *h)
  * Decode the group of blocks / video packet header.
  * @return <0 if no resync found
  */
-static int h261_resync(H261Context *h)
+static int h261_resync(H261DecContext *h)
 {
     MpegEncContext *const s = &h->s;
     int left, ret;
@@ -184,7 +198,7 @@ static int h261_resync(H261Context *h)
  * Decode skipped macroblocks.
  * @return 0
  */
-static int h261_decode_mb_skipped(H261Context *h, int mba1, int mba2)
+static int h261_decode_mb_skipped(H261DecContext *h, int mba1, int mba2)
 {
     MpegEncContext *const s = &h->s;
     int i;
@@ -209,7 +223,7 @@ static int h261_decode_mb_skipped(H261Context *h, int mba1, int mba2)
         s->mv[0][0][0]                 = 0;
         s->mv[0][0][1]                 = 0;
         s->mb_skipped                  = 1;
-        h->mtype                      &= ~MB_TYPE_H261_FIL;
+        h->common.mtype               &= ~MB_TYPE_H261_FIL;
 
         if (s->current_picture.motion_val[0]) {
             int b_stride = 2*s->mb_width + 1;
@@ -254,7 +268,7 @@ static int decode_mv_component(GetBitContext *gb, int v)
  * Decode a macroblock.
  * @return <0 if an error occurred
  */
-static int h261_decode_block(H261Context *h, int16_t *block, int n, int coded)
+static int h261_decode_block(H261DecContext *h, int16_t *block, int n, int coded)
 {
     MpegEncContext *const s = &h->s;
     int level, i, j, run;
@@ -346,9 +360,10 @@ static int h261_decode_block(H261Context *h, int16_t *block, int n, int coded)
     return 0;
 }
 
-static int h261_decode_mb(H261Context *h)
+static int h261_decode_mb(H261DecContext *h)
 {
     MpegEncContext *const s = &h->s;
+    H261Context *const com = &h->common;
     int i, cbp, xy;
 
     cbp = 63;
@@ -386,23 +401,23 @@ static int h261_decode_mb(H261Context *h)
     ff_update_block_index(s);
 
     // Read mtype
-    h->mtype = get_vlc2(&s->gb, h261_mtype_vlc.table, H261_MTYPE_VLC_BITS, 2);
-    if (h->mtype < 0) {
+    com->mtype = get_vlc2(&s->gb, h261_mtype_vlc.table, H261_MTYPE_VLC_BITS, 2);
+    if (com->mtype < 0) {
         av_log(s->avctx, AV_LOG_ERROR, "Invalid mtype index %d\n",
-               h->mtype);
+               com->mtype);
         return SLICE_ERROR;
     }
-    av_assert0(h->mtype < FF_ARRAY_ELEMS(ff_h261_mtype_map));
-    h->mtype = ff_h261_mtype_map[h->mtype];
+    av_assert0(com->mtype < FF_ARRAY_ELEMS(ff_h261_mtype_map));
+    com->mtype = ff_h261_mtype_map[com->mtype];
 
     // Read mquant
-    if (IS_QUANT(h->mtype))
+    if (IS_QUANT(com->mtype))
         ff_set_qscale(s, get_bits(&s->gb, 5));
 
-    s->mb_intra = IS_INTRA4x4(h->mtype);
+    s->mb_intra = IS_INTRA4x4(com->mtype);
 
     // Read mv
-    if (IS_16X16(h->mtype)) {
+    if (IS_16X16(com->mtype)) {
         /* Motion vector data is included for all MC macroblocks. MVD is
          * obtained from the macroblock vector by subtracting the vector
          * of the preceding macroblock. For this calculation the vector
@@ -425,7 +440,7 @@ static int h261_decode_mb(H261Context *h)
     }
 
     // Read cbp
-    if (HAS_CBP(h->mtype))
+    if (HAS_CBP(com->mtype))
         cbp = get_vlc2(&s->gb, h261_cbp_vlc.table, H261_CBP_VLC_BITS, 1) + 1;
 
     if (s->mb_intra) {
@@ -449,7 +464,7 @@ static int h261_decode_mb(H261Context *h)
 
 intra:
     /* decode each block */
-    if (s->mb_intra || HAS_CBP(h->mtype)) {
+    if (s->mb_intra || HAS_CBP(com->mtype)) {
         s->bdsp.clear_blocks(s->block[0]);
         for (i = 0; i < 6; i++) {
             if (h261_decode_block(h, s->block[i], i, cbp & 32) < 0)
@@ -470,7 +485,7 @@ intra:
  * Decode the H.261 picture header.
  * @return <0 if no startcode found
  */
-static int h261_decode_picture_header(H261Context *h)
+static int h261_decode_picture_header(H261DecContext *h)
 {
     MpegEncContext *const s = &h->s;
     int format, i;
@@ -534,7 +549,7 @@ static int h261_decode_picture_header(H261Context *h)
     return 0;
 }
 
-static int h261_decode_gob(H261Context *h)
+static int h261_decode_gob(H261DecContext *h)
 {
     MpegEncContext *const s = &h->s;
 
@@ -580,9 +595,9 @@ static int get_consumed_bytes(MpegEncContext *s, int buf_size)
 static int h261_decode_frame(AVCodecContext *avctx, void *data,
                              int *got_frame, AVPacket *avpkt)
 {
+    H261DecContext *const h = avctx->priv_data;
     const uint8_t *buf = avpkt->data;
     int buf_size       = avpkt->size;
-    H261Context *h     = avctx->priv_data;
     MpegEncContext *s  = &h->s;
     int ret;
     AVFrame *pict = data;
@@ -657,7 +672,7 @@ retry:
 
 static av_cold int h261_decode_end(AVCodecContext *avctx)
 {
-    H261Context *h    = avctx->priv_data;
+    H261DecContext *const h = avctx->priv_data;
     MpegEncContext *s = &h->s;
 
     ff_mpv_common_end(s);
@@ -669,7 +684,7 @@ const AVCodec ff_h261_decoder = {
     .long_name      = NULL_IF_CONFIG_SMALL("H.261"),
     .type           = AVMEDIA_TYPE_VIDEO,
     .id             = AV_CODEC_ID_H261,
-    .priv_data_size = sizeof(H261Context),
+    .priv_data_size = sizeof(H261DecContext),
     .init           = h261_decode_init,
     .close          = h261_decode_end,
     .decode         = h261_decode_frame,
diff --git a/libavcodec/h261enc.c b/libavcodec/h261enc.c
index af65c1f3b1..13fe5bbfb2 100644
--- a/libavcodec/h261enc.c
+++ b/libavcodec/h261enc.c
@@ -37,6 +37,14 @@
 static uint8_t uni_h261_rl_len [64*64*2*2];
 #define UNI_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level))
 
+typedef struct H261EncContext {
+    MpegEncContext s;
+
+    H261Context common;
+
+    int gob_number;
+} H261EncContext;
+
 int ff_h261_get_picture_format(int width, int height)
 {
     // QCIF
@@ -52,7 +60,7 @@ int ff_h261_get_picture_format(int width, int height)
 
 void ff_h261_encode_picture_header(MpegEncContext *s, int picture_number)
 {
-    H261Context *h = (H261Context *)s;
+    H261EncContext *const h = (H261EncContext *)s;
     int format, temp_ref;
 
     align_put_bits(&s->pb);
@@ -90,7 +98,7 @@ void ff_h261_encode_picture_header(MpegEncContext *s, int picture_number)
  */
 static void h261_encode_gob_header(MpegEncContext *s, int mb_line)
 {
-    H261Context *h = (H261Context *)s;
+    H261EncContext *const h = (H261EncContext *)s;
     if (ff_h261_get_picture_format(s->width, s->height) == 0) {
         h->gob_number += 2; // QCIF
     } else {
@@ -132,7 +140,7 @@ void ff_h261_reorder_mb_index(MpegEncContext *s)
     }
 }
 
-static void h261_encode_motion(H261Context *h, int val)
+static void h261_encode_motion(H261EncContext *h, int val)
 {
     MpegEncContext *const s = &h->s;
     int sign, code;
@@ -166,7 +174,7 @@ static inline int get_cbp(MpegEncContext *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(H261Context *h, int16_t *block, int n)
+static void h261_encode_block(H261EncContext *h, int16_t *block, int n)
 {
     MpegEncContext *const s = &h->s;
     int level, run, i, j, last_index, last_non_zero, sign, slevel, code;
@@ -237,12 +245,15 @@ static void h261_encode_block(H261Context *h, int16_t *block, int n)
 void ff_h261_encode_mb(MpegEncContext *s, int16_t block[6][64],
                        int motion_x, int motion_y)
 {
-    H261Context *h = (H261Context *)s;
+    /* The following is only allowed because this encoder
+     * does not use slice threading. */
+    H261EncContext *const h = (H261EncContext *)s;
+    H261Context *const com = &h->common;
     int mvd, mv_diff_x, mv_diff_y, i, cbp;
     cbp = 63; // avoid warning
     mvd = 0;
 
-    h->mtype = 0;
+    com->mtype = 0;
 
     if (!s->mb_intra) {
         /* compute cbp */
@@ -270,34 +281,34 @@ void ff_h261_encode_mb(MpegEncContext *s, int16_t block[6][64],
 
     /* calculate MTYPE */
     if (!s->mb_intra) {
-        h->mtype++;
+        com->mtype++;
 
         if (mvd || s->loop_filter)
-            h->mtype += 3;
+            com->mtype += 3;
         if (s->loop_filter)
-            h->mtype += 3;
+            com->mtype += 3;
         if (cbp)
-            h->mtype++;
-        av_assert1(h->mtype > 1);
+            com->mtype++;
+        av_assert1(com->mtype > 1);
     }
 
     if (s->dquant && cbp) {
-        h->mtype++;
+        com->mtype++;
     } else
         s->qscale -= s->dquant;
 
     put_bits(&s->pb,
-             ff_h261_mtype_bits[h->mtype],
-             ff_h261_mtype_code[h->mtype]);
+             ff_h261_mtype_bits[com->mtype],
+             ff_h261_mtype_code[com->mtype]);
 
-    h->mtype = ff_h261_mtype_map[h->mtype];
+    com->mtype = ff_h261_mtype_map[com->mtype];
 
-    if (IS_QUANT(h->mtype)) {
+    if (IS_QUANT(com->mtype)) {
         ff_set_qscale(s, s->qscale + s->dquant);
         put_bits(&s->pb, 5, s->qscale);
     }
 
-    if (IS_16X16(h->mtype)) {
+    if (IS_16X16(com->mtype)) {
         mv_diff_x       = (motion_x >> 1) - s->last_mv[0][0][0];
         mv_diff_y       = (motion_y >> 1) - s->last_mv[0][0][1];
         s->last_mv[0][0][0] = (motion_x >> 1);
@@ -306,7 +317,7 @@ void ff_h261_encode_mb(MpegEncContext *s, int16_t block[6][64],
         h261_encode_motion(h, mv_diff_y);
     }
 
-    if (HAS_CBP(h->mtype)) {
+    if (HAS_CBP(com->mtype)) {
         av_assert1(cbp > 0);
         put_bits(&s->pb,
                  ff_h261_cbp_tab[cbp - 1][1],
@@ -316,7 +327,7 @@ void ff_h261_encode_mb(MpegEncContext *s, int16_t block[6][64],
         /* encode each block */
         h261_encode_block(h, block[i], i);
 
-    if (!IS_16X16(h->mtype)) {
+    if (!IS_16X16(com->mtype)) {
         s->last_mv[0][0][0] = 0;
         s->last_mv[0][0][1] = 0;
     }
@@ -371,8 +382,11 @@ static av_cold void h261_encode_init_static(void)
 
 av_cold void ff_h261_encode_init(MpegEncContext *s)
 {
+    H261EncContext *const h = (H261EncContext*)s;
     static AVOnce init_static_once = AV_ONCE_INIT;
 
+    s->private_ctx = &h->common;
+
     s->min_qcoeff       = -127;
     s->max_qcoeff       = 127;
     s->y_dc_scale_table =
@@ -390,7 +404,7 @@ const AVCodec ff_h261_encoder = {
     .type           = AVMEDIA_TYPE_VIDEO,
     .id             = AV_CODEC_ID_H261,
     .priv_class     = &ff_mpv_enc_class,
-    .priv_data_size = sizeof(H261Context),
+    .priv_data_size = sizeof(H261EncContext),
     .init           = ff_mpv_encode_init,
     .encode2        = ff_mpv_encode_picture,
     .close          = ff_mpv_encode_end,
-- 
2.32.0

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

[FFmpeg-devel] [PATCH 06/41] avcodec/h261enc: Pass PutBitContext directly in h261_encode_motion()

[Andreas Rheinhardt]

Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
---
 libavcodec/h261enc.c | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

diff --git a/libavcodec/h261enc.c b/libavcodec/h261enc.c
index 13fe5bbfb2..7e3af1ff9e 100644
--- a/libavcodec/h261enc.c
+++ b/libavcodec/h261enc.c
@@ -140,13 +140,12 @@ void ff_h261_reorder_mb_index(MpegEncContext *s)
     }
 }
 
-static void h261_encode_motion(H261EncContext *h, int val)
+static void h261_encode_motion(PutBitContext *pb, int val)
 {
-    MpegEncContext *const s = &h->s;
     int sign, code;
     if (val == 0) {
         code = 0;
-        put_bits(&s->pb, ff_h261_mv_tab[code][1], ff_h261_mv_tab[code][0]);
+        put_bits(pb, ff_h261_mv_tab[code][1], ff_h261_mv_tab[code][0]);
     } else {
         if (val > 15)
             val -= 32;
@@ -154,8 +153,8 @@ static void h261_encode_motion(H261EncContext *h, int val)
             val += 32;
         sign = val < 0;
         code = sign ? -val : val;
-        put_bits(&s->pb, ff_h261_mv_tab[code][1], ff_h261_mv_tab[code][0]);
-        put_bits(&s->pb, 1, sign);
+        put_bits(pb, ff_h261_mv_tab[code][1], ff_h261_mv_tab[code][0]);
+        put_bits(pb, 1, sign);
     }
 }
 
@@ -313,8 +312,8 @@ void ff_h261_encode_mb(MpegEncContext *s, int16_t block[6][64],
         mv_diff_y       = (motion_y >> 1) - s->last_mv[0][0][1];
         s->last_mv[0][0][0] = (motion_x >> 1);
         s->last_mv[0][0][1] = (motion_y >> 1);
-        h261_encode_motion(h, mv_diff_x);
-        h261_encode_motion(h, mv_diff_y);
+        h261_encode_motion(&s->pb, mv_diff_x);
+        h261_encode_motion(&s->pb, mv_diff_y);
     }
 
     if (HAS_CBP(com->mtype)) {
-- 
2.32.0

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

[FFmpeg-devel] [PATCH 07/41] avcodec/idctdsp: Constify the permutation parameter of ff_init_scantable

[Andreas Rheinhardt]

Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
---
 libavcodec/idctdsp.c | 2 +-
 libavcodec/idctdsp.h | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/libavcodec/idctdsp.c b/libavcodec/idctdsp.c
index 71bd03c606..d07dc29207 100644
--- a/libavcodec/idctdsp.c
+++ b/libavcodec/idctdsp.c
@@ -26,7 +26,7 @@
 #include "simple_idct.h"
 #include "xvididct.h"
 
-av_cold void ff_init_scantable(uint8_t *permutation, ScanTable *st,
+av_cold void ff_init_scantable(const uint8_t *permutation, ScanTable *st,
                                const uint8_t *src_scantable)
 {
     int i, end;
diff --git a/libavcodec/idctdsp.h b/libavcodec/idctdsp.h
index 014488aec3..e8f20acaf2 100644
--- a/libavcodec/idctdsp.h
+++ b/libavcodec/idctdsp.h
@@ -43,7 +43,7 @@ enum idct_permutation_type {
     FF_IDCT_PERM_SSE2,
 };
 
-void ff_init_scantable(uint8_t *permutation, ScanTable *st,
+void ff_init_scantable(const uint8_t *permutation, ScanTable *st,
                        const uint8_t *src_scantable);
 void ff_init_scantable_permutation(uint8_t *idct_permutation,
                                    enum idct_permutation_type perm_type);
-- 
2.32.0

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

[FFmpeg-devel] [PATCH 08/41] avcodec/wmv2: Move initializing abt_scantables to the decoder

[Andreas Rheinhardt]

They are not used by the encoder at all.

Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
---
 libavcodec/wmv2.c    | 6 ------
 libavcodec/wmv2dec.c | 6 ++++++
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/libavcodec/wmv2.c b/libavcodec/wmv2.c
index fd64a0938f..57e1267782 100644
--- a/libavcodec/wmv2.c
+++ b/libavcodec/wmv2.c
@@ -20,11 +20,9 @@
 
 #include "avcodec.h"
 #include "idctdsp.h"
-#include "mpegutils.h"
 #include "mpegvideo.h"
 #include "msmpeg4data.h"
 #include "wmv2.h"
-#include "wmv2data.h"
 
 
 av_cold void ff_wmv2_common_init(Wmv2Context *w)
@@ -36,10 +34,6 @@ av_cold void ff_wmv2_common_init(Wmv2Context *w)
     s->idsp.perm_type = w->wdsp.idct_perm;
     ff_init_scantable_permutation(s->idsp.idct_permutation,
                                   w->wdsp.idct_perm);
-    ff_init_scantable(s->idsp.idct_permutation, &w->abt_scantable[0],
-                      ff_wmv2_scantableA);
-    ff_init_scantable(s->idsp.idct_permutation, &w->abt_scantable[1],
-                      ff_wmv2_scantableB);
     ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable,
                       ff_wmv1_scantable[1]);
     ff_init_scantable(s->idsp.idct_permutation, &s->intra_h_scantable,
diff --git a/libavcodec/wmv2dec.c b/libavcodec/wmv2dec.c
index 7518088b6a..dd0e2683f5 100644
--- a/libavcodec/wmv2dec.c
+++ b/libavcodec/wmv2dec.c
@@ -29,6 +29,7 @@
 #include "msmpeg4data.h"
 #include "simple_idct.h"
 #include "wmv2.h"
+#include "wmv2data.h"
 
 
 static void wmv2_add_block(Wmv2Context *w, int16_t *block1,
@@ -537,12 +538,17 @@ int ff_wmv2_decode_mb(MpegEncContext *s, int16_t block[6][64])
 static av_cold int wmv2_decode_init(AVCodecContext *avctx)
 {
     Wmv2Context *const w = avctx->priv_data;
+    MpegEncContext *const s = &w->s;
     int ret;
 
     if ((ret = ff_msmpeg4_decode_init(avctx)) < 0)
         return ret;
 
     ff_wmv2_common_init(w);
+    ff_init_scantable(s->idsp.idct_permutation, &w->abt_scantable[0],
+                      ff_wmv2_scantableA);
+    ff_init_scantable(s->idsp.idct_permutation, &w->abt_scantable[1],
+                      ff_wmv2_scantableB);
 
     return ff_intrax8_common_init(avctx, &w->x8, &w->s.idsp,
                                   w->s.block, w->s.block_last_index,
-- 
2.32.0

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

[FFmpeg-devel] [PATCH 09/41] avcodec/wmv2: Split Wmv2Context into decoder and encoder context

[Andreas Rheinhardt]

Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
---
 libavcodec/wmv2.c    |  6 ++---
 libavcodec/wmv2.h    | 26 +++---------------
 libavcodec/wmv2dec.c | 64 +++++++++++++++++++++++++++++++-------------
 libavcodec/wmv2enc.c | 29 +++++++++++++++-----
 4 files changed, 73 insertions(+), 52 deletions(-)

diff --git a/libavcodec/wmv2.c b/libavcodec/wmv2.c
index 57e1267782..8d1d117dea 100644
--- a/libavcodec/wmv2.c
+++ b/libavcodec/wmv2.c
@@ -25,9 +25,9 @@
 #include "wmv2.h"
 
 
-av_cold void ff_wmv2_common_init(Wmv2Context *w)
+av_cold void ff_wmv2_common_init(MpegEncContext *s)
 {
-    MpegEncContext *const s = &w->s;
+    WMV2Context *const w = s->private_ctx;
 
     ff_blockdsp_init(&s->bdsp, s->avctx);
     ff_wmv2dsp_init(&w->wdsp);
@@ -52,7 +52,7 @@ void ff_mspel_motion(MpegEncContext *s, uint8_t *dest_y,
                      uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
                      int motion_x, int motion_y, int h)
 {
-    Wmv2Context *const w = (Wmv2Context *) s;
+    WMV2Context *const w = s->private_ctx;
     uint8_t *ptr;
     int dxy, mx, my, src_x, src_y, v_edge_pos;
     ptrdiff_t offset, linesize, uvlinesize;
diff --git a/libavcodec/wmv2.h b/libavcodec/wmv2.h
index 1798dbabcd..4001093881 100644
--- a/libavcodec/wmv2.h
+++ b/libavcodec/wmv2.h
@@ -21,9 +21,6 @@
 #ifndef AVCODEC_WMV2_H
 #define AVCODEC_WMV2_H
 
-#include "libavutil/mem_internal.h"
-
-#include "intrax8.h"
 #include "mpegvideo.h"
 #include "wmv2dsp.h"
 
@@ -33,29 +30,12 @@
 #define SKIP_TYPE_COL  3
 
 
-typedef struct Wmv2Context {
-    MpegEncContext s;
-    IntraX8Context x8;
+typedef struct WMV2Context {
     WMV2DSPContext wdsp;
-    int j_type_bit;
-    int j_type;
-    int abt_flag;
-    int abt_type;
-    int abt_type_table[6];
-    int per_mb_abt;
-    int per_block_abt;
-    int mspel_bit;
-    int cbp_table_index;
-    int top_left_mv_flag;
-    int per_mb_rl_bit;
-    int skip_type;
     int hshift;
+} WMV2Context;
 
-    ScanTable abt_scantable[2];
-    DECLARE_ALIGNED(32, int16_t, abt_block2)[6][64];
-} Wmv2Context;
-
-void ff_wmv2_common_init(Wmv2Context *w);
+void ff_wmv2_common_init(MpegEncContext *s);
 
 int ff_wmv2_decode_mb(MpegEncContext *s, int16_t block[6][64]);
 int ff_wmv2_encode_picture_header(MpegEncContext * s, int picture_number);
diff --git a/libavcodec/wmv2dec.c b/libavcodec/wmv2dec.c
index dd0e2683f5..f9d91f9571 100644
--- a/libavcodec/wmv2dec.c
+++ b/libavcodec/wmv2dec.c
@@ -18,6 +18,8 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
+#include "libavutil/mem_internal.h"
+
 #include "avcodec.h"
 #include "h263dec.h"
 #include "internal.h"
@@ -31,8 +33,28 @@
 #include "wmv2.h"
 #include "wmv2data.h"
 
-
-static void wmv2_add_block(Wmv2Context *w, int16_t *block1,
+typedef struct WMV2DecContext {
+    MpegEncContext s;
+    WMV2Context common;
+    IntraX8Context x8;
+    int j_type_bit;
+    int j_type;
+    int abt_flag;
+    int abt_type;
+    int abt_type_table[6];
+    int per_mb_abt;
+    int per_block_abt;
+    int mspel_bit;
+    int cbp_table_index;
+    int top_left_mv_flag;
+    int per_mb_rl_bit;
+    int skip_type;
+
+    ScanTable abt_scantable[2];
+    DECLARE_ALIGNED(32, int16_t, abt_block2)[6][64];
+} WMV2DecContext;
+
+static void wmv2_add_block(WMV2DecContext *w, int16_t *block1,
                            uint8_t *dst, int stride, int n)
 {
     MpegEncContext *const s = &w->s;
@@ -40,7 +62,7 @@ static void wmv2_add_block(Wmv2Context *w, int16_t *block1,
     if (s->block_last_index[n] >= 0) {
         switch (w->abt_type_table[n]) {
         case 0:
-            w->wdsp.idct_add(dst, stride, block1);
+            w->common.wdsp.idct_add(dst, stride, block1);
             break;
         case 1:
             ff_simple_idct84_add(dst, stride, block1);
@@ -61,7 +83,7 @@ static void wmv2_add_block(Wmv2Context *w, int16_t *block1,
 void ff_wmv2_add_mb(MpegEncContext *s, int16_t block1[6][64],
                     uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr)
 {
-    Wmv2Context *const w = (Wmv2Context *) s;
+    WMV2DecContext *const w = (WMV2DecContext *) s;
 
     wmv2_add_block(w, block1[0], dest_y,                       s->linesize, 0);
     wmv2_add_block(w, block1[1], dest_y + 8,                   s->linesize, 1);
@@ -75,7 +97,7 @@ void ff_wmv2_add_mb(MpegEncContext *s, int16_t block1[6][64],
     wmv2_add_block(w, block1[5], dest_cr, s->uvlinesize, 5);
 }
 
-static int parse_mb_skip(Wmv2Context *w)
+static int parse_mb_skip(WMV2DecContext *w)
 {
     int mb_x, mb_y;
     int coded_mb_count = 0;
@@ -140,7 +162,7 @@ static int parse_mb_skip(Wmv2Context *w)
     return 0;
 }
 
-static int decode_ext_header(Wmv2Context *w)
+static int decode_ext_header(WMV2DecContext *w)
 {
     MpegEncContext *const s = &w->s;
     GetBitContext gb;
@@ -180,7 +202,7 @@ static int decode_ext_header(Wmv2Context *w)
 
 int ff_wmv2_decode_picture_header(MpegEncContext *s)
 {
-    Wmv2Context *const w = (Wmv2Context *) s;
+    WMV2DecContext *const w = (WMV2DecContext *) s;
     int code;
 
     if (s->picture_number == 0)
@@ -215,7 +237,7 @@ int ff_wmv2_decode_picture_header(MpegEncContext *s)
 
 int ff_wmv2_decode_secondary_picture_header(MpegEncContext *s)
 {
-    Wmv2Context *const w = (Wmv2Context *) s;
+    WMV2DecContext *const w = (WMV2DecContext *) s;
 
     if (s->pict_type == AV_PICTURE_TYPE_I) {
         if (w->j_type_bit)
@@ -323,19 +345,19 @@ int ff_wmv2_decode_secondary_picture_header(MpegEncContext *s)
     return 0;
 }
 
-static inline void wmv2_decode_motion(Wmv2Context *w, int *mx_ptr, int *my_ptr)
+static inline void wmv2_decode_motion(WMV2DecContext *w, int *mx_ptr, int *my_ptr)
 {
     MpegEncContext *const s = &w->s;
 
     ff_msmpeg4_decode_motion(s, mx_ptr, my_ptr);
 
     if ((((*mx_ptr) | (*my_ptr)) & 1) && s->mspel)
-        w->hshift = get_bits1(&s->gb);
+        w->common.hshift = get_bits1(&s->gb);
     else
-        w->hshift = 0;
+        w->common.hshift = 0;
 }
 
-static int16_t *wmv2_pred_motion(Wmv2Context *w, int *px, int *py)
+static int16_t *wmv2_pred_motion(WMV2DecContext *w, int *px, int *py)
 {
     MpegEncContext *const s = &w->s;
     int xy, wrap, diff, type;
@@ -380,7 +402,7 @@ static int16_t *wmv2_pred_motion(Wmv2Context *w, int *px, int *py)
     return mot_val;
 }
 
-static inline int wmv2_decode_inter_block(Wmv2Context *w, int16_t *block,
+static inline int wmv2_decode_inter_block(WMV2DecContext *w, int16_t *block,
                                           int n, int cbp)
 {
     MpegEncContext *const s = &w->s;
@@ -422,7 +444,9 @@ static inline int wmv2_decode_inter_block(Wmv2Context *w, int16_t *block,
 
 int ff_wmv2_decode_mb(MpegEncContext *s, int16_t block[6][64])
 {
-    Wmv2Context *const w = (Wmv2Context *) s;
+    /* The following is only allowed because this encoder
+     * does not use slice threading. */
+    WMV2DecContext *const w = (WMV2DecContext *) s;
     int cbp, code, i, ret;
     uint8_t *coded_val;
 
@@ -440,7 +464,7 @@ int ff_wmv2_decode_mb(MpegEncContext *s, int16_t block[6][64])
             s->mv[0][0][0] = 0;
             s->mv[0][0][1] = 0;
             s->mb_skipped  = 1;
-            w->hshift      = 0;
+            w->common.hshift      = 0;
             return 0;
         }
         if (get_bits_left(&s->gb) <= 0)
@@ -537,14 +561,16 @@ int ff_wmv2_decode_mb(MpegEncContext *s, int16_t block[6][64])
 
 static av_cold int wmv2_decode_init(AVCodecContext *avctx)
 {
-    Wmv2Context *const w = avctx->priv_data;
+    WMV2DecContext *const w = avctx->priv_data;
     MpegEncContext *const s = &w->s;
     int ret;
 
+    s->private_ctx = &w->common;
+
     if ((ret = ff_msmpeg4_decode_init(avctx)) < 0)
         return ret;
 
-    ff_wmv2_common_init(w);
+    ff_wmv2_common_init(s);
     ff_init_scantable(s->idsp.idct_permutation, &w->abt_scantable[0],
                       ff_wmv2_scantableA);
     ff_init_scantable(s->idsp.idct_permutation, &w->abt_scantable[1],
@@ -557,7 +583,7 @@ static av_cold int wmv2_decode_init(AVCodecContext *avctx)
 
 static av_cold int wmv2_decode_end(AVCodecContext *avctx)
 {
-    Wmv2Context *w = avctx->priv_data;
+    WMV2DecContext *const w = avctx->priv_data;
 
     ff_intrax8_common_end(&w->x8);
     return ff_h263_decode_end(avctx);
@@ -568,7 +594,7 @@ const AVCodec ff_wmv2_decoder = {
     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Video 8"),
     .type           = AVMEDIA_TYPE_VIDEO,
     .id             = AV_CODEC_ID_WMV2,
-    .priv_data_size = sizeof(Wmv2Context),
+    .priv_data_size = sizeof(WMV2DecContext),
     .init           = wmv2_decode_init,
     .close          = wmv2_decode_end,
     .decode         = ff_h263_decode_frame,
diff --git a/libavcodec/wmv2enc.c b/libavcodec/wmv2enc.c
index ab5365d1f6..a7827f3194 100644
--- a/libavcodec/wmv2enc.c
+++ b/libavcodec/wmv2enc.c
@@ -25,8 +25,21 @@
 #include "msmpeg4data.h"
 #include "wmv2.h"
 
-
-static int encode_ext_header(Wmv2Context *w)
+typedef struct WMV2EncContext {
+    MpegEncContext s;
+    WMV2Context common;
+    int j_type_bit;
+    int j_type;
+    int abt_flag;
+    int abt_type;
+    int per_mb_abt;
+    int mspel_bit;
+    int cbp_table_index;
+    int top_left_mv_flag;
+    int per_mb_rl_bit;
+} WMV2EncContext;
+
+static int encode_ext_header(WMV2EncContext *w)
 {
     MpegEncContext *const s = &w->s;
     PutBitContext pb;
@@ -54,12 +67,14 @@ static int encode_ext_header(Wmv2Context *w)
 
 static av_cold int wmv2_encode_init(AVCodecContext *avctx)
 {
-    Wmv2Context *const w = avctx->priv_data;
+    WMV2EncContext *const w = avctx->priv_data;
+    MpegEncContext *const s = &w->s;
 
+    s->private_ctx = &w->common;
     if (ff_mpv_encode_init(avctx) < 0)
         return -1;
 
-    ff_wmv2_common_init(w);
+    ff_wmv2_common_init(&w->s);
 
     avctx->extradata_size = 4;
     avctx->extradata      = av_mallocz(avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
@@ -73,7 +88,7 @@ static av_cold int wmv2_encode_init(AVCodecContext *avctx)
 
 int ff_wmv2_encode_picture_header(MpegEncContext *s, int picture_number)
 {
-    Wmv2Context *const w = (Wmv2Context *) s;
+    WMV2EncContext *const w = (WMV2EncContext *) s;
 
     put_bits(&s->pb, 1, s->pict_type - 1);
     if (s->pict_type == AV_PICTURE_TYPE_I)
@@ -147,7 +162,7 @@ int ff_wmv2_encode_picture_header(MpegEncContext *s, int picture_number)
 void ff_wmv2_encode_mb(MpegEncContext *s, int16_t block[6][64],
                        int motion_x, int motion_y)
 {
-    Wmv2Context *const w = (Wmv2Context *) s;
+    WMV2EncContext *const w = (WMV2EncContext *) s;
     int cbp, coded_cbp, i;
     int pred_x, pred_y;
     uint8_t *coded_block;
@@ -220,7 +235,7 @@ const AVCodec ff_wmv2_encoder = {
     .type           = AVMEDIA_TYPE_VIDEO,
     .id             = AV_CODEC_ID_WMV2,
     .priv_class     = &ff_mpv_enc_class,
-    .priv_data_size = sizeof(Wmv2Context),
+    .priv_data_size = sizeof(WMV2EncContext),
     .init           = wmv2_encode_init,
     .encode2        = ff_mpv_encode_picture,
     .close          = ff_mpv_encode_end,
-- 
2.32.0

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

[FFmpeg-devel] [PATCH 10/41] avcodec/msmpeg4.h: Move encoder-only stuff to a new header

[Andreas Rheinhardt]

Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
---
 libavcodec/mpegvideo_enc.c |  2 +-
 libavcodec/msmpeg4.h       | 15 -------------
 libavcodec/msmpeg4enc.c    |  1 +
 libavcodec/msmpeg4enc.h    | 45 ++++++++++++++++++++++++++++++++++++++
 libavcodec/wmv2enc.c       |  1 +
 5 files changed, 48 insertions(+), 16 deletions(-)
 create mode 100644 libavcodec/msmpeg4enc.h

diff --git a/libavcodec/mpegvideo_enc.c b/libavcodec/mpegvideo_enc.c
index 6df2a46eaa..4bc78841ac 100644
--- a/libavcodec/mpegvideo_enc.c
+++ b/libavcodec/mpegvideo_enc.c
@@ -56,7 +56,7 @@
 #include "mpegutils.h"
 #include "mjpegenc.h"
 #include "speedhqenc.h"
-#include "msmpeg4.h"
+#include "msmpeg4enc.h"
 #include "pixblockdsp.h"
 #include "qpeldsp.h"
 #include "faandct.h"
diff --git a/libavcodec/msmpeg4.h b/libavcodec/msmpeg4.h
index 483c965b9d..dbe650cbbc 100644
--- a/libavcodec/msmpeg4.h
+++ b/libavcodec/msmpeg4.h
@@ -28,7 +28,6 @@
 #include "avcodec.h"
 #include "mpegvideo.h"
 #include "msmpeg4data.h"
-#include "put_bits.h"
 
 #define INTER_INTRA_VLC_BITS 3
 #define MB_NON_INTRA_VLC_BITS 9
@@ -42,20 +41,10 @@
 extern VLC ff_mb_non_intra_vlc[4];
 extern VLC ff_inter_intra_vlc;
 
-void ff_msmpeg4_code012(PutBitContext *pb, int n);
 void ff_msmpeg4_common_init(MpegEncContext *s);
-void ff_msmpeg4_encode_block(MpegEncContext * s, int16_t * block, int n);
-void ff_msmpeg4_handle_slices(MpegEncContext *s);
-void ff_msmpeg4_encode_motion(MpegEncContext * s, int mx, int my);
 int ff_msmpeg4_coded_block_pred(MpegEncContext * s, int n,
                                 uint8_t **coded_block_ptr);
 
-void ff_msmpeg4_encode_init(MpegEncContext *s);
-void ff_msmpeg4_encode_picture_header(MpegEncContext *s, int picture_number);
-void ff_msmpeg4_encode_ext_header(MpegEncContext *s);
-void ff_msmpeg4_encode_mb(MpegEncContext *s, int16_t block[6][64],
-                          int motion_x, int motion_y);
-
 int ff_msmpeg4_decode_init(AVCodecContext *avctx);
 int ff_msmpeg4_decode_picture_header(MpegEncContext *s);
 int ff_msmpeg4_decode_ext_header(MpegEncContext *s, int buf_size);
@@ -72,9 +61,5 @@ int ff_msmpeg4_pred_dc(MpegEncContext *s, int n,
                                 CONFIG_WMV1_DECODER      || \
                                 CONFIG_WMV2_DECODER      || \
                                 CONFIG_VC1_DECODER)
-#define CONFIG_MSMPEG4_ENCODER (CONFIG_MSMPEG4V2_ENCODER || \
-                                CONFIG_MSMPEG4V3_ENCODER || \
-                                CONFIG_WMV1_ENCODER      || \
-                                CONFIG_WMV2_ENCODER)
 
 #endif /* AVCODEC_MSMPEG4_H */
diff --git a/libavcodec/msmpeg4enc.c b/libavcodec/msmpeg4enc.c
index 2c619e1210..31920b7f0d 100644
--- a/libavcodec/msmpeg4enc.c
+++ b/libavcodec/msmpeg4enc.c
@@ -39,6 +39,7 @@
 #include "mpeg4video.h"
 #include "msmpeg4.h"
 #include "msmpeg4data.h"
+#include "msmpeg4enc.h"
 #include "put_bits.h"
 #include "rl.h"
 #include "vc1data.h"
diff --git a/libavcodec/msmpeg4enc.h b/libavcodec/msmpeg4enc.h
new file mode 100644
index 0000000000..12f8f44232
--- /dev/null
+++ b/libavcodec/msmpeg4enc.h
@@ -0,0 +1,45 @@
+/*
+ * MSMPEG4 encoder header
+ * copyright (c) 2007 Aurelien Jacobs <aurel@gnuage.org>
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef AVCODEC_MSMPEG4ENC_H
+#define AVCODEC_MSMPEG4ENC_H
+
+#include "config.h"
+#include "mpegvideo.h"
+#include "put_bits.h"
+
+void ff_msmpeg4_encode_init(MpegEncContext *s);
+void ff_msmpeg4_encode_picture_header(MpegEncContext *s, int picture_number);
+void ff_msmpeg4_encode_ext_header(MpegEncContext *s);
+void ff_msmpeg4_encode_mb(MpegEncContext *s, int16_t block[6][64],
+                          int motion_x, int motion_y);
+void ff_msmpeg4_encode_block(MpegEncContext * s, int16_t * block, int n);
+void ff_msmpeg4_handle_slices(MpegEncContext *s);
+void ff_msmpeg4_encode_motion(MpegEncContext * s, int mx, int my);
+
+void ff_msmpeg4_code012(PutBitContext *pb, int n);
+
+#define CONFIG_MSMPEG4_ENCODER (CONFIG_MSMPEG4V2_ENCODER || \
+                                CONFIG_MSMPEG4V3_ENCODER || \
+                                CONFIG_WMV1_ENCODER      || \
+                                CONFIG_WMV2_ENCODER)
+
+#endif
diff --git a/libavcodec/wmv2enc.c b/libavcodec/wmv2enc.c
index a7827f3194..6036a0dec9 100644
--- a/libavcodec/wmv2enc.c
+++ b/libavcodec/wmv2enc.c
@@ -22,6 +22,7 @@
 #include "h263.h"
 #include "mpegvideo.h"
 #include "msmpeg4.h"
+#include "msmpeg4enc.h"
 #include "msmpeg4data.h"
 #include "wmv2.h"
 
-- 
2.32.0

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

[FFmpeg-devel] [PATCH 11/41] avcodec/msmpegenc: Add MSMPEG4EncContext and move ac_stats to it

[Andreas Rheinhardt]

Also avoid the allocation by making it part of the context.

Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
---
 libavcodec/mpegvideo.h     |  2 --
 libavcodec/mpegvideo_enc.c |  7 -------
 libavcodec/msmpeg4enc.c    | 26 +++++++++++++++-----------
 libavcodec/msmpeg4enc.h    |  8 ++++++++
 libavcodec/wmv2enc.c       |  8 ++++----
 5 files changed, 27 insertions(+), 24 deletions(-)

diff --git a/libavcodec/mpegvideo.h b/libavcodec/mpegvideo.h
index 5e406b9a9c..f5c9789fea 100644
--- a/libavcodec/mpegvideo.h
+++ b/libavcodec/mpegvideo.h
@@ -422,8 +422,6 @@ typedef struct MpegEncContext {
     int per_mb_rl_table;
     int esc3_level_length;
     int esc3_run_length;
-    /** [mb_intra][isChroma][level][run][last] */
-    int (*ac_stats)[2][MAX_LEVEL+1][MAX_RUN+1][2];
     int inter_intra_pred;
     int mspel;
 
diff --git a/libavcodec/mpegvideo_enc.c b/libavcodec/mpegvideo_enc.c
index 4bc78841ac..0e38824cca 100644
--- a/libavcodec/mpegvideo_enc.c
+++ b/libavcodec/mpegvideo_enc.c
@@ -813,12 +813,6 @@ av_cold int ff_mpv_encode_init(AVCodecContext *avctx)
     ff_pixblockdsp_init(&s->pdsp, avctx);
     ff_qpeldsp_init(&s->qdsp);
 
-    if (s->msmpeg4_version) {
-        int ac_stats_size = 2 * 2 * (MAX_LEVEL + 1) *  (MAX_RUN + 1) * 2 * sizeof(int);
-        if (!(s->ac_stats = av_mallocz(ac_stats_size)))
-            return AVERROR(ENOMEM);
-    }
-
     if (!(avctx->stats_out = av_mallocz(256))               ||
         !FF_ALLOCZ_TYPED_ARRAY(s->q_intra_matrix,          32) ||
         !FF_ALLOCZ_TYPED_ARRAY(s->q_chroma_intra_matrix,   32) ||
@@ -944,7 +938,6 @@ av_cold int ff_mpv_encode_end(AVCodecContext *avctx)
     ff_mpv_picture_free(avctx, &s->new_picture);
 
     av_freep(&avctx->stats_out);
-    av_freep(&s->ac_stats);
 
     if(s->q_chroma_intra_matrix   != s->q_intra_matrix  ) av_freep(&s->q_chroma_intra_matrix);
     if(s->q_chroma_intra_matrix16 != s->q_intra_matrix16) av_freep(&s->q_chroma_intra_matrix16);
diff --git a/libavcodec/msmpeg4enc.c b/libavcodec/msmpeg4enc.c
index 31920b7f0d..c436f78f9d 100644
--- a/libavcodec/msmpeg4enc.c
+++ b/libavcodec/msmpeg4enc.c
@@ -148,8 +148,9 @@ av_cold void ff_msmpeg4_encode_init(MpegEncContext *s)
     ff_thread_once(&init_static_once, msmpeg4_encode_init_static);
 }
 
-static void find_best_tables(MpegEncContext * s)
+static void find_best_tables(MSMPEG4EncContext *ms)
 {
+    MpegEncContext *const s = &ms->s;
     int i;
     int best        = 0, best_size        = INT_MAX;
     int chroma_best = 0, best_chroma_size = INT_MAX;
@@ -169,9 +170,9 @@ static void find_best_tables(MpegEncContext * s)
                 int last;
                 const int last_size= size + chroma_size;
                 for(last=0; last<2; last++){
-                    int inter_count       = s->ac_stats[0][0][level][run][last] + s->ac_stats[0][1][level][run][last];
-                    int intra_luma_count  = s->ac_stats[1][0][level][run][last];
-                    int intra_chroma_count= s->ac_stats[1][1][level][run][last];
+                    int inter_count       = ms->ac_stats[0][0][level][run][last] + ms->ac_stats[0][1][level][run][last];
+                    int intra_luma_count  = ms->ac_stats[1][0][level][run][last];
+                    int intra_chroma_count= ms->ac_stats[1][1][level][run][last];
 
                     if(s->pict_type==AV_PICTURE_TYPE_I){
                         size       += intra_luma_count  *rl_length[i  ][level][run][last];
@@ -197,7 +198,7 @@ static void find_best_tables(MpegEncContext * s)
 
     if(s->pict_type==AV_PICTURE_TYPE_P) chroma_best= best;
 
-    memset(s->ac_stats, 0, sizeof(int)*(MAX_LEVEL+1)*(MAX_RUN+1)*2*2*2);
+    memset(ms->ac_stats, 0, sizeof(ms->ac_stats));
 
     s->rl_table_index       =        best;
     s->rl_chroma_table_index= chroma_best;
@@ -215,7 +216,9 @@ static void find_best_tables(MpegEncContext * s)
 /* write MSMPEG4 compatible frame header */
 void ff_msmpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
 {
-    find_best_tables(s);
+    MSMPEG4EncContext *const ms = (MSMPEG4EncContext*)s;
+
+    find_best_tables(ms);
 
     align_put_bits(&s->pb);
     put_bits(&s->pb, 2, s->pict_type - 1);
@@ -553,6 +556,7 @@ static void msmpeg4_encode_dc(MpegEncContext * s, int level, int n, int *dir_ptr
  * escape coding (same as H.263) and more VLC tables. */
 void ff_msmpeg4_encode_block(MpegEncContext * s, int16_t * block, int n)
 {
+    MSMPEG4EncContext *const ms = (MSMPEG4EncContext*)s;
     int level, run, last, i, j, last_index;
     int last_non_zero, sign, slevel;
     int code, run_diff, dc_pred_dir;
@@ -603,10 +607,10 @@ void ff_msmpeg4_encode_block(MpegEncContext * s, int16_t * block, int n)
             }
 
             if(level<=MAX_LEVEL && run<=MAX_RUN){
-                s->ac_stats[s->mb_intra][n>3][level][run][last]++;
+                ms->ac_stats[s->mb_intra][n>3][level][run][last]++;
             }
 
-            s->ac_stats[s->mb_intra][n > 3][40][63][0]++; //esc3 like
+            ms->ac_stats[s->mb_intra][n > 3][40][63][0]++; //esc3 like
 
             code = get_rl_index(rl, last, run, level);
             put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
@@ -679,7 +683,7 @@ const AVCodec ff_msmpeg4v2_encoder = {
     .pix_fmts       = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
     .priv_class     = &ff_mpv_enc_class,
     .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
-    .priv_data_size = sizeof(MpegEncContext),
+    .priv_data_size = sizeof(MSMPEG4EncContext),
     .init           = ff_mpv_encode_init,
     .encode2        = ff_mpv_encode_picture,
     .close          = ff_mpv_encode_end,
@@ -693,7 +697,7 @@ const AVCodec ff_msmpeg4v3_encoder = {
     .pix_fmts       = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
     .priv_class     = &ff_mpv_enc_class,
     .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
-    .priv_data_size = sizeof(MpegEncContext),
+    .priv_data_size = sizeof(MSMPEG4EncContext),
     .init           = ff_mpv_encode_init,
     .encode2        = ff_mpv_encode_picture,
     .close          = ff_mpv_encode_end,
@@ -707,7 +711,7 @@ const AVCodec ff_wmv1_encoder = {
     .pix_fmts       = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
     .priv_class     = &ff_mpv_enc_class,
     .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
-    .priv_data_size = sizeof(MpegEncContext),
+    .priv_data_size = sizeof(MSMPEG4EncContext),
     .init           = ff_mpv_encode_init,
     .encode2        = ff_mpv_encode_picture,
     .close          = ff_mpv_encode_end,
diff --git a/libavcodec/msmpeg4enc.h b/libavcodec/msmpeg4enc.h
index 12f8f44232..98044913b1 100644
--- a/libavcodec/msmpeg4enc.h
+++ b/libavcodec/msmpeg4enc.h
@@ -25,6 +25,14 @@
 #include "config.h"
 #include "mpegvideo.h"
 #include "put_bits.h"
+#include "rl.h"
+
+typedef struct MSMPEG4EncContext {
+    MpegEncContext s;
+
+    /** [mb_intra][isChroma][level][run][last] */
+    unsigned ac_stats[2][2][MAX_LEVEL + 1][MAX_RUN + 1][2];
+} MSMPEG4EncContext;
 
 void ff_msmpeg4_encode_init(MpegEncContext *s);
 void ff_msmpeg4_encode_picture_header(MpegEncContext *s, int picture_number);
diff --git a/libavcodec/wmv2enc.c b/libavcodec/wmv2enc.c
index 6036a0dec9..d6962448a6 100644
--- a/libavcodec/wmv2enc.c
+++ b/libavcodec/wmv2enc.c
@@ -27,7 +27,7 @@
 #include "wmv2.h"
 
 typedef struct WMV2EncContext {
-    MpegEncContext s;
+    MSMPEG4EncContext msmpeg4;
     WMV2Context common;
     int j_type_bit;
     int j_type;
@@ -42,7 +42,7 @@ typedef struct WMV2EncContext {
 
 static int encode_ext_header(WMV2EncContext *w)
 {
-    MpegEncContext *const s = &w->s;
+    MpegEncContext *const s = &w->msmpeg4.s;
     PutBitContext pb;
     int code;
 
@@ -69,13 +69,13 @@ static int encode_ext_header(WMV2EncContext *w)
 static av_cold int wmv2_encode_init(AVCodecContext *avctx)
 {
     WMV2EncContext *const w = avctx->priv_data;
-    MpegEncContext *const s = &w->s;
+    MpegEncContext *const s = &w->msmpeg4.s;
 
     s->private_ctx = &w->common;
     if (ff_mpv_encode_init(avctx) < 0)
         return -1;
 
-    ff_wmv2_common_init(&w->s);
+    ff_wmv2_common_init(s);
 
     avctx->extradata_size = 4;
     avctx->extradata      = av_mallocz(avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
-- 
2.32.0

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

[FFmpeg-devel] [PATCH 12/41] avcodec/h263.h: Move encoder-only stuff to a new header h263enc.h

[Andreas Rheinhardt]

Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
---
 libavcodec/h263.h          |  99 ----------------------------
 libavcodec/h263enc.h       | 130 +++++++++++++++++++++++++++++++++++++
 libavcodec/ituh263enc.c    |   1 +
 libavcodec/mpeg4videodec.c |   1 +
 libavcodec/mpeg4videoenc.c |   1 +
 libavcodec/mpegvideo_enc.c |   1 +
 libavcodec/msmpeg4dec.c    |   1 +
 libavcodec/msmpeg4enc.c    |   1 +
 libavcodec/rv20enc.c       |   2 +-
 libavcodec/snowenc.c       |   2 +-
 libavcodec/svq1enc.c       |   1 +
 11 files changed, 139 insertions(+), 101 deletions(-)
 create mode 100644 libavcodec/h263enc.h

diff --git a/libavcodec/h263.h b/libavcodec/h263.h
index 6dd5d2295a..5e4a5bc6e5 100644
--- a/libavcodec/h263.h
+++ b/libavcodec/h263.h
@@ -20,119 +20,20 @@
 #ifndef AVCODEC_H263_H
 #define AVCODEC_H263_H
 
-#include <stdint.h>
 #include "libavutil/rational.h"
 #include "mpegvideo.h"
-#include "h263data.h"
 
 #define FF_ASPECT_EXTENDED 15
 
 #define H263_GOB_HEIGHT(h) ((h) <= 400 ? 1 : (h) <= 800 ? 2 : 4)
 
 av_const int ff_h263_aspect_to_info(AVRational aspect);
-void ff_h263_encode_mb(MpegEncContext *s,
-                       int16_t block[6][64],
-                       int motion_x, int motion_y);
-void ff_h263_encode_picture_header(MpegEncContext *s, int picture_number);
-void ff_h263_encode_gob_header(MpegEncContext * s, int mb_line);
 int16_t *ff_h263_pred_motion(MpegEncContext * s, int block, int dir,
                              int *px, int *py);
-void ff_h263_encode_init(MpegEncContext *s);
 void ff_h263_init_rl_inter(void);
 void ff_h263_update_motion_val(MpegEncContext * s);
 void ff_h263_loop_filter(MpegEncContext * s);
-void ff_h263_encode_mba(MpegEncContext *s);
-void ff_init_qscale_tab(MpegEncContext *s);
 
 
-void ff_clean_h263_qscales(MpegEncContext *s);
-void ff_h263_encode_motion(PutBitContext *pb, int val, int f_code);
-
-
-static inline int h263_get_motion_length(int val, int f_code){
-    int bit_size, code, sign;
-
-    if (val == 0) {
-        return 1; /* ff_mvtab[0][1] */
-    } else {
-        bit_size = f_code - 1;
-        /* modulo encoding */
-        val  = sign_extend(val, 6 + bit_size);
-        sign = val >> 31;
-        val  = (val ^ sign) - sign; /* val = FFABS(val) */
-        val--;
-        code = (val >> bit_size) + 1;
-
-        return ff_mvtab[code][1] + 1 + bit_size;
-    }
-}
-
-static inline void ff_h263_encode_motion_vector(MpegEncContext * s, int x, int y, int f_code){
-    if (s->avctx->flags2 & AV_CODEC_FLAG2_NO_OUTPUT) {
-        skip_put_bits(&s->pb,
-            h263_get_motion_length(x, f_code)
-           +h263_get_motion_length(y, f_code));
-    }else{
-        ff_h263_encode_motion(&s->pb, x, f_code);
-        ff_h263_encode_motion(&s->pb, y, f_code);
-    }
-}
-
-static inline int get_p_cbp(MpegEncContext * s,
-                      int16_t block[6][64],
-                      int motion_x, int motion_y){
-    int cbp, i;
-
-    if (s->mpv_flags & FF_MPV_FLAG_CBP_RD) {
-        int best_cbpy_score= INT_MAX;
-        int best_cbpc_score= INT_MAX;
-        int cbpc = (-1), cbpy= (-1);
-        const int offset= (s->mv_type==MV_TYPE_16X16 ? 0 : 16) + (s->dquant ? 8 : 0);
-        const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
-
-        for(i=0; i<4; i++){
-            int score= ff_h263_inter_MCBPC_bits[i + offset] * lambda;
-            if(i&1) score += s->coded_score[5];
-            if(i&2) score += s->coded_score[4];
-
-            if(score < best_cbpc_score){
-                best_cbpc_score= score;
-                cbpc= i;
-            }
-        }
-
-        for(i=0; i<16; i++){
-            int score= ff_h263_cbpy_tab[i ^ 0xF][1] * lambda;
-            if(i&1) score += s->coded_score[3];
-            if(i&2) score += s->coded_score[2];
-            if(i&4) score += s->coded_score[1];
-            if(i&8) score += s->coded_score[0];
-
-            if(score < best_cbpy_score){
-                best_cbpy_score= score;
-                cbpy= i;
-            }
-        }
-        cbp= cbpc + 4*cbpy;
-        if ((motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16){
-            if(best_cbpy_score + best_cbpc_score + 2*lambda >= 0)
-                cbp= 0;
-        }
-
-        for (i = 0; i < 6; i++) {
-            if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){
-                s->block_last_index[i]= -1;
-                s->bdsp.clear_block(s->block[i]);
-            }
-        }
-    }else{
-        cbp= 0;
-        for (i = 0; i < 6; i++) {
-            if (s->block_last_index[i] >= 0)
-                cbp |= 1 << (5 - i);
-        }
-    }
-    return cbp;
-}
 
 #endif /* AVCODEC_H263_H */
diff --git a/libavcodec/h263enc.h b/libavcodec/h263enc.h
new file mode 100644
index 0000000000..31f00665ce
--- /dev/null
+++ b/libavcodec/h263enc.h
@@ -0,0 +1,130 @@
+/*
+ * H.263 encoder header
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+#ifndef AVCODEC_H263ENC_H
+#define AVCODEC_H263ENC_H
+
+#include <stdint.h>
+#include "h263data.h"
+#include "mpegvideo.h"
+
+void ff_h263_encode_init(MpegEncContext *s);
+void ff_h263_encode_picture_header(MpegEncContext *s, int picture_number);
+void ff_h263_encode_gob_header(MpegEncContext * s, int mb_line);
+void ff_h263_encode_mb(MpegEncContext *s,
+                       int16_t block[6][64],
+                       int motion_x, int motion_y);
+void ff_h263_encode_mba(MpegEncContext *s);
+
+void ff_init_qscale_tab(MpegEncContext *s);
+void ff_clean_h263_qscales(MpegEncContext *s);
+
+void ff_h263_encode_motion(PutBitContext *pb, int val, int f_code);
+
+
+static inline int h263_get_motion_length(int val, int f_code)
+{
+    int bit_size, code, sign;
+
+    if (val == 0) {
+        return 1; /* ff_mvtab[0][1] */
+    } else {
+        bit_size = f_code - 1;
+        /* modulo encoding */
+        val  = sign_extend(val, 6 + bit_size);
+        sign = val >> 31;
+        val  = (val ^ sign) - sign; /* val = FFABS(val) */
+        val--;
+        code = (val >> bit_size) + 1;
+
+        return ff_mvtab[code][1] + 1 + bit_size;
+    }
+}
+
+static inline void ff_h263_encode_motion_vector(MpegEncContext * s,
+                                                int x, int y, int f_code)
+{
+    if (s->avctx->flags2 & AV_CODEC_FLAG2_NO_OUTPUT) {
+        skip_put_bits(&s->pb,
+                      h263_get_motion_length(x, f_code) +
+                      h263_get_motion_length(y, f_code));
+    } else {
+        ff_h263_encode_motion(&s->pb, x, f_code);
+        ff_h263_encode_motion(&s->pb, y, f_code);
+    }
+}
+
+static inline int get_p_cbp(MpegEncContext * s,
+                      int16_t block[6][64],
+                      int motion_x, int motion_y){
+    int cbp;
+
+    if (s->mpv_flags & FF_MPV_FLAG_CBP_RD) {
+        int best_cbpy_score = INT_MAX;
+        int best_cbpc_score = INT_MAX;
+        int cbpc = (-1), cbpy = (-1);
+        const int offset = (s->mv_type == MV_TYPE_16X16 ? 0 : 16) + (s->dquant ? 8 : 0);
+        const int lambda = s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
+
+        for (int i = 0; i < 4; i++) {
+            int score = ff_h263_inter_MCBPC_bits[i + offset] * lambda;
+            if (i & 1) score += s->coded_score[5];
+            if (i & 2) score += s->coded_score[4];
+
+            if (score < best_cbpc_score) {
+                best_cbpc_score = score;
+                cbpc = i;
+            }
+        }
+
+        for (int i = 0; i < 16; i++) {
+            int score= ff_h263_cbpy_tab[i ^ 0xF][1] * lambda;
+            if (i & 1) score += s->coded_score[3];
+            if (i & 2) score += s->coded_score[2];
+            if (i & 4) score += s->coded_score[1];
+            if (i & 8) score += s->coded_score[0];
+
+            if (score < best_cbpy_score) {
+                best_cbpy_score = score;
+                cbpy = i;
+            }
+        }
+        cbp = cbpc + 4 * cbpy;
+        if (!(motion_x | motion_y | s->dquant) && s->mv_type == MV_TYPE_16X16) {
+            if (best_cbpy_score + best_cbpc_score + 2 * lambda >= 0)
+                cbp= 0;
+        }
+
+        for (int i = 0; i < 6; i++) {
+            if (s->block_last_index[i] >= 0 && !((cbp >> (5 - i)) & 1)) {
+                s->block_last_index[i] = -1;
+                s->bdsp.clear_block(s->block[i]);
+            }
+        }
+    } else {
+        cbp = 0;
+        for (int i = 0; i < 6; i++) {
+            if (s->block_last_index[i] >= 0)
+                cbp |= 1 << (5 - i);
+        }
+    }
+    return cbp;
+}
+
+#endif
diff --git a/libavcodec/ituh263enc.c b/libavcodec/ituh263enc.c
index 9253d60a16..70ac1f643b 100644
--- a/libavcodec/ituh263enc.c
+++ b/libavcodec/ituh263enc.c
@@ -35,6 +35,7 @@
 #include "mpegvideo.h"
 #include "mpegvideodata.h"
 #include "h263.h"
+#include "h263enc.h"
 #include "h263data.h"
 #include "mathops.h"
 #include "mpegutils.h"
diff --git a/libavcodec/mpeg4videodec.c b/libavcodec/mpeg4videodec.c
index 2aea845580..c0eaa00eba 100644
--- a/libavcodec/mpeg4videodec.c
+++ b/libavcodec/mpeg4videodec.c
@@ -36,6 +36,7 @@
 #include "mpeg4video.h"
 #include "mpeg4videodata.h"
 #include "h263.h"
+#include "h263data.h"
 #include "h263dec.h"
 #include "profiles.h"
 #include "thread.h"
diff --git a/libavcodec/mpeg4videoenc.c b/libavcodec/mpeg4videoenc.c
index 27e16c3b72..8a1a6cbcc8 100644
--- a/libavcodec/mpeg4videoenc.c
+++ b/libavcodec/mpeg4videoenc.c
@@ -27,6 +27,7 @@
 #include "mpegutils.h"
 #include "mpegvideo.h"
 #include "h263.h"
+#include "h263enc.h"
 #include "mpeg4video.h"
 #include "mpeg4videodata.h"
 #include "profiles.h"
diff --git a/libavcodec/mpegvideo_enc.c b/libavcodec/mpegvideo_enc.c
index 0e38824cca..5717b7422e 100644
--- a/libavcodec/mpegvideo_enc.c
+++ b/libavcodec/mpegvideo_enc.c
@@ -51,6 +51,7 @@
 #include "h261.h"
 #include "h263.h"
 #include "h263data.h"
+#include "h263enc.h"
 #include "mjpegenc_common.h"
 #include "mathops.h"
 #include "mpegutils.h"
diff --git a/libavcodec/msmpeg4dec.c b/libavcodec/msmpeg4dec.c
index 3d2dcb9429..77ad8a8ff4 100644
--- a/libavcodec/msmpeg4dec.c
+++ b/libavcodec/msmpeg4dec.c
@@ -29,6 +29,7 @@
 #include "msmpeg4.h"
 #include "libavutil/imgutils.h"
 #include "h263.h"
+#include "h263data.h"
 #include "h263dec.h"
 #include "mpeg4video.h"
 #include "msmpeg4data.h"
diff --git a/libavcodec/msmpeg4enc.c b/libavcodec/msmpeg4enc.c
index c436f78f9d..16e19083da 100644
--- a/libavcodec/msmpeg4enc.c
+++ b/libavcodec/msmpeg4enc.c
@@ -35,6 +35,7 @@
 #include "libavutil/thread.h"
 #include "mpegvideo.h"
 #include "h263.h"
+#include "h263enc.h"
 #include "internal.h"
 #include "mpeg4video.h"
 #include "msmpeg4.h"
diff --git a/libavcodec/rv20enc.c b/libavcodec/rv20enc.c
index 19b6aab278..204cd03a24 100644
--- a/libavcodec/rv20enc.c
+++ b/libavcodec/rv20enc.c
@@ -27,8 +27,8 @@
 
 #include "mpegvideo.h"
 #include "mpegvideodata.h"
-#include "h263.h"
 #include "h263data.h"
+#include "h263enc.h"
 #include "put_bits.h"
 #include "rv10.h"
 
diff --git a/libavcodec/snowenc.c b/libavcodec/snowenc.c
index df31eb8132..e169ae601d 100644
--- a/libavcodec/snowenc.c
+++ b/libavcodec/snowenc.c
@@ -34,7 +34,7 @@
 #include "mathops.h"
 
 #include "mpegvideo.h"
-#include "h263.h"
+#include "h263enc.h"
 
 static av_cold int encode_init(AVCodecContext *avctx)
 {
diff --git a/libavcodec/svq1enc.c b/libavcodec/svq1enc.c
index 11cbd97185..9cef3d8ef6 100644
--- a/libavcodec/svq1enc.c
+++ b/libavcodec/svq1enc.c
@@ -32,6 +32,7 @@
 #include "me_cmp.h"
 #include "mpegvideo.h"
 #include "h263.h"
+#include "h263enc.h"
 #include "internal.h"
 #include "mpegutils.h"
 #include "packet_internal.h"
-- 
2.32.0

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

[FFmpeg-devel] [PATCH 13/41] avcodec/mpegvideo: Move encoder-only stuff to a new header

[Andreas Rheinhardt]

Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
---
 libavcodec/dnxhdenc.c           |   1 +
 libavcodec/flvdec.c             |   1 +
 libavcodec/flvenc.c             |   1 +
 libavcodec/h261enc.c            |   1 +
 libavcodec/h263enc.h            |   2 +-
 libavcodec/intelh263dec.c       |   1 +
 libavcodec/ituh263enc.c         |   1 +
 libavcodec/libxavs2.c           |   2 +
 libavcodec/mdec.c               |   1 +
 libavcodec/mjpegenc.c           |   1 +
 libavcodec/motion_est.c         |   2 +-
 libavcodec/mpeg12.h             |   1 +
 libavcodec/mpeg12enc.c          |   1 +
 libavcodec/mpeg4videoenc.c      |   1 +
 libavcodec/mpegvideo.h          | 126 -------------------------
 libavcodec/mpegvideo_enc.c      |   1 +
 libavcodec/mpegvideoenc.h       | 161 ++++++++++++++++++++++++++++++++
 libavcodec/msmpeg4enc.c         |   1 +
 libavcodec/nvdec_mpeg12.c       |   1 +
 libavcodec/nvdec_mpeg4.c        |   1 +
 libavcodec/ratecontrol.c        |   2 +-
 libavcodec/rv10enc.c            |   1 +
 libavcodec/rv20enc.c            |   1 +
 libavcodec/rv30.c               |   1 +
 libavcodec/rv40.c               |   1 +
 libavcodec/speedhqenc.c         |   1 +
 libavcodec/vaapi_encode_mpeg2.c |   2 +
 libavcodec/wmv2enc.c            |   1 +
 libavcodec/x86/mpegvideoenc.c   |   2 +-
 29 files changed, 190 insertions(+), 130 deletions(-)
 create mode 100644 libavcodec/mpegvideoenc.h

diff --git a/libavcodec/dnxhdenc.c b/libavcodec/dnxhdenc.c
index ca67964330..ac92474e56 100644
--- a/libavcodec/dnxhdenc.c
+++ b/libavcodec/dnxhdenc.c
@@ -34,6 +34,7 @@
 #include "fdctdsp.h"
 #include "internal.h"
 #include "mpegvideo.h"
+#include "mpegvideoenc.h"
 #include "pixblockdsp.h"
 #include "packet_internal.h"
 #include "profiles.h"
diff --git a/libavcodec/flvdec.c b/libavcodec/flvdec.c
index 2bd86b5b47..108cf88e34 100644
--- a/libavcodec/flvdec.c
+++ b/libavcodec/flvdec.c
@@ -22,6 +22,7 @@
 
 #include "flv.h"
 #include "h263dec.h"
+#include "internal.h"
 #include "mpegvideo.h"
 #include "mpegvideodata.h"
 
diff --git a/libavcodec/flvenc.c b/libavcodec/flvenc.c
index 158b399c40..6824327734 100644
--- a/libavcodec/flvenc.c
+++ b/libavcodec/flvenc.c
@@ -22,6 +22,7 @@
 #include "h263data.h"
 #include "mpegvideo.h"
 #include "mpegvideodata.h"
+#include "mpegvideoenc.h"
 
 void ff_flv_encode_picture_header(MpegEncContext *s, int picture_number)
 {
diff --git a/libavcodec/h261enc.c b/libavcodec/h261enc.c
index 7e3af1ff9e..710d292df6 100644
--- a/libavcodec/h261enc.c
+++ b/libavcodec/h261enc.c
@@ -33,6 +33,7 @@
 #include "mpegvideo.h"
 #include "h261.h"
 #include "mpegvideodata.h"
+#include "mpegvideoenc.h"
 
 static uint8_t uni_h261_rl_len [64*64*2*2];
 #define UNI_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level))
diff --git a/libavcodec/h263enc.h b/libavcodec/h263enc.h
index 31f00665ce..fff85a18f2 100644
--- a/libavcodec/h263enc.h
+++ b/libavcodec/h263enc.h
@@ -22,7 +22,7 @@
 
 #include <stdint.h>
 #include "h263data.h"
-#include "mpegvideo.h"
+#include "mpegvideoenc.h"
 
 void ff_h263_encode_init(MpegEncContext *s);
 void ff_h263_encode_picture_header(MpegEncContext *s, int picture_number);
diff --git a/libavcodec/intelh263dec.c b/libavcodec/intelh263dec.c
index 9dde247298..b61effa4df 100644
--- a/libavcodec/intelh263dec.c
+++ b/libavcodec/intelh263dec.c
@@ -18,6 +18,7 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
+#include "internal.h"
 #include "mpegutils.h"
 #include "mpegvideo.h"
 #include "h263data.h"
diff --git a/libavcodec/ituh263enc.c b/libavcodec/ituh263enc.c
index 70ac1f643b..ef7caf8009 100644
--- a/libavcodec/ituh263enc.c
+++ b/libavcodec/ituh263enc.c
@@ -34,6 +34,7 @@
 #include "avcodec.h"
 #include "mpegvideo.h"
 #include "mpegvideodata.h"
+#include "mpegvideoenc.h"
 #include "h263.h"
 #include "h263enc.h"
 #include "h263data.h"
diff --git a/libavcodec/libxavs2.c b/libavcodec/libxavs2.c
index 9c5a576e90..4742b18f9f 100644
--- a/libavcodec/libxavs2.c
+++ b/libavcodec/libxavs2.c
@@ -24,8 +24,10 @@
 
 #include "xavs2.h"
 #include "encode.h"
+#include "internal.h"
 #include "mpeg12.h"
 #include "libavutil/avstring.h"
+#include "libavutil/opt.h"
 
 #define xavs2_opt_set2(name, format, ...) do{ \
     char opt_str[16] = {0}; \
diff --git a/libavcodec/mdec.c b/libavcodec/mdec.c
index 007e7fada8..f340bdf385 100644
--- a/libavcodec/mdec.c
+++ b/libavcodec/mdec.c
@@ -33,6 +33,7 @@
 #include "blockdsp.h"
 #include "bswapdsp.h"
 #include "idctdsp.h"
+#include "internal.h"
 #include "mpeg12.h"
 #include "mpeg12data.h"
 #include "thread.h"
diff --git a/libavcodec/mjpegenc.c b/libavcodec/mjpegenc.c
index 6a47503ab4..b9b17a50df 100644
--- a/libavcodec/mjpegenc.c
+++ b/libavcodec/mjpegenc.c
@@ -39,6 +39,7 @@
 #include "mpegvideo.h"
 #include "mjpeg.h"
 #include "mjpegenc.h"
+#include "mpegvideoenc.h"
 #include "profiles.h"
 
 /* The following is the private context of MJPEG/AMV decoder.
diff --git a/libavcodec/motion_est.c b/libavcodec/motion_est.c
index 5b0958733c..35ca40b90a 100644
--- a/libavcodec/motion_est.c
+++ b/libavcodec/motion_est.c
@@ -36,7 +36,7 @@
 #include "mathops.h"
 #include "motion_est.h"
 #include "mpegutils.h"
-#include "mpegvideo.h"
+#include "mpegvideoenc.h"
 
 #define P_LEFT P[1]
 #define P_TOP P[2]
diff --git a/libavcodec/mpeg12.h b/libavcodec/mpeg12.h
index fb2b37e7c8..7ab2527a36 100644
--- a/libavcodec/mpeg12.h
+++ b/libavcodec/mpeg12.h
@@ -24,6 +24,7 @@
 
 #include "mpeg12vlc.h"
 #include "mpegvideo.h"
+#include "rl.h"
 
 /* Start codes. */
 #define SEQ_END_CODE            0x000001b7
diff --git a/libavcodec/mpeg12enc.c b/libavcodec/mpeg12enc.c
index 9c0be69ded..3ec3ac1860 100644
--- a/libavcodec/mpeg12enc.c
+++ b/libavcodec/mpeg12enc.c
@@ -43,6 +43,7 @@
 #include "mpeg12data.h"
 #include "mpegutils.h"
 #include "mpegvideo.h"
+#include "mpegvideoenc.h"
 #include "profiles.h"
 
 #if CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER
diff --git a/libavcodec/mpeg4videoenc.c b/libavcodec/mpeg4videoenc.c
index 8a1a6cbcc8..d09e20605d 100644
--- a/libavcodec/mpeg4videoenc.c
+++ b/libavcodec/mpeg4videoenc.c
@@ -30,6 +30,7 @@
 #include "h263enc.h"
 #include "mpeg4video.h"
 #include "mpeg4videodata.h"
+#include "mpegvideoenc.h"
 #include "profiles.h"
 
 /* The uni_DCtab_* tables below contain unified bits+length tables to encode DC
diff --git a/libavcodec/mpegvideo.h b/libavcodec/mpegvideo.h
index f5c9789fea..18d2d0902f 100644
--- a/libavcodec/mpegvideo.h
+++ b/libavcodec/mpegvideo.h
@@ -39,7 +39,6 @@
 #include "h263dsp.h"
 #include "hpeldsp.h"
 #include "idctdsp.h"
-#include "internal.h"
 #include "me_cmp.h"
 #include "motion_est.h"
 #include "mpegpicture.h"
@@ -54,11 +53,8 @@
 #endif
 #include "mpegutils.h"
 #include "qpeldsp.h"
-#include "rl.h"
 #include "videodsp.h"
 
-#include "libavutil/opt.h"
-
 #define MAX_THREADS 32
 
 #define MAX_B_FRAMES 16
@@ -558,101 +554,6 @@ typedef struct MpegEncContext {
 #endif
 } MpegEncContext;
 
-/* mpegvideo_enc common options */
-#define FF_MPV_FLAG_SKIP_RD      0x0001
-#define FF_MPV_FLAG_STRICT_GOP   0x0002
-#define FF_MPV_FLAG_QP_RD        0x0004
-#define FF_MPV_FLAG_CBP_RD       0x0008
-#define FF_MPV_FLAG_NAQ          0x0010
-#define FF_MPV_FLAG_MV0          0x0020
-
-#define FF_MPV_OPT_CMP_FUNC \
-{ "sad",    "Sum of absolute differences, fast", 0, AV_OPT_TYPE_CONST, {.i64 = FF_CMP_SAD }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS, "cmp_func" }, \
-{ "sse",    "Sum of squared errors", 0, AV_OPT_TYPE_CONST, {.i64 = FF_CMP_SSE }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS, "cmp_func" }, \
-{ "satd",   "Sum of absolute Hadamard transformed differences", 0, AV_OPT_TYPE_CONST, {.i64 = FF_CMP_SATD }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS, "cmp_func" }, \
-{ "dct",    "Sum of absolute DCT transformed differences", 0, AV_OPT_TYPE_CONST, {.i64 = FF_CMP_DCT }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS, "cmp_func" }, \
-{ "psnr",   "Sum of squared quantization errors, low quality", 0, AV_OPT_TYPE_CONST, {.i64 = FF_CMP_PSNR }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS, "cmp_func" }, \
-{ "bit",    "Number of bits needed for the block", 0, AV_OPT_TYPE_CONST, {.i64 = FF_CMP_BIT }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS, "cmp_func" }, \
-{ "rd",     "Rate distortion optimal, slow", 0, AV_OPT_TYPE_CONST, {.i64 = FF_CMP_RD }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS, "cmp_func" }, \
-{ "zero",   "Zero", 0, AV_OPT_TYPE_CONST, {.i64 = FF_CMP_ZERO }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS, "cmp_func" }, \
-{ "vsad",   "Sum of absolute vertical differences", 0, AV_OPT_TYPE_CONST, {.i64 = FF_CMP_VSAD }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS, "cmp_func" }, \
-{ "vsse",   "Sum of squared vertical differences", 0, AV_OPT_TYPE_CONST, {.i64 = FF_CMP_VSSE }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS, "cmp_func" }, \
-{ "nsse",   "Noise preserving sum of squared differences", 0, AV_OPT_TYPE_CONST, {.i64 = FF_CMP_NSSE }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS, "cmp_func" }, \
-{ "dct264", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_CMP_DCT264 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS, "cmp_func" }, \
-{ "dctmax", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_CMP_DCTMAX }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS, "cmp_func" }, \
-{ "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" }
-
-#ifndef FF_MPV_OFFSET
-#define FF_MPV_OFFSET(x) offsetof(MpegEncContext, x)
-#endif
-#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, \
-{ "mpv_flags",      "Flags common for all mpegvideo-based encoders.", FF_MPV_OFFSET(mpv_flags), AV_OPT_TYPE_FLAGS, { .i64 = 0 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS, "mpv_flags" },\
-{ "skip_rd",        "RD optimal MB level residual skipping", 0, AV_OPT_TYPE_CONST, { .i64 = FF_MPV_FLAG_SKIP_RD },    0, 0, FF_MPV_OPT_FLAGS, "mpv_flags" },\
-{ "strict_gop",     "Strictly enforce gop size",             0, AV_OPT_TYPE_CONST, { .i64 = FF_MPV_FLAG_STRICT_GOP }, 0, 0, FF_MPV_OPT_FLAGS, "mpv_flags" },\
-{ "qp_rd",          "Use rate distortion optimization for qp selection", 0, AV_OPT_TYPE_CONST, { .i64 = FF_MPV_FLAG_QP_RD },  0, 0, FF_MPV_OPT_FLAGS, "mpv_flags" },\
-{ "cbp_rd",         "use rate distortion optimization for CBP",          0, AV_OPT_TYPE_CONST, { .i64 = FF_MPV_FLAG_CBP_RD }, 0, 0, FF_MPV_OPT_FLAGS, "mpv_flags" },\
-{ "naq",            "normalize adaptive quantization",                   0, AV_OPT_TYPE_CONST, { .i64 = FF_MPV_FLAG_NAQ },    0, 0, FF_MPV_OPT_FLAGS, "mpv_flags" },\
-{ "mv0",            "always try a mb with mv=<0,0>",                     0, AV_OPT_TYPE_CONST, { .i64 = FF_MPV_FLAG_MV0 },    0, 0, FF_MPV_OPT_FLAGS, "mpv_flags" },\
-{ "luma_elim_threshold",   "single coefficient elimination threshold for luminance (negative values also consider dc coefficient)",\
-                                                                      FF_MPV_OFFSET(luma_elim_threshold), AV_OPT_TYPE_INT, { .i64 = 0 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS },\
-{ "chroma_elim_threshold", "single coefficient elimination threshold for chrominance (negative values also consider dc coefficient)",\
-                                                                      FF_MPV_OFFSET(chroma_elim_threshold), AV_OPT_TYPE_INT, { .i64 = 0 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS },\
-{ "quantizer_noise_shaping", NULL,                                  FF_MPV_OFFSET(quantizer_noise_shaping), AV_OPT_TYPE_INT, { .i64 = 0 },       0, INT_MAX, FF_MPV_OPT_FLAGS },\
-{ "error_rate", "Simulate errors in the bitstream to test error concealment.",                                                                                                  \
-                                                                    FF_MPV_OFFSET(error_rate),              AV_OPT_TYPE_INT, { .i64 = 0 },       0, INT_MAX, FF_MPV_OPT_FLAGS },\
-{"qsquish", "how to keep quantizer between qmin and qmax (0 = clip, 1 = use differentiable function)",                                                                          \
-                                                                    FF_MPV_OFFSET(rc_qsquish), AV_OPT_TYPE_FLOAT, {.dbl = 0 }, 0, 99, FF_MPV_OPT_FLAGS},                        \
-{"rc_qmod_amp", "experimental quantizer modulation",                FF_MPV_OFFSET(rc_qmod_amp), AV_OPT_TYPE_FLOAT, {.dbl = 0 }, -FLT_MAX, FLT_MAX, FF_MPV_OPT_FLAGS},           \
-{"rc_qmod_freq", "experimental quantizer modulation",               FF_MPV_OFFSET(rc_qmod_freq), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS},             \
-{"rc_eq", "Set rate control equation. When computing the expression, besides the standard functions "                                                                           \
-          "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.",                                                                         \
-                                                                    FF_MPV_OFFSET(rc_eq), AV_OPT_TYPE_STRING,                           .flags = FF_MPV_OPT_FLAGS },            \
-{"rc_init_cplx", "initial complexity for 1-pass encoding",          FF_MPV_OFFSET(rc_initial_cplx), AV_OPT_TYPE_FLOAT, {.dbl = 0 }, -FLT_MAX, FLT_MAX, FF_MPV_OPT_FLAGS},       \
-{"rc_buf_aggressivity", "currently useless",                        FF_MPV_OFFSET(rc_buffer_aggressivity), AV_OPT_TYPE_FLOAT, {.dbl = 1.0 }, -FLT_MAX, FLT_MAX, FF_MPV_OPT_FLAGS}, \
-{"border_mask", "increase the quantizer for macroblocks close to borders", FF_MPV_OFFSET(border_masking), AV_OPT_TYPE_FLOAT, {.dbl = 0 }, -FLT_MAX, FLT_MAX, FF_MPV_OPT_FLAGS},    \
-{"lmin", "minimum Lagrange factor (VBR)",                           FF_MPV_OFFSET(lmin), AV_OPT_TYPE_INT, {.i64 =  2*FF_QP2LAMBDA }, 0, INT_MAX, FF_MPV_OPT_FLAGS },            \
-{"lmax", "maximum Lagrange factor (VBR)",                           FF_MPV_OFFSET(lmax), AV_OPT_TYPE_INT, {.i64 = 31*FF_QP2LAMBDA }, 0, INT_MAX, FF_MPV_OPT_FLAGS },            \
-{"ibias", "intra quant bias",                                       FF_MPV_OFFSET(intra_quant_bias), AV_OPT_TYPE_INT, {.i64 = FF_DEFAULT_QUANT_BIAS }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS },   \
-{"pbias", "inter quant bias",                                       FF_MPV_OFFSET(inter_quant_bias), AV_OPT_TYPE_INT, {.i64 = FF_DEFAULT_QUANT_BIAS }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS },   \
-{"motion_est", "motion estimation algorithm",                       FF_MPV_OFFSET(motion_est), AV_OPT_TYPE_INT, {.i64 = FF_ME_EPZS }, FF_ME_ZERO, FF_ME_XONE, FF_MPV_OPT_FLAGS, "motion_est" },   \
-{ "zero", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FF_ME_ZERO }, 0, 0, FF_MPV_OPT_FLAGS, "motion_est" }, \
-{ "epzs", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FF_ME_EPZS }, 0, 0, FF_MPV_OPT_FLAGS, "motion_est" }, \
-{ "xone", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FF_ME_XONE }, 0, 0, FF_MPV_OPT_FLAGS, "motion_est" }, \
-{"skip_threshold", "Frame skip threshold",                          FF_MPV_OFFSET(frame_skip_threshold), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS }, \
-{"skip_factor", "Frame skip factor",                                FF_MPV_OFFSET(frame_skip_factor), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS }, \
-{"skip_exp", "Frame skip exponent",                                 FF_MPV_OFFSET(frame_skip_exp), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS }, \
-{"skip_cmp", "Frame skip compare function",                         FF_MPV_OFFSET(frame_skip_cmp), AV_OPT_TYPE_INT, {.i64 = FF_CMP_DCTMAX }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS, "cmp_func" }, \
-{"sc_threshold", "Scene change threshold",                          FF_MPV_OFFSET(scenechange_threshold), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS }, \
-{"noise_reduction", "Noise reduction",                              FF_MPV_OFFSET(noise_reduction), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS }, \
-{"ps", "RTP payload size in bytes",                             FF_MPV_OFFSET(rtp_payload_size), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS }, \
-{"mepc", "Motion estimation bitrate penalty compensation (1.0 = 256)", FF_MPV_OFFSET(me_penalty_compensation), AV_OPT_TYPE_INT, {.i64 = 256 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS }, \
-{"mepre", "pre motion estimation", FF_MPV_OFFSET(me_pre), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS }, \
-{"intra_penalty", "Penalty for intra blocks in block decision", FF_MPV_OFFSET(intra_penalty), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, INT_MAX/2, FF_MPV_OPT_FLAGS }, \
-
-#define FF_MPV_COMMON_BFRAME_OPTS \
-{"b_strategy", "Strategy to choose between I/P/B-frames",      FF_MPV_OFFSET(b_frame_strategy), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, 2, FF_MPV_OPT_FLAGS }, \
-{"b_sensitivity", "Adjust sensitivity of b_frame_strategy 1",  FF_MPV_OFFSET(b_sensitivity), AV_OPT_TYPE_INT, {.i64 = 40 }, 1, INT_MAX, FF_MPV_OPT_FLAGS }, \
-{"brd_scale", "Downscale frames for dynamic B-frame decision", FF_MPV_OFFSET(brd_scale), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, 3, FF_MPV_OPT_FLAGS },
-
-#if FF_API_MPEGVIDEO_OPTS
-#define FF_MPV_DEPRECATED_MPEG_QUANT_OPT \
-    { "mpeg_quant", "Deprecated, does nothing", FF_MPV_OFFSET(mpeg_quant), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, 0, FF_MPV_OPT_FLAGS | AV_OPT_FLAG_DEPRECATED },
-#define FF_MPV_DEPRECATED_A53_CC_OPT \
-    { "a53cc",      "Deprecated, does nothing", FF_MPV_OFFSET(dummy),      AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, FF_MPV_OPT_FLAGS | AV_OPT_FLAG_DEPRECATED },
-#define FF_MPV_DEPRECATED_MATRIX_OPT \
-   { "force_duplicated_matrix", "Deprecated, does nothing", FF_MPV_OFFSET(dummy), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, FF_MPV_OPT_FLAGS | AV_OPT_FLAG_DEPRECATED },
-#define FF_MPV_DEPRECATED_BFRAME_OPTS \
-   { "b_strategy",    "Deprecated, does nothing", FF_MPV_OFFSET(b_frame_strategy), AV_OPT_TYPE_INT, { .i64 =  0 }, 0, 2, FF_MPV_OPT_FLAGS | AV_OPT_FLAG_DEPRECATED }, \
-   { "b_sensitivity", "Deprecated, does nothing", FF_MPV_OFFSET(b_sensitivity),    AV_OPT_TYPE_INT, { .i64 = 40 }, 1, INT_MAX, FF_MPV_OPT_FLAGS | AV_OPT_FLAG_DEPRECATED }, \
-   { "brd_scale",     "Deprecated, does nothing", FF_MPV_OFFSET(brd_scale),        AV_OPT_TYPE_INT, { .i64 =  0 }, 0, 3, FF_MPV_OPT_FLAGS | AV_OPT_FLAG_DEPRECATED },
-#endif
-
-extern const AVClass ff_mpv_enc_class;
 
 /**
  * Set the given MpegEncContext to common defaults (same for encoding
@@ -661,8 +562,6 @@ extern const AVClass ff_mpv_enc_class;
  */
 void ff_mpv_common_defaults(MpegEncContext *s);
 
-void ff_dct_encode_init_x86(MpegEncContext *s);
-
 int ff_mpv_common_init(MpegEncContext *s);
 void ff_mpv_common_init_arm(MpegEncContext *s);
 void ff_mpv_common_init_axp(MpegEncContext *s);
@@ -703,14 +602,6 @@ void ff_mpv_report_decode_progress(MpegEncContext *s);
 int ff_mpv_frame_start(MpegEncContext *s, AVCodecContext *avctx);
 void ff_mpv_frame_end(MpegEncContext *s);
 
-int ff_mpv_encode_init(AVCodecContext *avctx);
-void ff_mpv_encode_init_x86(MpegEncContext *s);
-
-int ff_mpv_encode_end(AVCodecContext *avctx);
-int ff_mpv_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
-                          const AVFrame *frame, int *got_packet);
-int ff_mpv_reallocate_putbitbuffer(MpegEncContext *s, size_t threshold, size_t size_increase);
-
 void ff_clean_intra_table_entries(MpegEncContext *s);
 void ff_mpeg_draw_horiz_band(MpegEncContext *s, int y, int h);
 void ff_mpeg_flush(AVCodecContext *avctx);
@@ -719,19 +610,11 @@ void ff_print_debug_info(MpegEncContext *s, Picture *p, AVFrame *pict);
 
 int ff_mpv_export_qp_table(MpegEncContext *s, AVFrame *f, Picture *p, int qp_type);
 
-void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix);
-
 int ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src);
 int ff_mpeg_update_thread_context(AVCodecContext *dst, const AVCodecContext *src);
 void ff_set_qscale(MpegEncContext * s, int qscale);
 
 void ff_mpv_idct_init(MpegEncContext *s);
-int ff_dct_encode_init(MpegEncContext *s);
-void ff_convert_matrix(MpegEncContext *s, int (*qmat)[64], uint16_t (*qmat16)[2][64],
-                       const uint16_t *quant_matrix, int bias, int qmin, int qmax, int intra);
-int ff_dct_quantize_c(MpegEncContext *s, int16_t *block, int n, int qscale, int *overflow);
-void ff_block_permute(int16_t *block, uint8_t *permutation,
-                      const uint8_t *scantable, int last);
 void ff_init_block_index(MpegEncContext *s);
 
 void ff_mpv_motion(MpegEncContext *s,
@@ -756,15 +639,6 @@ static inline void ff_update_block_index(MpegEncContext *s){
     s->dest[2]+= (2 >> s->chroma_x_shift) * block_size;
 }
 
-static inline int get_bits_diff(MpegEncContext *s){
-    const int bits= put_bits_count(&s->pb);
-    const int last= s->last_bits;
-
-    s->last_bits = bits;
-
-    return bits - last;
-}
-
 static inline int mpeg_get_qscale(MpegEncContext *s)
 {
     int qscale = get_bits(&s->gb, 5);
diff --git a/libavcodec/mpegvideo_enc.c b/libavcodec/mpegvideo_enc.c
index 5717b7422e..a76b4b9f60 100644
--- a/libavcodec/mpegvideo_enc.c
+++ b/libavcodec/mpegvideo_enc.c
@@ -48,6 +48,7 @@
 #include "mpeg12data.h"
 #include "mpegvideo.h"
 #include "mpegvideodata.h"
+#include "mpegvideoenc.h"
 #include "h261.h"
 #include "h263.h"
 #include "h263data.h"
diff --git a/libavcodec/mpegvideoenc.h b/libavcodec/mpegvideoenc.h
new file mode 100644
index 0000000000..21e7a55e13
--- /dev/null
+++ b/libavcodec/mpegvideoenc.h
@@ -0,0 +1,161 @@
+/*
+ * Generic DCT based hybrid video encoder
+ * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
+ * Copyright (c) 2002-2004 Michael Niedermayer
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+/**
+ * @file
+ * mpegvideo header.
+ */
+
+#ifndef AVCODEC_MPEGVIDEOENC_H
+#define AVCODEC_MPEGVIDEOENC_H
+
+#include "libavutil/opt.h"
+#include "internal.h"
+#include "mpegvideo.h"
+
+/* mpegvideo_enc common options */
+#define FF_MPV_FLAG_SKIP_RD      0x0001
+#define FF_MPV_FLAG_STRICT_GOP   0x0002
+#define FF_MPV_FLAG_QP_RD        0x0004
+#define FF_MPV_FLAG_CBP_RD       0x0008
+#define FF_MPV_FLAG_NAQ          0x0010
+#define FF_MPV_FLAG_MV0          0x0020
+
+#define FF_MPV_OPT_CMP_FUNC \
+{ "sad",    "Sum of absolute differences, fast", 0, AV_OPT_TYPE_CONST, {.i64 = FF_CMP_SAD }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS, "cmp_func" }, \
+{ "sse",    "Sum of squared errors", 0, AV_OPT_TYPE_CONST, {.i64 = FF_CMP_SSE }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS, "cmp_func" }, \
+{ "satd",   "Sum of absolute Hadamard transformed differences", 0, AV_OPT_TYPE_CONST, {.i64 = FF_CMP_SATD }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS, "cmp_func" }, \
+{ "dct",    "Sum of absolute DCT transformed differences", 0, AV_OPT_TYPE_CONST, {.i64 = FF_CMP_DCT }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS, "cmp_func" }, \
+{ "psnr",   "Sum of squared quantization errors, low quality", 0, AV_OPT_TYPE_CONST, {.i64 = FF_CMP_PSNR }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS, "cmp_func" }, \
+{ "bit",    "Number of bits needed for the block", 0, AV_OPT_TYPE_CONST, {.i64 = FF_CMP_BIT }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS, "cmp_func" }, \
+{ "rd",     "Rate distortion optimal, slow", 0, AV_OPT_TYPE_CONST, {.i64 = FF_CMP_RD }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS, "cmp_func" }, \
+{ "zero",   "Zero", 0, AV_OPT_TYPE_CONST, {.i64 = FF_CMP_ZERO }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS, "cmp_func" }, \
+{ "vsad",   "Sum of absolute vertical differences", 0, AV_OPT_TYPE_CONST, {.i64 = FF_CMP_VSAD }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS, "cmp_func" }, \
+{ "vsse",   "Sum of squared vertical differences", 0, AV_OPT_TYPE_CONST, {.i64 = FF_CMP_VSSE }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS, "cmp_func" }, \
+{ "nsse",   "Noise preserving sum of squared differences", 0, AV_OPT_TYPE_CONST, {.i64 = FF_CMP_NSSE }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS, "cmp_func" }, \
+{ "dct264", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_CMP_DCT264 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS, "cmp_func" }, \
+{ "dctmax", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_CMP_DCTMAX }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS, "cmp_func" }, \
+{ "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" }
+
+#ifndef FF_MPV_OFFSET
+#define FF_MPV_OFFSET(x) offsetof(MpegEncContext, x)
+#endif
+#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, \
+{ "mpv_flags",      "Flags common for all mpegvideo-based encoders.", FF_MPV_OFFSET(mpv_flags), AV_OPT_TYPE_FLAGS, { .i64 = 0 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS, "mpv_flags" },\
+{ "skip_rd",        "RD optimal MB level residual skipping", 0, AV_OPT_TYPE_CONST, { .i64 = FF_MPV_FLAG_SKIP_RD },    0, 0, FF_MPV_OPT_FLAGS, "mpv_flags" },\
+{ "strict_gop",     "Strictly enforce gop size",             0, AV_OPT_TYPE_CONST, { .i64 = FF_MPV_FLAG_STRICT_GOP }, 0, 0, FF_MPV_OPT_FLAGS, "mpv_flags" },\
+{ "qp_rd",          "Use rate distortion optimization for qp selection", 0, AV_OPT_TYPE_CONST, { .i64 = FF_MPV_FLAG_QP_RD },  0, 0, FF_MPV_OPT_FLAGS, "mpv_flags" },\
+{ "cbp_rd",         "use rate distortion optimization for CBP",          0, AV_OPT_TYPE_CONST, { .i64 = FF_MPV_FLAG_CBP_RD }, 0, 0, FF_MPV_OPT_FLAGS, "mpv_flags" },\
+{ "naq",            "normalize adaptive quantization",                   0, AV_OPT_TYPE_CONST, { .i64 = FF_MPV_FLAG_NAQ },    0, 0, FF_MPV_OPT_FLAGS, "mpv_flags" },\
+{ "mv0",            "always try a mb with mv=<0,0>",                     0, AV_OPT_TYPE_CONST, { .i64 = FF_MPV_FLAG_MV0 },    0, 0, FF_MPV_OPT_FLAGS, "mpv_flags" },\
+{ "luma_elim_threshold",   "single coefficient elimination threshold for luminance (negative values also consider dc coefficient)",\
+                                                                      FF_MPV_OFFSET(luma_elim_threshold), AV_OPT_TYPE_INT, { .i64 = 0 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS },\
+{ "chroma_elim_threshold", "single coefficient elimination threshold for chrominance (negative values also consider dc coefficient)",\
+                                                                      FF_MPV_OFFSET(chroma_elim_threshold), AV_OPT_TYPE_INT, { .i64 = 0 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS },\
+{ "quantizer_noise_shaping", NULL,                                  FF_MPV_OFFSET(quantizer_noise_shaping), AV_OPT_TYPE_INT, { .i64 = 0 },       0, INT_MAX, FF_MPV_OPT_FLAGS },\
+{ "error_rate", "Simulate errors in the bitstream to test error concealment.",                                                                                                  \
+                                                                    FF_MPV_OFFSET(error_rate),              AV_OPT_TYPE_INT, { .i64 = 0 },       0, INT_MAX, FF_MPV_OPT_FLAGS },\
+{"qsquish", "how to keep quantizer between qmin and qmax (0 = clip, 1 = use differentiable function)",                                                                          \
+                                                                    FF_MPV_OFFSET(rc_qsquish), AV_OPT_TYPE_FLOAT, {.dbl = 0 }, 0, 99, FF_MPV_OPT_FLAGS},                        \
+{"rc_qmod_amp", "experimental quantizer modulation",                FF_MPV_OFFSET(rc_qmod_amp), AV_OPT_TYPE_FLOAT, {.dbl = 0 }, -FLT_MAX, FLT_MAX, FF_MPV_OPT_FLAGS},           \
+{"rc_qmod_freq", "experimental quantizer modulation",               FF_MPV_OFFSET(rc_qmod_freq), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS},             \
+{"rc_eq", "Set rate control equation. When computing the expression, besides the standard functions "                                                                           \
+          "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.",                                                                         \
+                                                                    FF_MPV_OFFSET(rc_eq), AV_OPT_TYPE_STRING,                           .flags = FF_MPV_OPT_FLAGS },            \
+{"rc_init_cplx", "initial complexity for 1-pass encoding",          FF_MPV_OFFSET(rc_initial_cplx), AV_OPT_TYPE_FLOAT, {.dbl = 0 }, -FLT_MAX, FLT_MAX, FF_MPV_OPT_FLAGS},       \
+{"rc_buf_aggressivity", "currently useless",                        FF_MPV_OFFSET(rc_buffer_aggressivity), AV_OPT_TYPE_FLOAT, {.dbl = 1.0 }, -FLT_MAX, FLT_MAX, FF_MPV_OPT_FLAGS}, \
+{"border_mask", "increase the quantizer for macroblocks close to borders", FF_MPV_OFFSET(border_masking), AV_OPT_TYPE_FLOAT, {.dbl = 0 }, -FLT_MAX, FLT_MAX, FF_MPV_OPT_FLAGS},    \
+{"lmin", "minimum Lagrange factor (VBR)",                           FF_MPV_OFFSET(lmin), AV_OPT_TYPE_INT, {.i64 =  2*FF_QP2LAMBDA }, 0, INT_MAX, FF_MPV_OPT_FLAGS },            \
+{"lmax", "maximum Lagrange factor (VBR)",                           FF_MPV_OFFSET(lmax), AV_OPT_TYPE_INT, {.i64 = 31*FF_QP2LAMBDA }, 0, INT_MAX, FF_MPV_OPT_FLAGS },            \
+{"ibias", "intra quant bias",                                       FF_MPV_OFFSET(intra_quant_bias), AV_OPT_TYPE_INT, {.i64 = FF_DEFAULT_QUANT_BIAS }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS },   \
+{"pbias", "inter quant bias",                                       FF_MPV_OFFSET(inter_quant_bias), AV_OPT_TYPE_INT, {.i64 = FF_DEFAULT_QUANT_BIAS }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS },   \
+{"motion_est", "motion estimation algorithm",                       FF_MPV_OFFSET(motion_est), AV_OPT_TYPE_INT, {.i64 = FF_ME_EPZS }, FF_ME_ZERO, FF_ME_XONE, FF_MPV_OPT_FLAGS, "motion_est" },   \
+{ "zero", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FF_ME_ZERO }, 0, 0, FF_MPV_OPT_FLAGS, "motion_est" }, \
+{ "epzs", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FF_ME_EPZS }, 0, 0, FF_MPV_OPT_FLAGS, "motion_est" }, \
+{ "xone", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FF_ME_XONE }, 0, 0, FF_MPV_OPT_FLAGS, "motion_est" }, \
+{"skip_threshold", "Frame skip threshold",                          FF_MPV_OFFSET(frame_skip_threshold), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS }, \
+{"skip_factor", "Frame skip factor",                                FF_MPV_OFFSET(frame_skip_factor), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS }, \
+{"skip_exp", "Frame skip exponent",                                 FF_MPV_OFFSET(frame_skip_exp), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS }, \
+{"skip_cmp", "Frame skip compare function",                         FF_MPV_OFFSET(frame_skip_cmp), AV_OPT_TYPE_INT, {.i64 = FF_CMP_DCTMAX }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS, "cmp_func" }, \
+{"sc_threshold", "Scene change threshold",                          FF_MPV_OFFSET(scenechange_threshold), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS }, \
+{"noise_reduction", "Noise reduction",                              FF_MPV_OFFSET(noise_reduction), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS }, \
+{"ps", "RTP payload size in bytes",                             FF_MPV_OFFSET(rtp_payload_size), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS }, \
+{"mepc", "Motion estimation bitrate penalty compensation (1.0 = 256)", FF_MPV_OFFSET(me_penalty_compensation), AV_OPT_TYPE_INT, {.i64 = 256 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS }, \
+{"mepre", "pre motion estimation", FF_MPV_OFFSET(me_pre), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS }, \
+{"intra_penalty", "Penalty for intra blocks in block decision", FF_MPV_OFFSET(intra_penalty), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, INT_MAX/2, FF_MPV_OPT_FLAGS }, \
+
+#define FF_MPV_COMMON_BFRAME_OPTS \
+{"b_strategy", "Strategy to choose between I/P/B-frames",      FF_MPV_OFFSET(b_frame_strategy), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, 2, FF_MPV_OPT_FLAGS }, \
+{"b_sensitivity", "Adjust sensitivity of b_frame_strategy 1",  FF_MPV_OFFSET(b_sensitivity), AV_OPT_TYPE_INT, {.i64 = 40 }, 1, INT_MAX, FF_MPV_OPT_FLAGS }, \
+{"brd_scale", "Downscale frames for dynamic B-frame decision", FF_MPV_OFFSET(brd_scale), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, 3, FF_MPV_OPT_FLAGS },
+
+#if FF_API_MPEGVIDEO_OPTS
+#define FF_MPV_DEPRECATED_MPEG_QUANT_OPT \
+    { "mpeg_quant", "Deprecated, does nothing", FF_MPV_OFFSET(mpeg_quant), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, 0, FF_MPV_OPT_FLAGS | AV_OPT_FLAG_DEPRECATED },
+#define FF_MPV_DEPRECATED_A53_CC_OPT \
+    { "a53cc",      "Deprecated, does nothing", FF_MPV_OFFSET(dummy),      AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, FF_MPV_OPT_FLAGS | AV_OPT_FLAG_DEPRECATED },
+#define FF_MPV_DEPRECATED_MATRIX_OPT \
+   { "force_duplicated_matrix", "Deprecated, does nothing", FF_MPV_OFFSET(dummy), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, FF_MPV_OPT_FLAGS | AV_OPT_FLAG_DEPRECATED },
+#define FF_MPV_DEPRECATED_BFRAME_OPTS \
+   { "b_strategy",    "Deprecated, does nothing", FF_MPV_OFFSET(b_frame_strategy), AV_OPT_TYPE_INT, { .i64 =  0 }, 0, 2, FF_MPV_OPT_FLAGS | AV_OPT_FLAG_DEPRECATED }, \
+   { "b_sensitivity", "Deprecated, does nothing", FF_MPV_OFFSET(b_sensitivity),    AV_OPT_TYPE_INT, { .i64 = 40 }, 1, INT_MAX, FF_MPV_OPT_FLAGS | AV_OPT_FLAG_DEPRECATED }, \
+   { "brd_scale",     "Deprecated, does nothing", FF_MPV_OFFSET(brd_scale),        AV_OPT_TYPE_INT, { .i64 =  0 }, 0, 3, FF_MPV_OPT_FLAGS | AV_OPT_FLAG_DEPRECATED },
+#endif
+
+extern const AVClass ff_mpv_enc_class;
+
+int ff_mpv_encode_init(AVCodecContext *avctx);
+void ff_mpv_encode_init_x86(MpegEncContext *s);
+
+int ff_mpv_encode_end(AVCodecContext *avctx);
+int ff_mpv_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
+                          const AVFrame *frame, int *got_packet);
+int ff_mpv_reallocate_putbitbuffer(MpegEncContext *s, size_t threshold, size_t size_increase);
+
+void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix);
+
+int ff_dct_encode_init(MpegEncContext *s);
+void ff_dct_encode_init_x86(MpegEncContext *s);
+
+int ff_dct_quantize_c(MpegEncContext *s, int16_t *block, int n, int qscale, int *overflow);
+void ff_convert_matrix(MpegEncContext *s, int (*qmat)[64], uint16_t (*qmat16)[2][64],
+                       const uint16_t *quant_matrix, int bias, int qmin, int qmax, int intra);
+
+void ff_block_permute(int16_t *block, uint8_t *permutation,
+                      const uint8_t *scantable, int last);
+
+static inline int get_bits_diff(MpegEncContext *s)
+{
+    const int bits = put_bits_count(&s->pb);
+    const int last = s->last_bits;
+
+    s->last_bits = bits;
+
+    return bits - last;
+}
+
+#endif
diff --git a/libavcodec/msmpeg4enc.c b/libavcodec/msmpeg4enc.c
index 16e19083da..5e1ed9cc27 100644
--- a/libavcodec/msmpeg4enc.c
+++ b/libavcodec/msmpeg4enc.c
@@ -34,6 +34,7 @@
 #include "libavutil/avutil.h"
 #include "libavutil/thread.h"
 #include "mpegvideo.h"
+#include "mpegvideoenc.h"
 #include "h263.h"
 #include "h263enc.h"
 #include "internal.h"
diff --git a/libavcodec/nvdec_mpeg12.c b/libavcodec/nvdec_mpeg12.c
index 9a9030d8d3..b8db4250bb 100644
--- a/libavcodec/nvdec_mpeg12.c
+++ b/libavcodec/nvdec_mpeg12.c
@@ -21,6 +21,7 @@
  */
 
 #include "avcodec.h"
+#include "internal.h"
 #include "mpegvideo.h"
 #include "nvdec.h"
 #include "decode.h"
diff --git a/libavcodec/nvdec_mpeg4.c b/libavcodec/nvdec_mpeg4.c
index 739b049933..2b2b1b87a1 100644
--- a/libavcodec/nvdec_mpeg4.c
+++ b/libavcodec/nvdec_mpeg4.c
@@ -21,6 +21,7 @@
  */
 
 #include "avcodec.h"
+#include "internal.h"
 #include "mpeg4video.h"
 #include "nvdec.h"
 #include "decode.h"
diff --git a/libavcodec/ratecontrol.c b/libavcodec/ratecontrol.c
index 6b77ccd006..f814e23ed5 100644
--- a/libavcodec/ratecontrol.c
+++ b/libavcodec/ratecontrol.c
@@ -32,7 +32,7 @@
 #include "internal.h"
 #include "ratecontrol.h"
 #include "mpegutils.h"
-#include "mpegvideo.h"
+#include "mpegvideoenc.h"
 #include "libavutil/eval.h"
 
 void ff_write_pass1_stats(MpegEncContext *s)
diff --git a/libavcodec/rv10enc.c b/libavcodec/rv10enc.c
index 72b25e0c55..0c74da1b3c 100644
--- a/libavcodec/rv10enc.c
+++ b/libavcodec/rv10enc.c
@@ -26,6 +26,7 @@
  */
 
 #include "mpegvideo.h"
+#include "mpegvideoenc.h"
 #include "put_bits.h"
 #include "rv10.h"
 
diff --git a/libavcodec/rv20enc.c b/libavcodec/rv20enc.c
index 204cd03a24..9f935d61e2 100644
--- a/libavcodec/rv20enc.c
+++ b/libavcodec/rv20enc.c
@@ -27,6 +27,7 @@
 
 #include "mpegvideo.h"
 #include "mpegvideodata.h"
+#include "mpegvideoenc.h"
 #include "h263data.h"
 #include "h263enc.h"
 #include "put_bits.h"
diff --git a/libavcodec/rv30.c b/libavcodec/rv30.c
index 751647bebe..d11b8430e7 100644
--- a/libavcodec/rv30.c
+++ b/libavcodec/rv30.c
@@ -25,6 +25,7 @@
  */
 
 #include "avcodec.h"
+#include "internal.h"
 #include "mpegutils.h"
 #include "mpegvideo.h"
 #include "golomb.h"
diff --git a/libavcodec/rv40.c b/libavcodec/rv40.c
index 31a7a04e51..0b3f733bc6 100644
--- a/libavcodec/rv40.c
+++ b/libavcodec/rv40.c
@@ -29,6 +29,7 @@
 #include "libavutil/imgutils.h"
 
 #include "avcodec.h"
+#include "internal.h"
 #include "mpegutils.h"
 #include "mpegvideo.h"
 #include "golomb.h"
diff --git a/libavcodec/speedhqenc.c b/libavcodec/speedhqenc.c
index 967774931c..806eae7cf1 100644
--- a/libavcodec/speedhqenc.c
+++ b/libavcodec/speedhqenc.c
@@ -34,6 +34,7 @@
 #include "mpeg12.h"
 #include "mpeg12data.h"
 #include "mpegvideo.h"
+#include "mpegvideoenc.h"
 #include "speedhqenc.h"
 
 extern RLTable ff_rl_speedhq;
diff --git a/libavcodec/vaapi_encode_mpeg2.c b/libavcodec/vaapi_encode_mpeg2.c
index af3a63dab7..d084d8c4b9 100644
--- a/libavcodec/vaapi_encode_mpeg2.c
+++ b/libavcodec/vaapi_encode_mpeg2.c
@@ -20,10 +20,12 @@
 #include <va/va_enc_mpeg2.h>
 
 #include "libavutil/avassert.h"
+#include "libavutil/opt.h"
 
 #include "avcodec.h"
 #include "cbs.h"
 #include "cbs_mpeg2.h"
+#include "internal.h"
 #include "mpeg12.h"
 #include "vaapi_encode.h"
 
diff --git a/libavcodec/wmv2enc.c b/libavcodec/wmv2enc.c
index d6962448a6..d8481301e1 100644
--- a/libavcodec/wmv2enc.c
+++ b/libavcodec/wmv2enc.c
@@ -21,6 +21,7 @@
 #include "avcodec.h"
 #include "h263.h"
 #include "mpegvideo.h"
+#include "mpegvideoenc.h"
 #include "msmpeg4.h"
 #include "msmpeg4enc.h"
 #include "msmpeg4data.h"
diff --git a/libavcodec/x86/mpegvideoenc.c b/libavcodec/x86/mpegvideoenc.c
index 4bad6a87ef..3691cce26c 100644
--- a/libavcodec/x86/mpegvideoenc.c
+++ b/libavcodec/x86/mpegvideoenc.c
@@ -26,7 +26,7 @@
 #include "libavutil/x86/cpu.h"
 #include "libavcodec/avcodec.h"
 #include "libavcodec/dct.h"
-#include "libavcodec/mpegvideo.h"
+#include "libavcodec/mpegvideoenc.h"
 
 /* not permutated inverse zigzag_direct + 1 for MMX quantizer */
 DECLARE_ALIGNED(16, static const uint16_t, inv_zigzag_direct16)[64] = {
-- 
2.32.0

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

[FFmpeg-devel] [PATCH 14/41] avcodec/avcodec: Avoid MpegEncContext in AVHWAccel.decode_mb

[Andreas Rheinhardt]

Use an opaque pointer to void instead.

Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
---
 libavcodec/avcodec.h        | 6 +-----
 libavcodec/mpegvideo_xvmc.c | 3 ++-
 2 files changed, 3 insertions(+), 6 deletions(-)

diff --git a/libavcodec/avcodec.h b/libavcodec/avcodec.h
index ec1a0566a4..918753fd0e 100644
--- a/libavcodec/avcodec.h
+++ b/libavcodec/avcodec.h
@@ -2026,8 +2026,6 @@ typedef struct AVCodecContext {
     int (*get_encode_buffer)(struct AVCodecContext *s, AVPacket *pkt, int flags);
 } AVCodecContext;
 
-struct MpegEncContext;
-
 /**
  * @defgroup lavc_hwaccel AVHWAccel
  *
@@ -2154,10 +2152,8 @@ typedef struct AVHWAccel {
      * XvMC uses it to replace the ff_mpv_reconstruct_mb().
      * Instead of decoding to raw picture, MB parameters are
      * stored in an array provided by the video driver.
-     *
-     * @param s the mpeg context
      */
-    void (*decode_mb)(struct MpegEncContext *s);
+    void (*decode_mb)(void *opaque);
 
     /**
      * Initialize the hwaccel private data.
diff --git a/libavcodec/mpegvideo_xvmc.c b/libavcodec/mpegvideo_xvmc.c
index f06583768c..bfeb453834 100644
--- a/libavcodec/mpegvideo_xvmc.c
+++ b/libavcodec/mpegvideo_xvmc.c
@@ -168,8 +168,9 @@ static int ff_xvmc_field_end(AVCodecContext *avctx)
  * Synthesize the data needed by XvMC to render one macroblock of data.
  * Fill all relevant fields, if necessary do IDCT.
  */
-static void ff_xvmc_decode_mb(struct MpegEncContext *s)
+static void ff_xvmc_decode_mb(void *opaque)
 {
+    MpegEncContext *const s = opaque;
     XvMCMacroBlock *mv_block;
     struct xvmc_pix_fmt *render;
     int i, cbp, blocks_per_mb;
-- 
2.32.0

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

[FFmpeg-devel] [PATCH 15/41] avcodec/speedhqenc: Add SpeedHQEncContext and move slice_start to it

[Andreas Rheinhardt]

Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
---
 libavcodec/mpegvideo.h  |  3 ---
 libavcodec/speedhqenc.c | 19 ++++++++++++++-----
 2 files changed, 14 insertions(+), 8 deletions(-)

diff --git a/libavcodec/mpegvideo.h b/libavcodec/mpegvideo.h
index 18d2d0902f..8f65f53c2a 100644
--- a/libavcodec/mpegvideo.h
+++ b/libavcodec/mpegvideo.h
@@ -421,9 +421,6 @@ typedef struct MpegEncContext {
     int inter_intra_pred;
     int mspel;
 
-    /* SpeedHQ specific */
-    int slice_start;
-
     /* decompression specific */
     GetBitContext gb;
 
diff --git a/libavcodec/speedhqenc.c b/libavcodec/speedhqenc.c
index 806eae7cf1..ba3b1d9393 100644
--- a/libavcodec/speedhqenc.c
+++ b/libavcodec/speedhqenc.c
@@ -55,6 +55,12 @@ static uint32_t speedhq_chr_dc_uni[512];
 
 static uint8_t uni_speedhq_ac_vlc_len[64 * 64 * 2];
 
+typedef struct SpeedHQEncContext {
+    MpegEncContext m;
+
+    int slice_start;
+} SpeedHQEncContext;
+
 static av_cold void speedhq_init_static_data(void)
 {
     ff_rl_init(&ff_rl_speedhq, speedhq_static_rl_table_store);
@@ -124,24 +130,27 @@ av_cold int ff_speedhq_encode_init(MpegEncContext *s)
 
 void ff_speedhq_encode_picture_header(MpegEncContext *s)
 {
+    SpeedHQEncContext *ctx = (SpeedHQEncContext*)s;
+
     put_bits_le(&s->pb, 8, 100 - s->qscale * 2);  /* FIXME why doubled */
     put_bits_le(&s->pb, 24, 4);  /* no second field */
 
+    ctx->slice_start = 4;
     /* length of first slice, will be filled out later */
-    s->slice_start = 4;
     put_bits_le(&s->pb, 24, 0);
 }
 
 void ff_speedhq_end_slice(MpegEncContext *s)
 {
+    SpeedHQEncContext *ctx = (SpeedHQEncContext*)s;
     int slice_len;
 
     flush_put_bits_le(&s->pb);
-    slice_len = s->pb.buf_ptr - (s->pb.buf + s->slice_start);
-    AV_WL24(s->pb.buf + s->slice_start, slice_len);
+    slice_len = put_bytes_output(&s->pb) - ctx->slice_start;
+    AV_WL24(s->pb.buf + ctx->slice_start, slice_len);
 
     /* length of next slice, will be filled out later */
-    s->slice_start = s->pb.buf_ptr - s->pb.buf;
+    ctx->slice_start = put_bytes_output(&s->pb);
     put_bits_le(&s->pb, 24, 0);
 }
 
@@ -274,7 +283,7 @@ const AVCodec ff_speedhq_encoder = {
     .type           = AVMEDIA_TYPE_VIDEO,
     .id             = AV_CODEC_ID_SPEEDHQ,
     .priv_class     = &ff_mpv_enc_class,
-    .priv_data_size = sizeof(MpegEncContext),
+    .priv_data_size = sizeof(SpeedHQEncContext),
     .init           = ff_mpv_encode_init,
     .encode2        = ff_mpv_encode_picture,
     .close          = ff_mpv_encode_end,
-- 
2.32.0

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

[FFmpeg-devel] [PATCH 16/41] avcodec/mpegvideo: Use typedefs for MPV(Main)?(Dec|Enc)?Context

[Andreas Rheinhardt]

This is in preparation for actually adding such contexts
and e.g. moving fields only used by the main thread to
the corresponding "Main" context.

Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
---
 libavcodec/alpha/mpegvideo_alpha.c     |   6 +-
 libavcodec/arm/asm-offsets.h           |   2 +-
 libavcodec/arm/me_cmp_init_arm.c       |  12 +--
 libavcodec/arm/mpegvideo_arm.c         |  18 ++--
 libavcodec/arm/mpegvideo_arm.h         |   2 +-
 libavcodec/arm/mpegvideo_armv5te.c     |   6 +-
 libavcodec/dnxhdenc.c                  |   4 +-
 libavcodec/dnxhdenc.h                  |   4 +-
 libavcodec/dxva2_mpeg2.c               |  14 +--
 libavcodec/dxva2_vc1.c                 |   6 +-
 libavcodec/flv.h                       |   5 +-
 libavcodec/flvdec.c                    |   4 +-
 libavcodec/flvenc.c                    |   4 +-
 libavcodec/h261.c                      |   2 +-
 libavcodec/h261.h                      |  11 +--
 libavcodec/h261dec.c                   |  29 +++---
 libavcodec/h261enc.c                   |  16 ++--
 libavcodec/h263.c                      |   8 +-
 libavcodec/h263.h                      |   6 +-
 libavcodec/h263dec.c                   |  16 ++--
 libavcodec/h263dec.h                   |  15 ++--
 libavcodec/h263enc.h                   |  18 ++--
 libavcodec/intelh263dec.c              |   4 +-
 libavcodec/ituh263dec.c                |  34 +++----
 libavcodec/ituh263enc.c                |  23 ++---
 libavcodec/me_cmp.c                    |  60 ++++++-------
 libavcodec/me_cmp.h                    |   6 +-
 libavcodec/mips/h263dsp_mips.h         |   6 +-
 libavcodec/mips/me_cmp_mips.h          |  32 +++----
 libavcodec/mips/me_cmp_msa.c           |  28 +++---
 libavcodec/mips/mpegvideo_init_mips.c  |   2 +-
 libavcodec/mips/mpegvideo_mips.h       |  12 +--
 libavcodec/mips/mpegvideo_mmi.c        |  12 +--
 libavcodec/mips/mpegvideo_msa.c        |   6 +-
 libavcodec/mjpegenc.c                  |  32 +++----
 libavcodec/mjpegenc.h                  |  14 +--
 libavcodec/motion_est.c                |  54 +++++------
 libavcodec/motion_est.h                |  25 +++---
 libavcodec/motion_est_template.c       |  34 +++----
 libavcodec/mpeg12.c                    |   4 +-
 libavcodec/mpeg12.h                    |  13 +--
 libavcodec/mpeg12dec.c                 | 112 +++++++++++------------
 libavcodec/mpeg12enc.c                 |  32 +++----
 libavcodec/mpeg4video.c                |  10 +--
 libavcodec/mpeg4video.h                |  31 +++----
 libavcodec/mpeg4video_parser.c         |   2 +-
 libavcodec/mpeg4videodec.c             |  80 ++++++++---------
 libavcodec/mpeg4videoenc.c             |  40 ++++-----
 libavcodec/mpeg_er.c                   |   6 +-
 libavcodec/mpeg_er.h                   |   4 +-
 libavcodec/mpegvideo.c                 |  79 ++++++++--------
 libavcodec/mpegvideo.h                 | 110 ++++++++++++-----------
 libavcodec/mpegvideo_dec.c             |  24 ++---
 libavcodec/mpegvideo_enc.c             | 119 ++++++++++++++-----------
 libavcodec/mpegvideo_motion.c          |  28 +++---
 libavcodec/mpegvideo_xvmc.c            |  14 +--
 libavcodec/mpegvideoenc.h              |  19 ++--
 libavcodec/msmpeg4.c                   |   6 +-
 libavcodec/msmpeg4.h                   |  14 +--
 libavcodec/msmpeg4dec.c                |  28 +++---
 libavcodec/msmpeg4enc.c                |  21 ++---
 libavcodec/msmpeg4enc.h                |  18 ++--
 libavcodec/mss2.c                      |   2 +-
 libavcodec/neon/mpegvideo.c            |   6 +-
 libavcodec/nvdec_mpeg12.c              |   2 +-
 libavcodec/nvdec_mpeg4.c               |   2 +-
 libavcodec/nvdec_vc1.c                 |   2 +-
 libavcodec/ppc/me_cmp.c                |  22 ++---
 libavcodec/ppc/mpegvideo_altivec.c     |   4 +-
 libavcodec/ratecontrol.c               |  24 ++---
 libavcodec/ratecontrol.h               |  16 ++--
 libavcodec/rv10.c                      |  16 ++--
 libavcodec/rv10.h                      |   7 +-
 libavcodec/rv10enc.c                   |   4 +-
 libavcodec/rv20enc.c                   |   5 +-
 libavcodec/rv30.c                      |   4 +-
 libavcodec/rv34.c                      |  38 ++++----
 libavcodec/rv34.h                      |   2 +-
 libavcodec/rv40.c                      |   6 +-
 libavcodec/snow.h                      |   4 +-
 libavcodec/snow_dwt.c                  |  16 ++--
 libavcodec/snow_dwt.h                  |   9 +-
 libavcodec/speedhqenc.c                |  12 +--
 libavcodec/speedhqenc.h                |  12 +--
 libavcodec/svq1enc.c                   |   3 +-
 libavcodec/svq1enc.h                   |   6 +-
 libavcodec/vaapi_mpeg2.c               |  10 +--
 libavcodec/vaapi_mpeg4.c               |   6 +-
 libavcodec/vaapi_vc1.c                 |  10 +--
 libavcodec/vc1.h                       |   2 +-
 libavcodec/vc1_block.c                 |  44 ++++-----
 libavcodec/vc1_loopfilter.c            |  28 +++---
 libavcodec/vc1_mc.c                    |  14 +--
 libavcodec/vc1_pred.c                  |   8 +-
 libavcodec/vc1dec.c                    |  13 ++-
 libavcodec/vdpau.c                     |   2 +-
 libavcodec/vdpau_mpeg12.c              |   4 +-
 libavcodec/vdpau_mpeg4.c               |   2 +-
 libavcodec/vdpau_vc1.c                 |   4 +-
 libavcodec/videotoolbox.c              |   2 +-
 libavcodec/wmv2.c                      |   4 +-
 libavcodec/wmv2.h                      |  19 ++--
 libavcodec/wmv2dec.c                   |  24 ++---
 libavcodec/wmv2enc.c                   |   8 +-
 libavcodec/x86/me_cmp.asm              |  16 ++--
 libavcodec/x86/me_cmp_init.c           |  72 +++++++--------
 libavcodec/x86/mpegvideo.c             |  14 +--
 libavcodec/x86/mpegvideoenc.c          |   8 +-
 libavcodec/x86/mpegvideoenc_template.c |   2 +-
 libavcodec/xvmc_internal.h             |   6 +-
 110 files changed, 999 insertions(+), 953 deletions(-)

diff --git a/libavcodec/alpha/mpegvideo_alpha.c b/libavcodec/alpha/mpegvideo_alpha.c
index 126fe264a1..ee553ae2fb 100644
--- a/libavcodec/alpha/mpegvideo_alpha.c
+++ b/libavcodec/alpha/mpegvideo_alpha.c
@@ -69,7 +69,7 @@ static void dct_unquantize_h263_axp(int16_t *block, int n_coeffs,
     }
 }
 
-static void dct_unquantize_h263_intra_axp(MpegEncContext *s, int16_t *block,
+static void dct_unquantize_h263_intra_axp(MPVContext *s, int16_t *block,
                                     int n, int qscale)
 {
     int n_coeffs;
@@ -96,14 +96,14 @@ static void dct_unquantize_h263_intra_axp(MpegEncContext *s, int16_t *block,
     block[0] = block0;
 }
 
-static void dct_unquantize_h263_inter_axp(MpegEncContext *s, int16_t *block,
+static void dct_unquantize_h263_inter_axp(MPVContext *s, int16_t *block,
                                     int n, int qscale)
 {
     int n_coeffs = s->inter_scantable.raster_end[s->block_last_index[n]];
     dct_unquantize_h263_axp(block, n_coeffs, qscale, (qscale - 1) | 1);
 }
 
-av_cold void ff_mpv_common_init_axp(MpegEncContext *s)
+av_cold void ff_mpv_common_init_axp(MPVMainContext *s)
 {
     s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_axp;
     s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_axp;
diff --git a/libavcodec/arm/asm-offsets.h b/libavcodec/arm/asm-offsets.h
index a2174b0a08..65a3f819cc 100644
--- a/libavcodec/arm/asm-offsets.h
+++ b/libavcodec/arm/asm-offsets.h
@@ -21,7 +21,7 @@
 #ifndef AVCODEC_ARM_ASM_OFFSETS_H
 #define AVCODEC_ARM_ASM_OFFSETS_H
 
-/* MpegEncContext */
+/* MPVContext */
 #define Y_DC_SCALE               0x04
 #define C_DC_SCALE               0x08
 #define AC_PRED                  0x0c
diff --git a/libavcodec/arm/me_cmp_init_arm.c b/libavcodec/arm/me_cmp_init_arm.c
index 03870a2bfa..981c247c75 100644
--- a/libavcodec/arm/me_cmp_init_arm.c
+++ b/libavcodec/arm/me_cmp_init_arm.c
@@ -23,19 +23,19 @@
 #include "libavutil/arm/cpu.h"
 #include "libavcodec/avcodec.h"
 #include "libavcodec/me_cmp.h"
-#include "libavcodec/mpegvideo.h"
+#include "libavcodec/mpegvideoenc.h"
 
-int ff_pix_abs16_armv6(MpegEncContext *s, uint8_t *blk1, uint8_t *blk2,
+int ff_pix_abs16_armv6(MPVEncContext *s, uint8_t *blk1, uint8_t *blk2,
                        ptrdiff_t stride, int h);
-int ff_pix_abs16_x2_armv6(MpegEncContext *s, uint8_t *blk1, uint8_t *blk2,
+int ff_pix_abs16_x2_armv6(MPVEncContext *s, uint8_t *blk1, uint8_t *blk2,
                           ptrdiff_t stride, int h);
-int ff_pix_abs16_y2_armv6(MpegEncContext *s, uint8_t *blk1, uint8_t *blk2,
+int ff_pix_abs16_y2_armv6(MPVEncContext *s, uint8_t *blk1, uint8_t *blk2,
                           ptrdiff_t stride, int h);
 
-int ff_pix_abs8_armv6(MpegEncContext *s, uint8_t *blk1, uint8_t *blk2,
+int ff_pix_abs8_armv6(MPVEncContext *s, uint8_t *blk1, uint8_t *blk2,
                       ptrdiff_t stride, int h);
 
-int ff_sse16_armv6(MpegEncContext *s, uint8_t *blk1, uint8_t *blk2,
+int ff_sse16_armv6(MPVEncContext *s, uint8_t *blk1, uint8_t *blk2,
                    ptrdiff_t stride, int h);
 
 av_cold void ff_me_cmp_init_arm(MECmpContext *c, AVCodecContext *avctx)
diff --git a/libavcodec/arm/mpegvideo_arm.c b/libavcodec/arm/mpegvideo_arm.c
index 008ef18eea..daea438bb1 100644
--- a/libavcodec/arm/mpegvideo_arm.c
+++ b/libavcodec/arm/mpegvideo_arm.c
@@ -27,21 +27,21 @@
 #include "asm-offsets.h"
 
 #if HAVE_NEON
-AV_CHECK_OFFSET(MpegEncContext, y_dc_scale,       Y_DC_SCALE);
-AV_CHECK_OFFSET(MpegEncContext, c_dc_scale,       C_DC_SCALE);
-AV_CHECK_OFFSET(MpegEncContext, ac_pred,          AC_PRED);
-AV_CHECK_OFFSET(MpegEncContext, block_last_index, BLOCK_LAST_INDEX);
-AV_CHECK_OFFSET(MpegEncContext, inter_scantable.raster_end,
+AV_CHECK_OFFSET(MPVContext, y_dc_scale,       Y_DC_SCALE);
+AV_CHECK_OFFSET(MPVContext, c_dc_scale,       C_DC_SCALE);
+AV_CHECK_OFFSET(MPVContext, ac_pred,          AC_PRED);
+AV_CHECK_OFFSET(MPVContext, block_last_index, BLOCK_LAST_INDEX);
+AV_CHECK_OFFSET(MPVContext, inter_scantable.raster_end,
                 INTER_SCANTAB_RASTER_END);
-AV_CHECK_OFFSET(MpegEncContext, h263_aic,         H263_AIC);
+AV_CHECK_OFFSET(MPVContext, h263_aic,         H263_AIC);
 #endif
 
-void ff_dct_unquantize_h263_inter_neon(MpegEncContext *s, int16_t *block,
+void ff_dct_unquantize_h263_inter_neon(MPVContext *s, int16_t *block,
                                        int n, int qscale);
-void ff_dct_unquantize_h263_intra_neon(MpegEncContext *s, int16_t *block,
+void ff_dct_unquantize_h263_intra_neon(MPVContext *s, int16_t *block,
                                        int n, int qscale);
 
-av_cold void ff_mpv_common_init_arm(MpegEncContext *s)
+av_cold void ff_mpv_common_init_arm(MPVMainContext *s)
 {
     int cpu_flags = av_get_cpu_flags();
 
diff --git a/libavcodec/arm/mpegvideo_arm.h b/libavcodec/arm/mpegvideo_arm.h
index 709ae6b247..1ba4053e04 100644
--- a/libavcodec/arm/mpegvideo_arm.h
+++ b/libavcodec/arm/mpegvideo_arm.h
@@ -21,6 +21,6 @@
 
 #include "libavcodec/mpegvideo.h"
 
-void ff_mpv_common_init_armv5te(MpegEncContext *s);
+void ff_mpv_common_init_armv5te(MPVMainContext *s);
 
 #endif /* AVCODEC_ARM_MPEGVIDEO_ARM_H */
diff --git a/libavcodec/arm/mpegvideo_armv5te.c b/libavcodec/arm/mpegvideo_armv5te.c
index e20bb4c645..3b5185baee 100644
--- a/libavcodec/arm/mpegvideo_armv5te.c
+++ b/libavcodec/arm/mpegvideo_armv5te.c
@@ -50,7 +50,7 @@ static inline void dct_unquantize_h263_helper_c(int16_t *block, int qmul, int qa
 }
 #endif
 
-static void dct_unquantize_h263_intra_armv5te(MpegEncContext *s,
+static void dct_unquantize_h263_intra_armv5te(MPVContext *s,
                                   int16_t *block, int n, int qscale)
 {
     int level, qmul, qadd;
@@ -79,7 +79,7 @@ static void dct_unquantize_h263_intra_armv5te(MpegEncContext *s,
     block[0] = level;
 }
 
-static void dct_unquantize_h263_inter_armv5te(MpegEncContext *s,
+static void dct_unquantize_h263_inter_armv5te(MPVContext *s,
                                   int16_t *block, int n, int qscale)
 {
     int qmul, qadd;
@@ -95,7 +95,7 @@ static void dct_unquantize_h263_inter_armv5te(MpegEncContext *s,
     ff_dct_unquantize_h263_armv5te(block, qmul, qadd, nCoeffs + 1);
 }
 
-av_cold void ff_mpv_common_init_armv5te(MpegEncContext *s)
+av_cold void ff_mpv_common_init_armv5te(MPVMainContext *s)
 {
     s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_armv5te;
     s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_armv5te;
diff --git a/libavcodec/dnxhdenc.c b/libavcodec/dnxhdenc.c
index ac92474e56..74989276b9 100644
--- a/libavcodec/dnxhdenc.c
+++ b/libavcodec/dnxhdenc.c
@@ -115,7 +115,7 @@ void dnxhd_10bit_get_pixels_8x4_sym(int16_t *av_restrict block,
     memcpy(block + 4 * 8, pixels + 3 * line_size, 8 * sizeof(*block));
 }
 
-static int dnxhd_10bit_dct_quantize_444(MpegEncContext *ctx, int16_t *block,
+static int dnxhd_10bit_dct_quantize_444(MPVEncContext *ctx, int16_t *block,
                                         int n, int qscale, int *overflow)
 {
     int i, j, level, last_non_zero, start_i;
@@ -174,7 +174,7 @@ static int dnxhd_10bit_dct_quantize_444(MpegEncContext *ctx, int16_t *block,
     return last_non_zero;
 }
 
-static int dnxhd_10bit_dct_quantize(MpegEncContext *ctx, int16_t *block,
+static int dnxhd_10bit_dct_quantize(MPVEncContext *ctx, int16_t *block,
                                     int n, int qscale, int *overflow)
 {
     const uint8_t *scantable= ctx->intra_scantable.scantable;
diff --git a/libavcodec/dnxhdenc.h b/libavcodec/dnxhdenc.h
index 9e4c869bc4..ef52735ad6 100644
--- a/libavcodec/dnxhdenc.h
+++ b/libavcodec/dnxhdenc.h
@@ -30,8 +30,8 @@
 
 #include "libavutil/mem_internal.h"
 
-#include "mpegvideo.h"
 #include "dnxhddata.h"
+#include "mpegvideoenc.h"
 
 typedef struct RCCMPEntry {
     uint16_t mb;
@@ -46,7 +46,7 @@ typedef struct RCEntry {
 typedef struct DNXHDEncContext {
     AVClass *class;
     BlockDSPContext bdsp;
-    MpegEncContext m; ///< Used for quantization dsp functions
+    MPVMainEncContext m; ///< Used for quantization dsp functions
 
     int cid;
     int profile;
diff --git a/libavcodec/dxva2_mpeg2.c b/libavcodec/dxva2_mpeg2.c
index 8cc21bf199..76932d4d63 100644
--- a/libavcodec/dxva2_mpeg2.c
+++ b/libavcodec/dxva2_mpeg2.c
@@ -39,7 +39,7 @@ struct dxva2_picture_context {
 
 static void fill_picture_parameters(AVCodecContext *avctx,
                                     AVDXVAContext *ctx,
-                                    const struct MpegEncContext *s,
+                                    const struct MPVDecContext *s,
                                     DXVA_PictureParameters *pp)
 {
     const Picture *current_picture = s->current_picture_ptr;
@@ -105,7 +105,7 @@ static void fill_picture_parameters(AVCodecContext *avctx,
 
 static void fill_quantization_matrices(AVCodecContext *avctx,
                                        AVDXVAContext *ctx,
-                                       const struct MpegEncContext *s,
+                                       const struct MPVDecContext *s,
                                        DXVA_QmatrixData *qm)
 {
     int i;
@@ -121,7 +121,7 @@ static void fill_quantization_matrices(AVCodecContext *avctx,
 }
 
 static void fill_slice(AVCodecContext *avctx,
-                       const struct MpegEncContext *s,
+                       const struct MPVDecContext *s,
                        DXVA_SliceInfo *slice,
                        unsigned position,
                        const uint8_t *buffer, unsigned size)
@@ -151,7 +151,7 @@ static int commit_bitstream_and_slice_buffer(AVCodecContext *avctx,
                                              DECODER_BUFFER_DESC *bs,
                                              DECODER_BUFFER_DESC *sc)
 {
-    const struct MpegEncContext *s = avctx->priv_data;
+    const struct MPVDecContext *const s = avctx->priv_data;
     AVDXVAContext *ctx = DXVA_CONTEXT(avctx);
     struct dxva2_picture_context *ctx_pic =
         s->current_picture_ptr->hwaccel_picture_private;
@@ -254,7 +254,7 @@ static int dxva2_mpeg2_start_frame(AVCodecContext *avctx,
                                    av_unused const uint8_t *buffer,
                                    av_unused uint32_t size)
 {
-    const struct MpegEncContext *s = avctx->priv_data;
+    const struct MPVDecContext *const s = avctx->priv_data;
     AVDXVAContext *ctx = DXVA_CONTEXT(avctx);
     struct dxva2_picture_context *ctx_pic =
         s->current_picture_ptr->hwaccel_picture_private;
@@ -275,7 +275,7 @@ static int dxva2_mpeg2_start_frame(AVCodecContext *avctx,
 static int dxva2_mpeg2_decode_slice(AVCodecContext *avctx,
                                     const uint8_t *buffer, uint32_t size)
 {
-    const struct MpegEncContext *s = avctx->priv_data;
+    const struct MPVDecContext *const s = avctx->priv_data;
     struct dxva2_picture_context *ctx_pic =
         s->current_picture_ptr->hwaccel_picture_private;
     unsigned position;
@@ -297,7 +297,7 @@ static int dxva2_mpeg2_decode_slice(AVCodecContext *avctx,
 
 static int dxva2_mpeg2_end_frame(AVCodecContext *avctx)
 {
-    struct MpegEncContext *s = avctx->priv_data;
+    struct MPVDecContext *const s = avctx->priv_data;
     struct dxva2_picture_context *ctx_pic =
         s->current_picture_ptr->hwaccel_picture_private;
     int ret;
diff --git a/libavcodec/dxva2_vc1.c b/libavcodec/dxva2_vc1.c
index f08ac8b5a0..d3171a2443 100644
--- a/libavcodec/dxva2_vc1.c
+++ b/libavcodec/dxva2_vc1.c
@@ -40,7 +40,7 @@ static void fill_picture_parameters(AVCodecContext *avctx,
                                     AVDXVAContext *ctx, const VC1Context *v,
                                     DXVA_PictureParameters *pp)
 {
-    const MpegEncContext *s = &v->s;
+    const MPVDecContext *const s = &v->s;
     const Picture *current_picture = s->current_picture_ptr;
     int intcomp = 0;
 
@@ -163,7 +163,7 @@ static void fill_slice(AVCodecContext *avctx, DXVA_SliceInfo *slice,
                        unsigned position, unsigned size)
 {
     const VC1Context *v = avctx->priv_data;
-    const MpegEncContext *s = &v->s;
+    const MPVDecContext *const s = &v->s;
 
     memset(slice, 0, sizeof(*slice));
     slice->wHorizontalPosition = 0;
@@ -185,7 +185,7 @@ static int commit_bitstream_and_slice_buffer(AVCodecContext *avctx,
 {
     const VC1Context *v = avctx->priv_data;
     AVDXVAContext *ctx = DXVA_CONTEXT(avctx);
-    const MpegEncContext *s = &v->s;
+    const MPVDecContext *const s = &v->s;
     struct dxva2_picture_context *ctx_pic = s->current_picture_ptr->hwaccel_picture_private;
 
     static const uint8_t start_code[] = { 0, 0, 1, 0x0d };
diff --git a/libavcodec/flv.h b/libavcodec/flv.h
index 561cfe0baa..54b13faeb1 100644
--- a/libavcodec/flv.h
+++ b/libavcodec/flv.h
@@ -23,12 +23,13 @@
 
 #include "get_bits.h"
 #include "mpegvideo.h"
+#include "mpegvideoenc.h"
 #include "put_bits.h"
 
-void ff_flv_encode_picture_header(MpegEncContext *s, int picture_number);
+void ff_flv_encode_picture_header(MPVMainEncContext *s, int picture_number);
 void ff_flv2_encode_ac_esc(PutBitContext *pb, int slevel, int level, int run,
                            int last);
 
-int ff_flv_decode_picture_header(MpegEncContext *s);
+int ff_flv_decode_picture_header(MPVMainDecContext *s);
 
 #endif /* AVCODEC_FLV_H */
diff --git a/libavcodec/flvdec.c b/libavcodec/flvdec.c
index 108cf88e34..27bad20efb 100644
--- a/libavcodec/flvdec.c
+++ b/libavcodec/flvdec.c
@@ -26,7 +26,7 @@
 #include "mpegvideo.h"
 #include "mpegvideodata.h"
 
-int ff_flv_decode_picture_header(MpegEncContext *s)
+int ff_flv_decode_picture_header(MPVMainDecContext *s)
 {
     int format, width, height;
 
@@ -118,7 +118,7 @@ const AVCodec ff_flv_decoder = {
     .long_name      = NULL_IF_CONFIG_SMALL("FLV / Sorenson Spark / Sorenson H.263 (Flash Video)"),
     .type           = AVMEDIA_TYPE_VIDEO,
     .id             = AV_CODEC_ID_FLV1,
-    .priv_data_size = sizeof(MpegEncContext),
+    .priv_data_size = sizeof(MPVMainDecContext),
     .init           = ff_h263_decode_init,
     .close          = ff_h263_decode_end,
     .decode         = ff_h263_decode_frame,
diff --git a/libavcodec/flvenc.c b/libavcodec/flvenc.c
index 6824327734..1de9e4da55 100644
--- a/libavcodec/flvenc.c
+++ b/libavcodec/flvenc.c
@@ -24,7 +24,7 @@
 #include "mpegvideodata.h"
 #include "mpegvideoenc.h"
 
-void ff_flv_encode_picture_header(MpegEncContext *s, int picture_number)
+void ff_flv_encode_picture_header(MPVMainEncContext *s, int picture_number)
 {
     int format;
 
@@ -97,7 +97,7 @@ const AVCodec ff_flv_encoder = {
     .type           = AVMEDIA_TYPE_VIDEO,
     .id             = AV_CODEC_ID_FLV1,
     .priv_class     = &ff_mpv_enc_class,
-    .priv_data_size = sizeof(MpegEncContext),
+    .priv_data_size = sizeof(MPVMainEncContext),
     .init           = ff_mpv_encode_init,
     .encode2        = ff_mpv_encode_picture,
     .close          = ff_mpv_encode_end,
diff --git a/libavcodec/h261.c b/libavcodec/h261.c
index 7dfaee7dc4..a4ad742d76 100644
--- a/libavcodec/h261.c
+++ b/libavcodec/h261.c
@@ -58,7 +58,7 @@ static void h261_loop_filter(uint8_t *src, int stride)
     }
 }
 
-void ff_h261_loop_filter(MpegEncContext *s)
+void ff_h261_loop_filter(MPVContext *s)
 {
     H261Context *const h = s->private_ctx;
     const int linesize   = s->linesize;
diff --git a/libavcodec/h261.h b/libavcodec/h261.h
index ff1903e508..ba9b7a033e 100644
--- a/libavcodec/h261.h
+++ b/libavcodec/h261.h
@@ -29,6 +29,7 @@
 #define AVCODEC_H261_H
 
 #include "mpegvideo.h"
+#include "mpegvideoenc.h"
 #include "rl.h"
 
 /**
@@ -49,13 +50,13 @@ extern const uint8_t ff_h261_mv_tab[17][2];
 extern const uint8_t ff_h261_cbp_tab[63][2];
 extern RLTable ff_h261_rl_tcoeff;
 
-void ff_h261_loop_filter(MpegEncContext *s);
+void ff_h261_loop_filter(MPVContext *s);
 
 int ff_h261_get_picture_format(int width, int height);
-void ff_h261_reorder_mb_index(MpegEncContext *s);
-void ff_h261_encode_mb(MpegEncContext *s, int16_t block[6][64],
+void ff_h261_reorder_mb_index(MPVEncContext *s);
+void ff_h261_encode_mb(MPVEncContext *s, int16_t block[6][64],
                        int motion_x, int motion_y);
-void ff_h261_encode_picture_header(MpegEncContext *s, int picture_number);
-void ff_h261_encode_init(MpegEncContext *s);
+void ff_h261_encode_picture_header(MPVMainEncContext *s, int picture_number);
+void ff_h261_encode_init(MPVMainEncContext *s);
 
 #endif /* AVCODEC_H261_H */
diff --git a/libavcodec/h261dec.c b/libavcodec/h261dec.c
index 17f1067b15..b95a9f6a80 100644
--- a/libavcodec/h261dec.c
+++ b/libavcodec/h261dec.c
@@ -48,7 +48,7 @@ static VLC h261_mv_vlc;
 static VLC h261_cbp_vlc;
 
 typedef struct H261DecContext {
-    MpegEncContext s;
+    MPVMainDecContext s;
 
     H261Context common;
 
@@ -81,7 +81,7 @@ static av_cold int h261_decode_init(AVCodecContext *avctx)
 {
     static AVOnce init_static_once = AV_ONCE_INIT;
     H261DecContext *const h = avctx->priv_data;
-    MpegEncContext *const s = &h->s;
+    MPVMainDecContext *const s = &h->s;
 
     s->private_ctx = &h->common;
     // set defaults
@@ -106,7 +106,7 @@ static av_cold int h261_decode_init(AVCodecContext *avctx)
 static int h261_decode_gob_header(H261DecContext *h)
 {
     unsigned int val;
-    MpegEncContext *const s = &h->s;
+    MPVDecContext *const s = &h->s;
 
     if (!h->gob_start_code_skipped) {
         /* Check for GOB Start Code */
@@ -159,7 +159,7 @@ static int h261_decode_gob_header(H261DecContext *h)
  */
 static int h261_resync(H261DecContext *h)
 {
-    MpegEncContext *const s = &h->s;
+    MPVDecContext *const s = &h->s;
     int left, ret;
 
     if (h->gob_start_code_skipped) {
@@ -200,7 +200,7 @@ static int h261_resync(H261DecContext *h)
  */
 static int h261_decode_mb_skipped(H261DecContext *h, int mba1, int mba2)
 {
-    MpegEncContext *const s = &h->s;
+    MPVDecContext *const s = &h->s;
     int i;
 
     s->mb_intra = 0;
@@ -270,7 +270,7 @@ static int decode_mv_component(GetBitContext *gb, int v)
  */
 static int h261_decode_block(H261DecContext *h, int16_t *block, int n, int coded)
 {
-    MpegEncContext *const s = &h->s;
+    MPVDecContext *const s = &h->s;
     int level, i, j, run;
     RLTable *rl = &ff_h261_rl_tcoeff;
     const uint8_t *scan_table;
@@ -362,7 +362,7 @@ static int h261_decode_block(H261DecContext *h, int16_t *block, int n, int coded
 
 static int h261_decode_mb(H261DecContext *h)
 {
-    MpegEncContext *const s = &h->s;
+    MPVDecContext *const s = &h->s;
     H261Context *const com = &h->common;
     int i, cbp, xy;
 
@@ -487,7 +487,7 @@ intra:
  */
 static int h261_decode_picture_header(H261DecContext *h)
 {
-    MpegEncContext *const s = &h->s;
+    MPVDecContext *const s = &h->s;
     int format, i;
     uint32_t startcode = 0;
 
@@ -551,7 +551,7 @@ static int h261_decode_picture_header(H261DecContext *h)
 
 static int h261_decode_gob(H261DecContext *h)
 {
-    MpegEncContext *const s = &h->s;
+    MPVDecContext *const s = &h->s;
 
     ff_set_qscale(s, s->qscale);
 
@@ -581,7 +581,7 @@ static int h261_decode_gob(H261DecContext *h)
 /**
  * returns the number of bytes consumed for building the current frame
  */
-static int get_consumed_bytes(MpegEncContext *s, int buf_size)
+static int get_consumed_bytes(MPVDecContext *s, int buf_size)
 {
     int pos = get_bits_count(&s->gb) >> 3;
     if (pos == 0)
@@ -596,9 +596,10 @@ static int h261_decode_frame(AVCodecContext *avctx, void *data,
                              int *got_frame, AVPacket *avpkt)
 {
     H261DecContext *const h = avctx->priv_data;
+    MPVMainDecContext *const s2 = &h->s;
+    MPVDecContext *const s = s2;
     const uint8_t *buf = avpkt->data;
     int buf_size       = avpkt->size;
-    MpegEncContext *s  = &h->s;
     int ret;
     AVFrame *pict = data;
 
@@ -619,11 +620,11 @@ retry:
     }
 
     if (s->width != avctx->coded_width || s->height != avctx->coded_height) {
-        ff_mpv_common_end(s);
+        ff_mpv_common_end(s2);
     }
 
     if (!s->context_initialized) {
-        if ((ret = ff_mpv_common_init(s)) < 0)
+        if ((ret = ff_mpv_common_init(s2)) < 0)
             return ret;
 
         ret = ff_set_dimensions(avctx, s->width, s->height);
@@ -673,7 +674,7 @@ retry:
 static av_cold int h261_decode_end(AVCodecContext *avctx)
 {
     H261DecContext *const h = avctx->priv_data;
-    MpegEncContext *s = &h->s;
+    MPVMainContext *const s = &h->s;
 
     ff_mpv_common_end(s);
     return 0;
diff --git a/libavcodec/h261enc.c b/libavcodec/h261enc.c
index 710d292df6..a2e4c55c93 100644
--- a/libavcodec/h261enc.c
+++ b/libavcodec/h261enc.c
@@ -39,7 +39,7 @@ static uint8_t uni_h261_rl_len [64*64*2*2];
 #define UNI_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level))
 
 typedef struct H261EncContext {
-    MpegEncContext s;
+    MPVMainEncContext s;
 
     H261Context common;
 
@@ -59,7 +59,7 @@ int ff_h261_get_picture_format(int width, int height)
         return AVERROR(EINVAL);
 }
 
-void ff_h261_encode_picture_header(MpegEncContext *s, int picture_number)
+void ff_h261_encode_picture_header(MPVMainEncContext *s, int picture_number)
 {
     H261EncContext *const h = (H261EncContext *)s;
     int format, temp_ref;
@@ -97,7 +97,7 @@ void ff_h261_encode_picture_header(MpegEncContext *s, int picture_number)
 /**
  * Encode a group of blocks header.
  */
-static void h261_encode_gob_header(MpegEncContext *s, int mb_line)
+static void h261_encode_gob_header(MPVEncContext *s, int mb_line)
 {
     H261EncContext *const h = (H261EncContext *)s;
     if (ff_h261_get_picture_format(s->width, s->height) == 0) {
@@ -114,7 +114,7 @@ static void h261_encode_gob_header(MpegEncContext *s, int mb_line)
     s->last_mv[0][0][1] = 0;
 }
 
-void ff_h261_reorder_mb_index(MpegEncContext *s)
+void ff_h261_reorder_mb_index(MPVEncContext *s)
 {
     int index = s->mb_x + s->mb_y * s->mb_width;
 
@@ -159,7 +159,7 @@ static void h261_encode_motion(PutBitContext *pb, int val)
     }
 }
 
-static inline int get_cbp(MpegEncContext *s, int16_t block[6][64])
+static inline int get_cbp(MPVEncContext *s, int16_t block[6][64])
 {
     int i, cbp;
     cbp = 0;
@@ -176,7 +176,7 @@ static inline int get_cbp(MpegEncContext *s, int16_t block[6][64])
  */
 static void h261_encode_block(H261EncContext *h, int16_t *block, int n)
 {
-    MpegEncContext *const s = &h->s;
+    MPVEncContext *const s = &h->s;
     int level, run, i, j, last_index, last_non_zero, sign, slevel, code;
     RLTable *rl;
 
@@ -242,7 +242,7 @@ static void h261_encode_block(H261EncContext *h, int16_t *block, int n)
         put_bits(&s->pb, rl->table_vlc[0][1], rl->table_vlc[0][0]); // EOB
 }
 
-void ff_h261_encode_mb(MpegEncContext *s, int16_t block[6][64],
+void ff_h261_encode_mb(MPVEncContext *s, int16_t block[6][64],
                        int motion_x, int motion_y)
 {
     /* The following is only allowed because this encoder
@@ -380,7 +380,7 @@ 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(MpegEncContext *s)
+av_cold void ff_h261_encode_init(MPVMainEncContext *s)
 {
     H261EncContext *const h = (H261EncContext*)s;
     static AVOnce init_static_once = AV_ONCE_INIT;
diff --git a/libavcodec/h263.c b/libavcodec/h263.c
index b30ffaf878..c60666172a 100644
--- a/libavcodec/h263.c
+++ b/libavcodec/h263.c
@@ -50,7 +50,8 @@ av_cold void ff_h263_init_rl_inter(void)
     ff_thread_once(&init_static_once, h263_init_rl_inter);
 }
 
-void ff_h263_update_motion_val(MpegEncContext * s){
+void ff_h263_update_motion_val(MPVContext *s)
+{
     const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
                //FIXME a lot of that is only needed for !low_delay
     const int wrap = s->b8_stride;
@@ -102,7 +103,8 @@ void ff_h263_update_motion_val(MpegEncContext * s){
     }
 }
 
-void ff_h263_loop_filter(MpegEncContext * s){
+void ff_h263_loop_filter(MPVContext *s)
+{
     int qp_c;
     const int linesize  = s->linesize;
     const int uvlinesize= s->uvlinesize;
@@ -187,7 +189,7 @@ void ff_h263_loop_filter(MpegEncContext * s){
     }
 }
 
-int16_t *ff_h263_pred_motion(MpegEncContext * s, int block, int dir,
+int16_t *ff_h263_pred_motion(MPVContext * s, int block, int dir,
                              int *px, int *py)
 {
     int wrap;
diff --git a/libavcodec/h263.h b/libavcodec/h263.h
index 5e4a5bc6e5..a3ad0625d5 100644
--- a/libavcodec/h263.h
+++ b/libavcodec/h263.h
@@ -28,11 +28,11 @@
 #define H263_GOB_HEIGHT(h) ((h) <= 400 ? 1 : (h) <= 800 ? 2 : 4)
 
 av_const int ff_h263_aspect_to_info(AVRational aspect);
-int16_t *ff_h263_pred_motion(MpegEncContext * s, int block, int dir,
+int16_t *ff_h263_pred_motion(MPVContext * s, int block, int dir,
                              int *px, int *py);
 void ff_h263_init_rl_inter(void);
-void ff_h263_update_motion_val(MpegEncContext * s);
-void ff_h263_loop_filter(MpegEncContext * s);
+void ff_h263_update_motion_val(MPVContext * s);
+void ff_h263_loop_filter(MPVContext * s);
 
 
 
diff --git a/libavcodec/h263dec.c b/libavcodec/h263dec.c
index 3466027286..56138eca04 100644
--- a/libavcodec/h263dec.c
+++ b/libavcodec/h263dec.c
@@ -55,7 +55,7 @@ static enum AVPixelFormat h263_get_format(AVCodecContext *avctx)
 {
     /* MPEG-4 Studio Profile only, not supported by hardware */
     if (avctx->bits_per_raw_sample > 8) {
-        av_assert1(((MpegEncContext *)avctx->priv_data)->studio_profile);
+        av_assert1(((MPVDecContext *)avctx->priv_data)->studio_profile);
         return avctx->pix_fmt;
     }
 
@@ -73,7 +73,7 @@ static enum AVPixelFormat h263_get_format(AVCodecContext *avctx)
 
 av_cold int ff_h263_decode_init(AVCodecContext *avctx)
 {
-    MpegEncContext *s = avctx->priv_data;
+    MPVMainDecContext *const s = avctx->priv_data;
     int ret;
 
     s->out_format      = FMT_H263;
@@ -156,7 +156,7 @@ av_cold int ff_h263_decode_init(AVCodecContext *avctx)
 
 av_cold int ff_h263_decode_end(AVCodecContext *avctx)
 {
-    MpegEncContext *s = avctx->priv_data;
+    MPVMainDecContext *const s = avctx->priv_data;
 
     ff_mpv_common_end(s);
     return 0;
@@ -165,7 +165,7 @@ av_cold int ff_h263_decode_end(AVCodecContext *avctx)
 /**
  * Return the number of bytes consumed for building the current frame.
  */
-static int get_consumed_bytes(MpegEncContext *s, int buf_size)
+static int get_consumed_bytes(MPVMainDecContext *s, int buf_size)
 {
     int pos = (get_bits_count(&s->gb) + 7) >> 3;
 
@@ -193,7 +193,7 @@ static int get_consumed_bytes(MpegEncContext *s, int buf_size)
     }
 }
 
-static int decode_slice(MpegEncContext *s)
+static int decode_slice(MPVMainDecContext *s)
 {
     const int part_mask = s->partitioned_frame
                           ? (ER_AC_END | ER_AC_ERROR) : 0x7F;
@@ -425,9 +425,9 @@ static int decode_slice(MpegEncContext *s)
 int ff_h263_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
                          AVPacket *avpkt)
 {
+    MPVMainDecContext *const s  = avctx->priv_data;
     const uint8_t *buf = avpkt->data;
     int buf_size       = avpkt->size;
-    MpegEncContext *s  = avctx->priv_data;
     int ret;
     int slice_ret = 0;
     AVFrame *pict = data;
@@ -763,7 +763,7 @@ const AVCodec ff_h263_decoder = {
     .long_name      = NULL_IF_CONFIG_SMALL("H.263 / H.263-1996, H.263+ / H.263-1998 / H.263 version 2"),
     .type           = AVMEDIA_TYPE_VIDEO,
     .id             = AV_CODEC_ID_H263,
-    .priv_data_size = sizeof(MpegEncContext),
+    .priv_data_size = sizeof(MPVMainDecContext),
     .init           = ff_h263_decode_init,
     .close          = ff_h263_decode_end,
     .decode         = ff_h263_decode_frame,
@@ -784,7 +784,7 @@ const AVCodec ff_h263p_decoder = {
     .long_name      = NULL_IF_CONFIG_SMALL("H.263 / H.263-1996, H.263+ / H.263-1998 / H.263 version 2"),
     .type           = AVMEDIA_TYPE_VIDEO,
     .id             = AV_CODEC_ID_H263P,
-    .priv_data_size = sizeof(MpegEncContext),
+    .priv_data_size = sizeof(MPVMainDecContext),
     .init           = ff_h263_decode_init,
     .close          = ff_h263_decode_end,
     .decode         = ff_h263_decode_frame,
diff --git a/libavcodec/h263dec.h b/libavcodec/h263dec.h
index 8d5f9a7add..5261844812 100644
--- a/libavcodec/h263dec.h
+++ b/libavcodec/h263dec.h
@@ -40,26 +40,25 @@ extern VLC ff_h263_mv_vlc;
 
 extern const enum AVPixelFormat ff_h263_hwaccel_pixfmt_list_420[];
 
-int ff_h263_decode_motion(MpegEncContext * s, int pred, int f_code);
+int ff_h263_decode_motion(MPVDecContext * s, int pred, int f_code);
 int ff_h263_decode_init(AVCodecContext *avctx);
 int ff_h263_decode_frame(AVCodecContext *avctx,
                              void *data, int *got_frame,
                              AVPacket *avpkt);
 int ff_h263_decode_end(AVCodecContext *avctx);
 void ff_h263_decode_init_vlc(void);
-int ff_h263_decode_picture_header(MpegEncContext *s);
-int ff_h263_decode_gob_header(MpegEncContext *s);
-int ff_h263_decode_mba(MpegEncContext *s);
+int ff_h263_decode_picture_header(MPVMainDecContext *s);
+int ff_h263_decode_mba(MPVDecContext *s);
 
 /**
  * Print picture info if FF_DEBUG_PICT_INFO is set.
  */
-void ff_h263_show_pict_info(MpegEncContext *s);
+void ff_h263_show_pict_info(MPVMainDecContext *s);
 
-int ff_intel_h263_decode_picture_header(MpegEncContext *s);
-int ff_h263_decode_mb(MpegEncContext *s,
+int ff_intel_h263_decode_picture_header(MPVMainDecContext *s);
+int ff_h263_decode_mb(MPVDecContext *s,
                       int16_t block[6][64]);
 
-int ff_h263_resync(MpegEncContext *s);
+int ff_h263_resync(MPVMainDecContext *s);
 
 #endif
diff --git a/libavcodec/h263enc.h b/libavcodec/h263enc.h
index fff85a18f2..180eb52be3 100644
--- a/libavcodec/h263enc.h
+++ b/libavcodec/h263enc.h
@@ -24,16 +24,16 @@
 #include "h263data.h"
 #include "mpegvideoenc.h"
 
-void ff_h263_encode_init(MpegEncContext *s);
-void ff_h263_encode_picture_header(MpegEncContext *s, int picture_number);
-void ff_h263_encode_gob_header(MpegEncContext * s, int mb_line);
-void ff_h263_encode_mb(MpegEncContext *s,
+void ff_h263_encode_init(MPVMainEncContext *s);
+void ff_h263_encode_picture_header(MPVMainEncContext *s, int picture_number);
+void ff_h263_encode_gob_header(MPVEncContext * s, int mb_line);
+void ff_h263_encode_mb(MPVEncContext *s,
                        int16_t block[6][64],
                        int motion_x, int motion_y);
-void ff_h263_encode_mba(MpegEncContext *s);
+void ff_h263_encode_mba(MPVEncContext *s);
 
-void ff_init_qscale_tab(MpegEncContext *s);
-void ff_clean_h263_qscales(MpegEncContext *s);
+void ff_init_qscale_tab(MPVMainEncContext *s);
+void ff_clean_h263_qscales(MPVMainEncContext *s);
 
 void ff_h263_encode_motion(PutBitContext *pb, int val, int f_code);
 
@@ -57,7 +57,7 @@ static inline int h263_get_motion_length(int val, int f_code)
     }
 }
 
-static inline void ff_h263_encode_motion_vector(MpegEncContext * s,
+static inline void ff_h263_encode_motion_vector(MPVEncContext * s,
                                                 int x, int y, int f_code)
 {
     if (s->avctx->flags2 & AV_CODEC_FLAG2_NO_OUTPUT) {
@@ -70,7 +70,7 @@ static inline void ff_h263_encode_motion_vector(MpegEncContext * s,
     }
 }
 
-static inline int get_p_cbp(MpegEncContext * s,
+static inline int get_p_cbp(MPVEncContext * s,
                       int16_t block[6][64],
                       int motion_x, int motion_y){
     int cbp;
diff --git a/libavcodec/intelh263dec.c b/libavcodec/intelh263dec.c
index b61effa4df..1f79f36f9f 100644
--- a/libavcodec/intelh263dec.c
+++ b/libavcodec/intelh263dec.c
@@ -26,7 +26,7 @@
 #include "mpegvideodata.h"
 
 /* don't understand why they choose a different header ! */
-int ff_intel_h263_decode_picture_header(MpegEncContext *s)
+int ff_intel_h263_decode_picture_header(MPVMainDecContext *s)
 {
     int format;
 
@@ -134,7 +134,7 @@ const AVCodec ff_h263i_decoder = {
     .long_name      = NULL_IF_CONFIG_SMALL("Intel H.263"),
     .type           = AVMEDIA_TYPE_VIDEO,
     .id             = AV_CODEC_ID_H263I,
-    .priv_data_size = sizeof(MpegEncContext),
+    .priv_data_size = sizeof(MPVMainDecContext),
     .init           = ff_h263_decode_init,
     .close          = ff_h263_decode_end,
     .decode         = ff_h263_decode_frame,
diff --git a/libavcodec/ituh263dec.c b/libavcodec/ituh263dec.c
index 7d7a1f01a2..ac19d52a37 100644
--- a/libavcodec/ituh263dec.c
+++ b/libavcodec/ituh263dec.c
@@ -74,7 +74,8 @@ static const int h263_mb_type_b_map[15]= {
     MB_TYPE_INTRA4x4                | MB_TYPE_CBP | MB_TYPE_QUANT,
 };
 
-void ff_h263_show_pict_info(MpegEncContext *s){
+void ff_h263_show_pict_info(MPVMainDecContext *s)
+{
     if(s->avctx->debug&FF_DEBUG_PICT_INFO){
     av_log(s->avctx, AV_LOG_DEBUG, "qp:%d %c size:%d rnd:%d%s%s%s%s%s%s%s%s%s %d/%d\n",
          s->qscale, av_get_picture_type_char(s->pict_type),
@@ -136,7 +137,7 @@ av_cold void ff_h263_decode_init_vlc(void)
     }
 }
 
-int ff_h263_decode_mba(MpegEncContext *s)
+int ff_h263_decode_mba(MPVDecContext *s)
 {
     int i, mb_pos;
 
@@ -154,7 +155,7 @@ int ff_h263_decode_mba(MpegEncContext *s)
  * Decode the group of blocks header or slice header.
  * @return <0 if an error occurred
  */
-static int h263_decode_gob_header(MpegEncContext *s)
+static int h263_decode_gob_header(MPVMainDecContext *s)
 {
     unsigned int val, gob_number;
     int left;
@@ -210,7 +211,8 @@ static int h263_decode_gob_header(MpegEncContext *s)
  * Decode the group of blocks / video packet header / slice header (MPEG-4 Studio).
  * @return bit position of the resync_marker, or <0 if none was found
  */
-int ff_h263_resync(MpegEncContext *s){
+int ff_h263_resync(MPVMainDecContext *s)
+{
     int left, pos, ret;
 
     /* In MPEG-4 studio mode look for a new slice startcode
@@ -267,7 +269,7 @@ int ff_h263_resync(MpegEncContext *s){
     return -1;
 }
 
-int ff_h263_decode_motion(MpegEncContext * s, int pred, int f_code)
+int ff_h263_decode_motion(MPVDecContext *s, int pred, int f_code)
 {
     int code, val, sign, shift;
     code = get_vlc2(&s->gb, ff_h263_mv_vlc.table, H263_MV_VLC_BITS, 2);
@@ -305,7 +307,7 @@ int ff_h263_decode_motion(MpegEncContext * s, int pred, int f_code)
 
 
 /* Decode RVLC of H.263+ UMV */
-static int h263p_decode_umotion(MpegEncContext * s, int pred)
+static int h263p_decode_umotion(MPVDecContext *s, int pred)
 {
    int code = 0, sign;
 
@@ -335,7 +337,8 @@ static int h263p_decode_umotion(MpegEncContext * s, int pred)
 /**
  * read the next MVs for OBMC. yes this is an ugly hack, feel free to send a patch :)
  */
-static void preview_obmc(MpegEncContext *s){
+static void preview_obmc(MPVDecContext *s)
+{
     GetBitContext gb= s->gb;
 
     int cbpc, i, pred_x, pred_y, mx, my;
@@ -427,7 +430,8 @@ end:
     s->gb= gb;
 }
 
-static void h263_decode_dquant(MpegEncContext *s){
+static void h263_decode_dquant(MPVDecContext *s)
+{
     static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
 
     if(s->modified_quant){
@@ -440,7 +444,7 @@ static void h263_decode_dquant(MpegEncContext *s){
     ff_set_qscale(s, s->qscale);
 }
 
-static void h263_pred_acdc(MpegEncContext * s, int16_t *block, int n)
+static void h263_pred_acdc(MPVDecContext *s, int16_t *block, int n)
 {
     int x, y, wrap, a, c, pred_dc, scale;
     int16_t *dc_val, *ac_val, *ac_val1;
@@ -527,7 +531,7 @@ static void h263_pred_acdc(MpegEncContext * s, int16_t *block, int n)
         ac_val1[8 + i] = block[s->idsp.idct_permutation[i]];
 }
 
-static int h263_decode_block(MpegEncContext * s, int16_t * block,
+static int h263_decode_block(MPVDecContext *s, int16_t * block,
                              int n, int coded)
 {
     int level, i, j, run;
@@ -674,7 +678,7 @@ not_coded:
     return 0;
 }
 
-static int h263_skip_b_part(MpegEncContext *s, int cbp)
+static int h263_skip_b_part(MPVDecContext *s, int cbp)
 {
     LOCAL_ALIGNED_32(int16_t, dblock, [64]);
     int i, mbi;
@@ -716,7 +720,7 @@ static int h263_get_modb(GetBitContext *gb, int pb_frame, int *cbpb)
 
 #define tab_size ((signed)FF_ARRAY_ELEMS(s->direct_scale_mv[0]))
 #define tab_bias (tab_size / 2)
-static inline void set_one_direct_mv(MpegEncContext *s, Picture *p, int i)
+static inline void set_one_direct_mv(MPVDecContext *s, Picture *p, int i)
 {
     int xy           = s->block_index[i];
     uint16_t time_pp = s->pp_time;
@@ -744,7 +748,7 @@ static inline void set_one_direct_mv(MpegEncContext *s, Picture *p, int i)
 /**
  * @return the mb_type
  */
-static int set_direct_mv(MpegEncContext *s)
+static int set_direct_mv(MPVDecContext *s)
 {
     const int mb_index = s->mb_x + s->mb_y * s->mb_stride;
     Picture *p = &s->next_picture;
@@ -781,7 +785,7 @@ static int set_direct_mv(MpegEncContext *s)
     }
 }
 
-int ff_h263_decode_mb(MpegEncContext *s,
+int ff_h263_decode_mb(MPVDecContext *s,
                       int16_t block[6][64])
 {
     int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
@@ -1083,7 +1087,7 @@ end:
 }
 
 /* Most is hardcoded; should extend to handle all H.263 streams. */
-int ff_h263_decode_picture_header(MpegEncContext *s)
+int ff_h263_decode_picture_header(MPVMainDecContext *s)
 {
     int format, width, height, i, ret;
     uint32_t startcode;
diff --git a/libavcodec/ituh263enc.c b/libavcodec/ituh263enc.c
index ef7caf8009..97f3ad95f2 100644
--- a/libavcodec/ituh263enc.c
+++ b/libavcodec/ituh263enc.c
@@ -102,7 +102,7 @@ av_const int ff_h263_aspect_to_info(AVRational aspect){
     return FF_ASPECT_EXTENDED;
 }
 
-void ff_h263_encode_picture_header(MpegEncContext * s, int picture_number)
+void ff_h263_encode_picture_header(MPVMainEncContext * s, int picture_number)
 {
     int format, coded_frame_rate, coded_frame_rate_base, i, temp_ref;
     int best_clock_code=1;
@@ -240,7 +240,7 @@ void ff_h263_encode_picture_header(MpegEncContext * s, int picture_number)
 /**
  * Encode a group of blocks header.
  */
-void ff_h263_encode_gob_header(MpegEncContext * s, int mb_line)
+void ff_h263_encode_gob_header(MPVEncContext *s, int mb_line)
 {
     put_bits(&s->pb, 17, 1); /* GBSC */
 
@@ -266,7 +266,8 @@ void ff_h263_encode_gob_header(MpegEncContext * 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(MpegEncContext *s){
+void ff_clean_h263_qscales(MPVMainEncContext *s)
+{
     int i;
     int8_t * const qscale_table = s->current_picture.qscale_table;
 
@@ -299,7 +300,7 @@ static const int dquant_code[5]= {1,0,9,2,3};
  * @param block the 8x8 block
  * @param n block index (0-3 are luma, 4-5 are chroma)
  */
-static void h263_encode_block(MpegEncContext * s, int16_t * block, int n)
+static void h263_encode_block(MPVEncContext *s, int16_t * block, int n)
 {
     int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
     RLTable *rl;
@@ -447,7 +448,7 @@ static void h263p_encode_umotion(PutBitContext *pb, int val)
     }
 }
 
-static int h263_pred_dc(MpegEncContext * s, int n, int16_t **dc_val_ptr)
+static int h263_pred_dc(MPVEncContext *s, int n, int16_t **dc_val_ptr)
 {
     int x, y, wrap, a, c, pred_dc;
     int16_t *dc_val;
@@ -488,7 +489,7 @@ static int h263_pred_dc(MpegEncContext * s, int n, int16_t **dc_val_ptr)
     return pred_dc;
 }
 
-void ff_h263_encode_mb(MpegEncContext * s,
+void ff_h263_encode_mb(MPVEncContext *s,
                        int16_t block[6][64],
                        int motion_x, int motion_y)
 {
@@ -811,7 +812,7 @@ static av_cold void h263_encode_init_static(void)
     init_mv_penalty_and_fcode();
 }
 
-av_cold void ff_h263_encode_init(MpegEncContext *s)
+av_cold void ff_h263_encode_init(MPVMainEncContext *s)
 {
     static AVOnce init_static_once = AV_ONCE_INIT;
 
@@ -866,7 +867,7 @@ av_cold void ff_h263_encode_init(MpegEncContext *s)
     ff_thread_once(&init_static_once, h263_encode_init_static);
 }
 
-void ff_h263_encode_mba(MpegEncContext *s)
+void ff_h263_encode_mba(MPVEncContext *s)
 {
     int i, mb_pos;
 
@@ -877,7 +878,7 @@ void ff_h263_encode_mba(MpegEncContext *s)
     put_bits(&s->pb, ff_mba_length[i], mb_pos);
 }
 
-#define OFFSET(x) offsetof(MpegEncContext, x)
+#define OFFSET(x) offsetof(MPVMainEncContext, 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 },
@@ -907,7 +908,7 @@ const AVCodec ff_h263_encoder = {
     .pix_fmts= (const enum AVPixelFormat[]){AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE},
     .priv_class     = &h263_class,
     .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
-    .priv_data_size = sizeof(MpegEncContext),
+    .priv_data_size = sizeof(MPVMainEncContext),
     .init           = ff_mpv_encode_init,
     .encode2        = ff_mpv_encode_picture,
     .close          = ff_mpv_encode_end,
@@ -943,7 +944,7 @@ const AVCodec ff_h263p_encoder = {
     .priv_class     = &h263p_class,
     .capabilities   = AV_CODEC_CAP_SLICE_THREADS,
     .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
-    .priv_data_size = sizeof(MpegEncContext),
+    .priv_data_size = sizeof(MPVMainEncContext),
     .init           = ff_mpv_encode_init,
     .encode2        = ff_mpv_encode_picture,
     .close          = ff_mpv_encode_end,
diff --git a/libavcodec/me_cmp.c b/libavcodec/me_cmp.c
index 60545248b3..8fa8c258ee 100644
--- a/libavcodec/me_cmp.c
+++ b/libavcodec/me_cmp.c
@@ -27,7 +27,7 @@
 #include "copy_block.h"
 #include "simple_idct.h"
 #include "me_cmp.h"
-#include "mpegvideo.h"
+#include "mpegvideoenc.h"
 #include "config.h"
 
 /* (i - 256) * (i - 256) */
@@ -66,7 +66,7 @@ const uint32_t ff_square_tab[512] = {
     57600, 58081, 58564, 59049, 59536, 60025, 60516, 61009, 61504, 62001, 62500, 63001, 63504, 64009, 64516, 65025,
 };
 
-static int sse4_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
+static int sse4_c(MPVEncContext *v, uint8_t *pix1, uint8_t *pix2,
                   ptrdiff_t stride, int h)
 {
     int s = 0, i;
@@ -83,7 +83,7 @@ static int sse4_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
     return s;
 }
 
-static int sse8_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
+static int sse8_c(MPVEncContext *v, uint8_t *pix1, uint8_t *pix2,
                   ptrdiff_t stride, int h)
 {
     int s = 0, i;
@@ -104,7 +104,7 @@ static int sse8_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
     return s;
 }
 
-static int sse16_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
+static int sse16_c(MPVEncContext *v, uint8_t *pix1, uint8_t *pix2,
                    ptrdiff_t stride, int h)
 {
     int s = 0, i;
@@ -146,7 +146,7 @@ static int sum_abs_dctelem_c(int16_t *block)
 #define avg2(a, b) (((a) + (b) + 1) >> 1)
 #define avg4(a, b, c, d) (((a) + (b) + (c) + (d) + 2) >> 2)
 
-static inline int pix_abs16_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
+static inline int pix_abs16_c(MPVEncContext *v, uint8_t *pix1, uint8_t *pix2,
                               ptrdiff_t stride, int h)
 {
     int s = 0, i;
@@ -174,7 +174,7 @@ static inline int pix_abs16_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
     return s;
 }
 
-static inline int pix_median_abs16_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
+static inline int pix_median_abs16_c(MPVEncContext *v, uint8_t *pix1, uint8_t *pix2,
                              ptrdiff_t stride, int h)
 {
     int s = 0, i, j;
@@ -213,7 +213,7 @@ static inline int pix_median_abs16_c(MpegEncContext *v, uint8_t *pix1, uint8_t *
     return s;
 }
 
-static int pix_abs16_x2_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
+static int pix_abs16_x2_c(MPVEncContext *v, uint8_t *pix1, uint8_t *pix2,
                           ptrdiff_t stride, int h)
 {
     int s = 0, i;
@@ -241,7 +241,7 @@ static int pix_abs16_x2_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
     return s;
 }
 
-static int pix_abs16_y2_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
+static int pix_abs16_y2_c(MPVEncContext *v, uint8_t *pix1, uint8_t *pix2,
                           ptrdiff_t stride, int h)
 {
     int s = 0, i;
@@ -271,7 +271,7 @@ static int pix_abs16_y2_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
     return s;
 }
 
-static int pix_abs16_xy2_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
+static int pix_abs16_xy2_c(MPVEncContext *v, uint8_t *pix1, uint8_t *pix2,
                            ptrdiff_t stride, int h)
 {
     int s = 0, i;
@@ -301,7 +301,7 @@ static int pix_abs16_xy2_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
     return s;
 }
 
-static inline int pix_abs8_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
+static inline int pix_abs8_c(MPVEncContext *v, uint8_t *pix1, uint8_t *pix2,
                              ptrdiff_t stride, int h)
 {
     int s = 0, i;
@@ -321,7 +321,7 @@ static inline int pix_abs8_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
     return s;
 }
 
-static inline int pix_median_abs8_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
+static inline int pix_median_abs8_c(MPVEncContext *v, uint8_t *pix1, uint8_t *pix2,
                              ptrdiff_t stride, int h)
 {
     int s = 0, i, j;
@@ -352,7 +352,7 @@ static inline int pix_median_abs8_c(MpegEncContext *v, uint8_t *pix1, uint8_t *p
     return s;
 }
 
-static int pix_abs8_x2_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
+static int pix_abs8_x2_c(MPVEncContext *v, uint8_t *pix1, uint8_t *pix2,
                          ptrdiff_t stride, int h)
 {
     int s = 0, i;
@@ -372,7 +372,7 @@ static int pix_abs8_x2_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
     return s;
 }
 
-static int pix_abs8_y2_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
+static int pix_abs8_y2_c(MPVEncContext *v, uint8_t *pix1, uint8_t *pix2,
                          ptrdiff_t stride, int h)
 {
     int s = 0, i;
@@ -394,7 +394,7 @@ static int pix_abs8_y2_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
     return s;
 }
 
-static int pix_abs8_xy2_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
+static int pix_abs8_xy2_c(MPVEncContext *v, uint8_t *pix1, uint8_t *pix2,
                           ptrdiff_t stride, int h)
 {
     int s = 0, i;
@@ -416,7 +416,7 @@ static int pix_abs8_xy2_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
     return s;
 }
 
-static int nsse16_c(MpegEncContext *c, uint8_t *s1, uint8_t *s2,
+static int nsse16_c(MPVEncContext *c, uint8_t *s1, uint8_t *s2,
                     ptrdiff_t stride, int h)
 {
     int score1 = 0, score2 = 0, x, y;
@@ -441,7 +441,7 @@ static int nsse16_c(MpegEncContext *c, uint8_t *s1, uint8_t *s2,
         return score1 + FFABS(score2) * 8;
 }
 
-static int nsse8_c(MpegEncContext *c, uint8_t *s1, uint8_t *s2,
+static int nsse8_c(MPVEncContext *c, uint8_t *s1, uint8_t *s2,
                    ptrdiff_t stride, int h)
 {
     int score1 = 0, score2 = 0, x, y;
@@ -466,7 +466,7 @@ static int nsse8_c(MpegEncContext *c, uint8_t *s1, uint8_t *s2,
         return score1 + FFABS(score2) * 8;
 }
 
-static int zero_cmp(MpegEncContext *s, uint8_t *a, uint8_t *b,
+static int zero_cmp(MPVEncContext *s, uint8_t *a, uint8_t *b,
                     ptrdiff_t stride, int h)
 {
     return 0;
@@ -552,7 +552,7 @@ void ff_set_cmp(MECmpContext *c, me_cmp_func *cmp, int type)
 
 #define BUTTERFLYA(x, y) (FFABS((x) + (y)) + FFABS((x) - (y)))
 
-static int hadamard8_diff8x8_c(MpegEncContext *s, uint8_t *dst,
+static int hadamard8_diff8x8_c(MPVEncContext *s, uint8_t *dst,
                                uint8_t *src, ptrdiff_t stride, int h)
 {
     int i, temp[64], sum = 0;
@@ -604,7 +604,7 @@ static int hadamard8_diff8x8_c(MpegEncContext *s, uint8_t *dst,
     return sum;
 }
 
-static int hadamard8_intra8x8_c(MpegEncContext *s, uint8_t *src,
+static int hadamard8_intra8x8_c(MPVEncContext *s, uint8_t *src,
                                 uint8_t *dummy, ptrdiff_t stride, int h)
 {
     int i, temp[64], sum = 0;
@@ -656,7 +656,7 @@ static int hadamard8_intra8x8_c(MpegEncContext *s, uint8_t *src,
     return sum;
 }
 
-static int dct_sad8x8_c(MpegEncContext *s, uint8_t *src1,
+static int dct_sad8x8_c(MPVEncContext *s, uint8_t *src1,
                         uint8_t *src2, ptrdiff_t stride, int h)
 {
     LOCAL_ALIGNED_16(int16_t, temp, [64]);
@@ -697,7 +697,7 @@ static int dct_sad8x8_c(MpegEncContext *s, uint8_t *src1,
         DST(7, (a4 >> 2) - a7);                         \
     }
 
-static int dct264_sad8x8_c(MpegEncContext *s, uint8_t *src1,
+static int dct264_sad8x8_c(MPVEncContext *s, uint8_t *src1,
                            uint8_t *src2, ptrdiff_t stride, int h)
 {
     int16_t dct[8][8];
@@ -722,7 +722,7 @@ static int dct264_sad8x8_c(MpegEncContext *s, uint8_t *src1,
 }
 #endif
 
-static int dct_max8x8_c(MpegEncContext *s, uint8_t *src1,
+static int dct_max8x8_c(MPVEncContext *s, uint8_t *src1,
                         uint8_t *src2, ptrdiff_t stride, int h)
 {
     LOCAL_ALIGNED_16(int16_t, temp, [64]);
@@ -739,7 +739,7 @@ static int dct_max8x8_c(MpegEncContext *s, uint8_t *src1,
     return sum;
 }
 
-static int quant_psnr8x8_c(MpegEncContext *s, uint8_t *src1,
+static int quant_psnr8x8_c(MPVEncContext *s, uint8_t *src1,
                            uint8_t *src2, ptrdiff_t stride, int h)
 {
     LOCAL_ALIGNED_16(int16_t, temp, [64 * 2]);
@@ -764,7 +764,7 @@ static int quant_psnr8x8_c(MpegEncContext *s, uint8_t *src1,
     return sum;
 }
 
-static int rd8x8_c(MpegEncContext *s, uint8_t *src1, uint8_t *src2,
+static int rd8x8_c(MPVEncContext *s, uint8_t *src1, uint8_t *src2,
                    ptrdiff_t stride, int h)
 {
     const uint8_t *scantable = s->intra_scantable.permutated;
@@ -841,7 +841,7 @@ static int rd8x8_c(MpegEncContext *s, uint8_t *src1, uint8_t *src2,
     return distortion + ((bits * s->qscale * s->qscale * 109 + 64) >> 7);
 }
 
-static int bit8x8_c(MpegEncContext *s, uint8_t *src1, uint8_t *src2,
+static int bit8x8_c(MPVEncContext *s, uint8_t *src1, uint8_t *src2,
                     ptrdiff_t stride, int h)
 {
     const uint8_t *scantable = s->intra_scantable.permutated;
@@ -903,7 +903,7 @@ static int bit8x8_c(MpegEncContext *s, uint8_t *src1, uint8_t *src2,
 }
 
 #define VSAD_INTRA(size)                                                \
-static int vsad_intra ## size ## _c(MpegEncContext *c,                  \
+static int vsad_intra ## size ## _c(MPVEncContext *c,                   \
                                     uint8_t *s, uint8_t *dummy,         \
                                     ptrdiff_t stride, int h)            \
 {                                                                       \
@@ -925,7 +925,7 @@ VSAD_INTRA(8)
 VSAD_INTRA(16)
 
 #define VSAD(size)                                                             \
-static int vsad ## size ## _c(MpegEncContext *c,                               \
+static int vsad ## size ## _c(MPVEncContext *c,                                \
                               uint8_t *s1, uint8_t *s2,                        \
                               ptrdiff_t stride, int h)                               \
 {                                                                              \
@@ -945,7 +945,7 @@ VSAD(16)
 
 #define SQ(a) ((a) * (a))
 #define VSSE_INTRA(size)                                                \
-static int vsse_intra ## size ## _c(MpegEncContext *c,                  \
+static int vsse_intra ## size ## _c(MPVEncContext *c,                   \
                                     uint8_t *s, uint8_t *dummy,         \
                                     ptrdiff_t stride, int h)            \
 {                                                                       \
@@ -967,7 +967,7 @@ VSSE_INTRA(8)
 VSSE_INTRA(16)
 
 #define VSSE(size)                                                             \
-static int vsse ## size ## _c(MpegEncContext *c, uint8_t *s1, uint8_t *s2,     \
+static int vsse ## size ## _c(MPVEncContext *c, uint8_t *s1, uint8_t *s2,      \
                               ptrdiff_t stride, int h)                         \
 {                                                                              \
     int score = 0, x, y;                                                       \
@@ -985,7 +985,7 @@ VSSE(8)
 VSSE(16)
 
 #define WRAPPER8_16_SQ(name8, name16)                                   \
-static int name16(MpegEncContext *s, uint8_t *dst, uint8_t *src,        \
+static int name16(MPVEncContext *s, uint8_t *dst, uint8_t *src,         \
                   ptrdiff_t stride, int h)                              \
 {                                                                       \
     int score = 0;                                                      \
diff --git a/libavcodec/me_cmp.h b/libavcodec/me_cmp.h
index e9b5161c9a..ca9a617a6a 100644
--- a/libavcodec/me_cmp.h
+++ b/libavcodec/me_cmp.h
@@ -39,13 +39,14 @@ extern const uint32_t ff_square_tab[512];
  * !future video codecs might need functions with less strict alignment
  */
 
-struct MpegEncContext;
+#define MPVEncContext MPVContext
+struct MPVEncContext;
 /* Motion estimation:
  * h is limited to { width / 2, width, 2 * width },
  * but never larger than 16 and never smaller than 2.
  * Although currently h < 4 is not used as functions with
  * width < 8 are neither used nor implemented. */
-typedef int (*me_cmp_func)(struct MpegEncContext *c,
+typedef int (*me_cmp_func)(struct MPVEncContext *c,
                            uint8_t *blk1 /* align width (8 or 16) */,
                            uint8_t *blk2 /* align 1 */, ptrdiff_t stride,
                            int h);
@@ -89,5 +90,6 @@ void ff_me_cmp_init_mips(MECmpContext *c, AVCodecContext *avctx);
 void ff_set_cmp(MECmpContext *c, me_cmp_func *cmp, int type);
 
 void ff_dsputil_init_dwt(MECmpContext *c);
+#undef MPVEncContext
 
 #endif /* AVCODEC_ME_CMP_H */
diff --git a/libavcodec/mips/h263dsp_mips.h b/libavcodec/mips/h263dsp_mips.h
index 99a43cd44a..852856db55 100644
--- a/libavcodec/mips/h263dsp_mips.h
+++ b/libavcodec/mips/h263dsp_mips.h
@@ -25,11 +25,11 @@
 
 void ff_h263_h_loop_filter_msa(uint8_t *src, int stride, int q_scale);
 void ff_h263_v_loop_filter_msa(uint8_t *src, int stride, int q_scale);
-void ff_dct_unquantize_mpeg2_inter_msa(MpegEncContext *s, int16_t *block,
+void ff_dct_unquantize_mpeg2_inter_msa(MPVContext *s, int16_t *block,
                                        int32_t index, int32_t q_scale);
-void ff_dct_unquantize_h263_inter_msa(MpegEncContext *s, int16_t *block,
+void ff_dct_unquantize_h263_inter_msa(MPVContext *s, int16_t *block,
                                       int32_t index, int32_t q_scale);
-void ff_dct_unquantize_h263_intra_msa(MpegEncContext *s, int16_t *block,
+void ff_dct_unquantize_h263_intra_msa(MPVContext *s, int16_t *block,
                                       int32_t index, int32_t q_scale);
 int ff_pix_sum_msa(uint8_t *pix, int line_size);
 
diff --git a/libavcodec/mips/me_cmp_mips.h b/libavcodec/mips/me_cmp_mips.h
index e0d0f51af8..71187f7a5c 100644
--- a/libavcodec/mips/me_cmp_mips.h
+++ b/libavcodec/mips/me_cmp_mips.h
@@ -21,38 +21,38 @@
 #ifndef AVCODEC_MIPS_ME_CMP_MIPS_H
 #define AVCODEC_MIPS_ME_CMP_MIPS_H
 
-#include "../mpegvideo.h"
+#include "libavcodec/mpegvideoenc.h"
 #include "libavcodec/bit_depth_template.c"
 
-int ff_hadamard8_diff8x8_msa(MpegEncContext *s, uint8_t *dst, uint8_t *src,
+int ff_hadamard8_diff8x8_msa(MPVEncContext *s, uint8_t *dst, uint8_t *src,
                              ptrdiff_t stride, int h);
-int ff_hadamard8_intra8x8_msa(MpegEncContext *s, uint8_t *dst, uint8_t *src,
+int ff_hadamard8_intra8x8_msa(MPVEncContext *s, uint8_t *dst, uint8_t *src,
                               ptrdiff_t stride, int h);
-int ff_hadamard8_diff16_msa(MpegEncContext *s, uint8_t *dst, uint8_t *src,
+int ff_hadamard8_diff16_msa(MPVEncContext *s, uint8_t *dst, uint8_t *src,
                             ptrdiff_t stride, int h);
-int ff_hadamard8_intra16_msa(MpegEncContext *s, uint8_t *dst, uint8_t *src,
+int ff_hadamard8_intra16_msa(MPVEncContext *s, uint8_t *dst, uint8_t *src,
                              ptrdiff_t stride, int h);
-int ff_pix_abs16_msa(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
+int ff_pix_abs16_msa(MPVEncContext *v, uint8_t *pix1, uint8_t *pix2,
                      ptrdiff_t stride, int h);
-int ff_pix_abs16_x2_msa(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
+int ff_pix_abs16_x2_msa(MPVEncContext *v, uint8_t *pix1, uint8_t *pix2,
                         ptrdiff_t stride, int h);
-int ff_pix_abs16_y2_msa(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
+int ff_pix_abs16_y2_msa(MPVEncContext *v, uint8_t *pix1, uint8_t *pix2,
                         ptrdiff_t stride, int h);
-int ff_pix_abs16_xy2_msa(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
+int ff_pix_abs16_xy2_msa(MPVEncContext *v, uint8_t *pix1, uint8_t *pix2,
                          ptrdiff_t stride, int h);
-int ff_pix_abs8_msa(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
+int ff_pix_abs8_msa(MPVEncContext *v, uint8_t *pix1, uint8_t *pix2,
                     ptrdiff_t stride, int h);
-int ff_pix_abs8_x2_msa(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
+int ff_pix_abs8_x2_msa(MPVEncContext *v, uint8_t *pix1, uint8_t *pix2,
                        ptrdiff_t stride, int h);
-int ff_pix_abs8_y2_msa(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
+int ff_pix_abs8_y2_msa(MPVEncContext *v, uint8_t *pix1, uint8_t *pix2,
                        ptrdiff_t stride, int h);
-int ff_pix_abs8_xy2_msa(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
+int ff_pix_abs8_xy2_msa(MPVEncContext *v, uint8_t *pix1, uint8_t *pix2,
                         ptrdiff_t stride, int h);
-int ff_sse16_msa(MpegEncContext *v, uint8_t *pu8Src, uint8_t *pu8Ref,
+int ff_sse16_msa(MPVEncContext *v, uint8_t *pu8Src, uint8_t *pu8Ref,
                  ptrdiff_t stride, int i32Height);
-int ff_sse8_msa(MpegEncContext *v, uint8_t *pu8Src, uint8_t *pu8Ref,
+int ff_sse8_msa(MPVEncContext *v, uint8_t *pu8Src, uint8_t *pu8Ref,
                 ptrdiff_t stride, int i32Height);
-int ff_sse4_msa(MpegEncContext *v, uint8_t *pu8Src, uint8_t *pu8Ref,
+int ff_sse4_msa(MPVEncContext *v, uint8_t *pu8Src, uint8_t *pu8Ref,
                 ptrdiff_t stride, int i32Height);
 void ff_add_pixels8_msa(uint8_t *av_restrict pixels, int16_t *block,
                         ptrdiff_t stride);
diff --git a/libavcodec/mips/me_cmp_msa.c b/libavcodec/mips/me_cmp_msa.c
index 7cb7af0047..f71bb7e4aa 100644
--- a/libavcodec/mips/me_cmp_msa.c
+++ b/libavcodec/mips/me_cmp_msa.c
@@ -587,79 +587,79 @@ static int32_t hadamard_intra_8x8_msa(uint8_t *src, int32_t src_stride,
     return sum_res;
 }
 
-int ff_pix_abs16_msa(MpegEncContext *v, uint8_t *src, uint8_t *ref,
+int ff_pix_abs16_msa(MPVEncContext *v, uint8_t *src, uint8_t *ref,
                      ptrdiff_t stride, int height)
 {
     return sad_16width_msa(src, stride, ref, stride, height);
 }
 
-int ff_pix_abs8_msa(MpegEncContext *v, uint8_t *src, uint8_t *ref,
+int ff_pix_abs8_msa(MPVEncContext *v, uint8_t *src, uint8_t *ref,
                     ptrdiff_t stride, int height)
 {
     return sad_8width_msa(src, stride, ref, stride, height);
 }
 
-int ff_pix_abs16_x2_msa(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
+int ff_pix_abs16_x2_msa(MPVEncContext *v, uint8_t *pix1, uint8_t *pix2,
                         ptrdiff_t stride, int h)
 {
     return sad_horiz_bilinear_filter_16width_msa(pix1, stride, pix2, stride, h);
 }
 
-int ff_pix_abs16_y2_msa(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
+int ff_pix_abs16_y2_msa(MPVEncContext *v, uint8_t *pix1, uint8_t *pix2,
                         ptrdiff_t stride, int h)
 {
     return sad_vert_bilinear_filter_16width_msa(pix1, stride, pix2, stride, h);
 }
 
-int ff_pix_abs16_xy2_msa(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
+int ff_pix_abs16_xy2_msa(MPVEncContext *v, uint8_t *pix1, uint8_t *pix2,
                          ptrdiff_t stride, int h)
 {
     return sad_hv_bilinear_filter_16width_msa(pix1, stride, pix2, stride, h);
 }
 
-int ff_pix_abs8_x2_msa(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
+int ff_pix_abs8_x2_msa(MPVEncContext *v, uint8_t *pix1, uint8_t *pix2,
                        ptrdiff_t stride, int h)
 {
     return sad_horiz_bilinear_filter_8width_msa(pix1, stride, pix2, stride, h);
 }
 
-int ff_pix_abs8_y2_msa(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
+int ff_pix_abs8_y2_msa(MPVEncContext *v, uint8_t *pix1, uint8_t *pix2,
                        ptrdiff_t stride, int h)
 {
     return sad_vert_bilinear_filter_8width_msa(pix1, stride, pix2, stride, h);
 }
 
-int ff_pix_abs8_xy2_msa(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
+int ff_pix_abs8_xy2_msa(MPVEncContext *v, uint8_t *pix1, uint8_t *pix2,
                         ptrdiff_t stride, int h)
 {
     return sad_hv_bilinear_filter_8width_msa(pix1, stride, pix2, stride, h);
 }
 
-int ff_sse16_msa(MpegEncContext *v, uint8_t *src, uint8_t *ref,
+int ff_sse16_msa(MPVEncContext *v, uint8_t *src, uint8_t *ref,
                  ptrdiff_t stride, int height)
 {
     return sse_16width_msa(src, stride, ref, stride, height);
 }
 
-int ff_sse8_msa(MpegEncContext *v, uint8_t *src, uint8_t *ref,
+int ff_sse8_msa(MPVEncContext *v, uint8_t *src, uint8_t *ref,
                 ptrdiff_t stride, int height)
 {
     return sse_8width_msa(src, stride, ref, stride, height);
 }
 
-int ff_sse4_msa(MpegEncContext *v, uint8_t *src, uint8_t *ref,
+int ff_sse4_msa(MPVEncContext *v, uint8_t *src, uint8_t *ref,
                 ptrdiff_t stride, int height)
 {
     return sse_4width_msa(src, stride, ref, stride, height);
 }
 
-int ff_hadamard8_diff8x8_msa(MpegEncContext *s, uint8_t *dst, uint8_t *src,
+int ff_hadamard8_diff8x8_msa(MPVEncContext *s, uint8_t *dst, uint8_t *src,
                              ptrdiff_t stride, int h)
 {
     return hadamard_diff_8x8_msa(src, stride, dst, stride);
 }
 
-int ff_hadamard8_intra8x8_msa(MpegEncContext *s, uint8_t *dst, uint8_t *src,
+int ff_hadamard8_intra8x8_msa(MPVEncContext *s, uint8_t *dst, uint8_t *src,
                               ptrdiff_t stride, int h)
 {
     return hadamard_intra_8x8_msa(src, stride, dst, stride);
@@ -667,7 +667,7 @@ int ff_hadamard8_intra8x8_msa(MpegEncContext *s, uint8_t *dst, uint8_t *src,
 
 /* Hadamard Transform functions */
 #define WRAPPER8_16_SQ(name8, name16)                      \
-int name16(MpegEncContext *s, uint8_t *dst, uint8_t *src,  \
+int name16(MPVEncContext *s, uint8_t *dst, uint8_t *src,   \
            ptrdiff_t stride, int h)                        \
 {                                                          \
     int score = 0;                                         \
diff --git a/libavcodec/mips/mpegvideo_init_mips.c b/libavcodec/mips/mpegvideo_init_mips.c
index f687ad18f1..1c1008d2e5 100644
--- a/libavcodec/mips/mpegvideo_init_mips.c
+++ b/libavcodec/mips/mpegvideo_init_mips.c
@@ -23,7 +23,7 @@
 #include "h263dsp_mips.h"
 #include "mpegvideo_mips.h"
 
-av_cold void ff_mpv_common_init_mips(MpegEncContext *s)
+av_cold void ff_mpv_common_init_mips(MPVMainContext *s)
 {
     int cpu_flags = av_get_cpu_flags();
 
diff --git a/libavcodec/mips/mpegvideo_mips.h b/libavcodec/mips/mpegvideo_mips.h
index 760d7b3295..88d675eee6 100644
--- a/libavcodec/mips/mpegvideo_mips.h
+++ b/libavcodec/mips/mpegvideo_mips.h
@@ -23,16 +23,16 @@
 
 #include "libavcodec/mpegvideo.h"
 
-void ff_dct_unquantize_h263_intra_mmi(MpegEncContext *s, int16_t *block,
+void ff_dct_unquantize_h263_intra_mmi(MPVContext *s, int16_t *block,
         int n, int qscale);
-void ff_dct_unquantize_h263_inter_mmi(MpegEncContext *s, int16_t *block,
+void ff_dct_unquantize_h263_inter_mmi(MPVContext *s, int16_t *block,
         int n, int qscale);
-void ff_dct_unquantize_mpeg1_intra_mmi(MpegEncContext *s, int16_t *block,
+void ff_dct_unquantize_mpeg1_intra_mmi(MPVContext *s, int16_t *block,
         int n, int qscale);
-void ff_dct_unquantize_mpeg1_inter_mmi(MpegEncContext *s, int16_t *block,
+void ff_dct_unquantize_mpeg1_inter_mmi(MPVContext *s, int16_t *block,
         int n, int qscale);
-void ff_dct_unquantize_mpeg2_intra_mmi(MpegEncContext *s, int16_t *block,
+void ff_dct_unquantize_mpeg2_intra_mmi(MPVContext *s, int16_t *block,
         int n, int qscale);
-void ff_denoise_dct_mmi(MpegEncContext *s, int16_t *block);
+void ff_denoise_dct_mmi(MPVContext *s, int16_t *block);
 
 #endif /* AVCODEC_MIPS_MPEGVIDEO_MIPS_H */
diff --git a/libavcodec/mips/mpegvideo_mmi.c b/libavcodec/mips/mpegvideo_mmi.c
index 3d5b5e20ab..e8ff72c946 100644
--- a/libavcodec/mips/mpegvideo_mmi.c
+++ b/libavcodec/mips/mpegvideo_mmi.c
@@ -25,7 +25,7 @@
 #include "mpegvideo_mips.h"
 #include "libavutil/mips/mmiutils.h"
 
-void ff_dct_unquantize_h263_intra_mmi(MpegEncContext *s, int16_t *block,
+void ff_dct_unquantize_h263_intra_mmi(MPVContext *s, int16_t *block,
         int n, int qscale)
 {
     int64_t level, nCoeffs;
@@ -101,7 +101,7 @@ void ff_dct_unquantize_h263_intra_mmi(MpegEncContext *s, int16_t *block,
     block[0] = level;
 }
 
-void ff_dct_unquantize_h263_inter_mmi(MpegEncContext *s, int16_t *block,
+void ff_dct_unquantize_h263_inter_mmi(MPVContext *s, int16_t *block,
         int n, int qscale)
 {
     int64_t nCoeffs;
@@ -160,7 +160,7 @@ void ff_dct_unquantize_h263_inter_mmi(MpegEncContext *s, int16_t *block,
     );
 }
 
-void ff_dct_unquantize_mpeg1_intra_mmi(MpegEncContext *s, int16_t *block,
+void ff_dct_unquantize_mpeg1_intra_mmi(MPVContext *s, int16_t *block,
         int n, int qscale)
 {
     int64_t nCoeffs;
@@ -254,7 +254,7 @@ void ff_dct_unquantize_mpeg1_intra_mmi(MpegEncContext *s, int16_t *block,
     block[0] = block0;
 }
 
-void ff_dct_unquantize_mpeg1_inter_mmi(MpegEncContext *s, int16_t *block,
+void ff_dct_unquantize_mpeg1_inter_mmi(MPVContext *s, int16_t *block,
         int n, int qscale)
 {
     int64_t nCoeffs;
@@ -342,7 +342,7 @@ void ff_dct_unquantize_mpeg1_inter_mmi(MpegEncContext *s, int16_t *block,
     );
 }
 
-void ff_dct_unquantize_mpeg2_intra_mmi(MpegEncContext *s, int16_t *block,
+void ff_dct_unquantize_mpeg2_intra_mmi(MPVContext *s, int16_t *block,
         int n, int qscale)
 {
     uint64_t nCoeffs;
@@ -435,7 +435,7 @@ void ff_dct_unquantize_mpeg2_intra_mmi(MpegEncContext *s, int16_t *block,
     block[0]= block0;
 }
 
-void ff_denoise_dct_mmi(MpegEncContext *s, int16_t *block)
+void ff_denoise_dct_mmi(MPVContext *s, int16_t *block)
 {
     const int intra = s->mb_intra;
     int *sum = s->dct_error_sum[intra];
diff --git a/libavcodec/mips/mpegvideo_msa.c b/libavcodec/mips/mpegvideo_msa.c
index aa9ef770eb..26dc3df92c 100644
--- a/libavcodec/mips/mpegvideo_msa.c
+++ b/libavcodec/mips/mpegvideo_msa.c
@@ -193,7 +193,7 @@ static int32_t mpeg2_dct_unquantize_inter_msa(int16_t *block,
     return sum_res;
 }
 
-void ff_dct_unquantize_h263_intra_msa(MpegEncContext *s,
+void ff_dct_unquantize_h263_intra_msa(MPVContext *s,
                                       int16_t *block, int32_t index,
                                       int32_t qscale)
 {
@@ -218,7 +218,7 @@ void ff_dct_unquantize_h263_intra_msa(MpegEncContext *s,
     h263_dct_unquantize_msa(block, qmul, qadd, nCoeffs, 1);
 }
 
-void ff_dct_unquantize_h263_inter_msa(MpegEncContext *s,
+void ff_dct_unquantize_h263_inter_msa(MPVContext *s,
                                       int16_t *block, int32_t index,
                                       int32_t qscale)
 {
@@ -235,7 +235,7 @@ void ff_dct_unquantize_h263_inter_msa(MpegEncContext *s,
     h263_dct_unquantize_msa(block, qmul, qadd, nCoeffs, 0);
 }
 
-void ff_dct_unquantize_mpeg2_inter_msa(MpegEncContext *s,
+void ff_dct_unquantize_mpeg2_inter_msa(MPVContext *s,
                                        int16_t *block, int32_t index,
                                        int32_t qscale)
 {
diff --git a/libavcodec/mjpegenc.c b/libavcodec/mjpegenc.c
index b9b17a50df..481ee884e9 100644
--- a/libavcodec/mjpegenc.c
+++ b/libavcodec/mjpegenc.c
@@ -44,10 +44,10 @@
 
 /* The following is the private context of MJPEG/AMV decoder.
  * Note that when using slice threading only the main thread's
- * MpegEncContext is followed by a MjpegContext; the other threads
- * can access this shared context via MpegEncContext.mjpeg. */
+ * MPVMainEncContext is followed by a MjpegContext; the other threads
+ * can access this shared context via MPVEncContext.mjpeg. */
 typedef struct MJPEGEncContext {
-    MpegEncContext mpeg;
+    MPVMainEncContext mpeg;
     MJpegContext   mjpeg;
 } MJPEGEncContext;
 
@@ -75,7 +75,7 @@ static av_cold void init_uni_ac_vlc(const uint8_t huff_size_ac[256],
     }
 }
 
-static void mjpeg_encode_picture_header(MpegEncContext *s)
+static void mjpeg_encode_picture_header(MPVMainEncContext *s)
 {
     ff_mjpeg_encode_picture_header(s->avctx, &s->pb, s->mjpeg_ctx,
                                    &s->intra_scantable, 0,
@@ -87,7 +87,7 @@ static void mjpeg_encode_picture_header(MpegEncContext *s)
         s->thread_context[i]->esc_pos = 0;
 }
 
-void ff_mjpeg_amv_encode_picture_header(MpegEncContext *s)
+void ff_mjpeg_amv_encode_picture_header(MPVMainEncContext *s)
 {
     MJPEGEncContext *const m = (MJPEGEncContext*)s;
     av_assert2(s->mjpeg_ctx == &m->mjpeg);
@@ -100,9 +100,9 @@ void ff_mjpeg_amv_encode_picture_header(MpegEncContext *s)
 /**
  * Encodes and outputs the entire frame in the JPEG format.
  *
- * @param s The MpegEncContext.
+ * @param s The MPVEncContext.
  */
-static void mjpeg_encode_picture_frame(MpegEncContext *s)
+static void mjpeg_encode_picture_frame(MPVEncContext *s)
 {
     int nbits, code, table_id;
     MJpegContext *m = s->mjpeg_ctx;
@@ -211,10 +211,10 @@ static void mjpeg_build_optimal_huffman(MJpegContext *m)
  *
  * Header + values + stuffing.
  *
- * @param s The MpegEncContext.
+ * @param s The MPVEncContext.
  * @return int Error code, 0 if successful.
  */
-int ff_mjpeg_encode_stuffing(MpegEncContext *s)
+int ff_mjpeg_encode_stuffing(MPVEncContext *s)
 {
     MJpegContext *const m = s->mjpeg_ctx;
     PutBitContext *pbc = &s->pb;
@@ -260,7 +260,7 @@ fail:
     return ret;
 }
 
-static int alloc_huffman(MpegEncContext *s)
+static int alloc_huffman(MPVMainEncContext *s)
 {
     MJpegContext *m = s->mjpeg_ctx;
     size_t num_mbs, num_blocks, num_codes;
@@ -288,7 +288,7 @@ static int alloc_huffman(MpegEncContext *s)
     return 0;
 }
 
-av_cold int ff_mjpeg_encode_init(MpegEncContext *s)
+av_cold int ff_mjpeg_encode_init(MPVMainEncContext *s)
 {
     MJpegContext *const m = &((MJPEGEncContext*)s)->mjpeg;
     int ret, use_slices;
@@ -412,11 +412,11 @@ static void ff_mjpeg_encode_coef(MJpegContext *s, uint8_t table_id, int val, int
 /**
  * Add the block's data into the JPEG buffer.
  *
- * @param s The MpegEncContext that contains the JPEG buffer.
+ * @param s The MPVEncContext that contains the JPEG buffer.
  * @param block The block.
  * @param n The block's index or number.
  */
-static void record_block(MpegEncContext *s, int16_t *block, int n)
+static void record_block(MPVEncContext *s, int16_t *block, int n)
 {
     int i, j, table_id;
     int component, dc, last_index, val, run;
@@ -459,7 +459,7 @@ static void record_block(MpegEncContext *s, int16_t *block, int n)
         ff_mjpeg_encode_code(m, table_id, 0);
 }
 
-static void encode_block(MpegEncContext *s, int16_t *block, int n)
+static void encode_block(MPVEncContext *s, int16_t *block, int n)
 {
     int mant, nbits, code, i, j;
     int component, dc, run, last_index, val;
@@ -517,7 +517,7 @@ static void encode_block(MpegEncContext *s, int16_t *block, int n)
         put_bits(&s->pb, huff_size_ac[0], huff_code_ac[0]);
 }
 
-void ff_mjpeg_encode_mb(MpegEncContext *s, int16_t block[12][64])
+void ff_mjpeg_encode_mb(MPVEncContext *s, int16_t block[12][64])
 {
     int i;
     if (s->mjpeg_ctx->huffman == HUFFMAN_TABLE_OPTIMAL) {
@@ -589,7 +589,7 @@ void ff_mjpeg_encode_mb(MpegEncContext *s, int16_t block[12][64])
 static int amv_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
                               const AVFrame *pic_arg, int *got_packet)
 {
-    MpegEncContext *s = avctx->priv_data;
+    MPVMainEncContext *const s = avctx->priv_data;
     AVFrame *pic;
     int i, ret;
     int chroma_h_shift, chroma_v_shift;
diff --git a/libavcodec/mjpegenc.h b/libavcodec/mjpegenc.h
index a593b67e96..609b663e09 100644
--- a/libavcodec/mjpegenc.h
+++ b/libavcodec/mjpegenc.h
@@ -36,7 +36,7 @@
 #include <stdint.h>
 
 #include "mjpeg.h"
-#include "mpegvideo.h"
+#include "mpegvideoenc.h"
 #include "put_bits.h"
 
 /**
@@ -71,9 +71,9 @@ typedef struct MJpegContext {
     uint8_t huff_size_ac_chrominance[256];  ///< AC chrominance Huffman table size.
     uint16_t huff_code_ac_chrominance[256]; ///< AC chrominance Huffman table codes.
 
-    /** Storage for AC luminance VLC (in MpegEncContext) */
+    /** Storage for AC luminance VLC (in MPVEncContext) */
     uint8_t uni_ac_vlc_len[64 * 64 * 2];
-    /** Storage for AC chrominance VLC (in MpegEncContext) */
+    /** Storage for AC chrominance VLC (in MPVEncContext) */
     uint8_t uni_chroma_ac_vlc_len[64 * 64 * 2];
 
     // Default DC tables have exactly 12 values
@@ -107,9 +107,9 @@ static inline void put_marker(PutBitContext *p, enum JpegMarker code)
     put_bits(p, 8, code);
 }
 
-int  ff_mjpeg_encode_init(MpegEncContext *s);
-void ff_mjpeg_amv_encode_picture_header(MpegEncContext *s);
-void ff_mjpeg_encode_mb(MpegEncContext *s, int16_t block[12][64]);
-int  ff_mjpeg_encode_stuffing(MpegEncContext *s);
+int  ff_mjpeg_encode_init(MPVMainEncContext *s);
+void ff_mjpeg_amv_encode_picture_header(MPVMainEncContext *s);
+void ff_mjpeg_encode_mb(MPVEncContext *s, int16_t block[12][64]);
+int  ff_mjpeg_encode_stuffing(MPVEncContext *s);
 
 #endif /* AVCODEC_MJPEGENC_H */
diff --git a/libavcodec/motion_est.c b/libavcodec/motion_est.c
index 35ca40b90a..34ea72fe3d 100644
--- a/libavcodec/motion_est.c
+++ b/libavcodec/motion_est.c
@@ -47,7 +47,7 @@
 #define ME_MAP_SHIFT 3
 #define ME_MAP_MV_BITS 11
 
-static int sad_hpel_motion_search(MpegEncContext * s,
+static int sad_hpel_motion_search(MPVEncContext * s,
                                   int *mx_ptr, int *my_ptr, int dmin,
                                   int src_index, int ref_index,
                                   int size, int h);
@@ -104,7 +104,7 @@ static int get_flags(MotionEstContext *c, int direct, int chroma){
            + (chroma ? FLAG_CHROMA : 0);
 }
 
-static av_always_inline int cmp_direct_inline(MpegEncContext *s, const int x, const int y, const int subx, const int suby,
+static av_always_inline int cmp_direct_inline(MPVEncContext *s, const int x, const int y, const int subx, const int suby,
                       const int size, const int h, int ref_index, int src_index,
                       me_cmp_func cmp_func, me_cmp_func chroma_cmp_func, int qpel){
     MotionEstContext * const c= &s->me;
@@ -176,7 +176,7 @@ static av_always_inline int cmp_direct_inline(MpegEncContext *s, const int x, co
     return d;
 }
 
-static av_always_inline int cmp_inline(MpegEncContext *s, const int x, const int y, const int subx, const int suby,
+static av_always_inline int cmp_inline(MPVEncContext *s, const int x, const int y, const int subx, const int suby,
                       const int size, const int h, int ref_index, int src_index,
                       me_cmp_func cmp_func, me_cmp_func chroma_cmp_func, int qpel, int chroma){
     MotionEstContext * const c= &s->me;
@@ -228,13 +228,13 @@ static av_always_inline int cmp_inline(MpegEncContext *s, const int x, const int
     return d;
 }
 
-static int cmp_simple(MpegEncContext *s, const int x, const int y,
+static int cmp_simple(MPVEncContext *s, const int x, const int y,
                       int ref_index, int src_index,
                       me_cmp_func cmp_func, me_cmp_func chroma_cmp_func){
     return cmp_inline(s,x,y,0,0,0,16,ref_index,src_index, cmp_func, chroma_cmp_func, 0, 0);
 }
 
-static int cmp_fpel_internal(MpegEncContext *s, const int x, const int y,
+static int cmp_fpel_internal(MPVEncContext *s, const int x, const int y,
                       const int size, const int h, int ref_index, int src_index,
                       me_cmp_func cmp_func, me_cmp_func chroma_cmp_func, const int flags){
     if(flags&FLAG_DIRECT){
@@ -244,7 +244,7 @@ static int cmp_fpel_internal(MpegEncContext *s, const int x, const int y,
     }
 }
 
-static int cmp_internal(MpegEncContext *s, const int x, const int y, const int subx, const int suby,
+static int cmp_internal(MPVEncContext *s, const int x, const int y, const int subx, const int suby,
                       const int size, const int h, int ref_index, int src_index,
                       me_cmp_func cmp_func, me_cmp_func chroma_cmp_func, const int flags){
     if(flags&FLAG_DIRECT){
@@ -257,7 +257,7 @@ static int cmp_internal(MpegEncContext *s, const int x, const int y, const int s
 /** @brief compares a block (either a full macroblock or a partition thereof)
     against a proposed motion-compensated prediction of that block
  */
-static av_always_inline int cmp(MpegEncContext *s, const int x, const int y, const int subx, const int suby,
+static av_always_inline int cmp(MPVEncContext *s, const int x, const int y, const int subx, const int suby,
                       const int size, const int h, int ref_index, int src_index,
                       me_cmp_func cmp_func, me_cmp_func chroma_cmp_func, const int flags){
     if(av_builtin_constant_p(flags) && av_builtin_constant_p(h) && av_builtin_constant_p(size)
@@ -272,7 +272,7 @@ static av_always_inline int cmp(MpegEncContext *s, const int x, const int y, con
     }
 }
 
-static int cmp_hpel(MpegEncContext *s, const int x, const int y, const int subx, const int suby,
+static int cmp_hpel(MPVEncContext *s, const int x, const int y, const int subx, const int suby,
                       const int size, const int h, int ref_index, int src_index,
                       me_cmp_func cmp_func, me_cmp_func chroma_cmp_func, const int flags){
     if(flags&FLAG_DIRECT){
@@ -282,7 +282,7 @@ static int cmp_hpel(MpegEncContext *s, const int x, const int y, const int subx,
     }
 }
 
-static int cmp_qpel(MpegEncContext *s, const int x, const int y, const int subx, const int suby,
+static int cmp_qpel(MPVEncContext *s, const int x, const int y, const int subx, const int suby,
                       const int size, const int h, int ref_index, int src_index,
                       me_cmp_func cmp_func, me_cmp_func chroma_cmp_func, const int flags){
     if(flags&FLAG_DIRECT){
@@ -294,7 +294,7 @@ static int cmp_qpel(MpegEncContext *s, const int x, const int y, const int subx,
 
 #include "motion_est_template.c"
 
-static int zero_cmp(MpegEncContext *s, uint8_t *a, uint8_t *b,
+static int zero_cmp(MPVEncContext *s, uint8_t *a, uint8_t *b,
                     ptrdiff_t stride, int h)
 {
     return 0;
@@ -303,7 +303,7 @@ static int zero_cmp(MpegEncContext *s, uint8_t *a, uint8_t *b,
 static void zero_hpel(uint8_t *a, const uint8_t *b, ptrdiff_t stride, int h){
 }
 
-int ff_init_me(MpegEncContext *s){
+int ff_init_me(MPVEncContext *s){
     MotionEstContext * const c= &s->me;
     int cache_size= FFMIN(ME_MAP_SIZE>>ME_MAP_SHIFT, 1<<ME_MAP_SHIFT);
     int dia_size= FFMAX(FFABS(s->avctx->dia_size)&255, FFABS(s->avctx->pre_dia_size)&255);
@@ -389,7 +389,7 @@ int ff_init_me(MpegEncContext *s){
     COPY3_IF_LT(dminh, d, dx, x, dy, y)\
 }
 
-static int sad_hpel_motion_search(MpegEncContext * s,
+static int sad_hpel_motion_search(MPVEncContext * s,
                                   int *mx_ptr, int *my_ptr, int dmin,
                                   int src_index, int ref_index,
                                   int size, int h)
@@ -494,7 +494,7 @@ static int sad_hpel_motion_search(MpegEncContext * s,
     return dminh;
 }
 
-static inline void set_p_mv_tables(MpegEncContext * s, int mx, int my, int mv4)
+static inline void set_p_mv_tables(MPVEncContext * s, int mx, int my, int mv4)
 {
     const int xy= s->mb_x + s->mb_y*s->mb_stride;
 
@@ -521,7 +521,7 @@ static inline void set_p_mv_tables(MpegEncContext * s, int mx, int my, int mv4)
 /**
  * get fullpel ME search limits.
  */
-static inline void get_limits(MpegEncContext *s, int x, int y)
+static inline void get_limits(MPVEncContext *s, int x, int y)
 {
     MotionEstContext * const c= &s->me;
     int range= c->avctx->me_range >> (1 + !!(c->flags&FLAG_QPEL));
@@ -568,7 +568,7 @@ static inline void init_mv4_ref(MotionEstContext *c){
     c->src[3][0] = c->src[2][0] + 8;
 }
 
-static inline int h263_mv4_search(MpegEncContext *s, int mx, int my, int shift)
+static inline int h263_mv4_search(MPVEncContext *s, int mx, int my, int shift)
 {
     MotionEstContext * const c= &s->me;
     const int size= 1;
@@ -722,7 +722,7 @@ static inline int h263_mv4_search(MpegEncContext *s, int mx, int my, int shift)
     }
 }
 
-static inline void init_interlaced_ref(MpegEncContext *s, int ref_index){
+static inline void init_interlaced_ref(MPVEncContext *s, int ref_index){
     MotionEstContext * const c= &s->me;
 
     c->ref[1+ref_index][0] = c->ref[0+ref_index][0] + s->linesize;
@@ -735,7 +735,7 @@ static inline void init_interlaced_ref(MpegEncContext *s, int ref_index){
     }
 }
 
-static int interlaced_search(MpegEncContext *s, int ref_index,
+static int interlaced_search(MPVEncContext *s, int ref_index,
                              int16_t (*mv_tables[2][2])[2], uint8_t *field_select_tables[2], int mx, int my, int user_field_select)
 {
     MotionEstContext * const c= &s->me;
@@ -882,7 +882,7 @@ static inline int get_penalty_factor(int lambda, int lambda2, int type){
     }
 }
 
-void ff_estimate_p_frame_motion(MpegEncContext * s,
+void ff_estimate_p_frame_motion(MPVEncContext * s,
                                 int mb_x, int mb_y)
 {
     MotionEstContext * const c= &s->me;
@@ -1058,7 +1058,7 @@ void ff_estimate_p_frame_motion(MpegEncContext * s,
     s->mb_type[mb_y*s->mb_stride + mb_x]= mb_type;
 }
 
-int ff_pre_estimate_p_frame_motion(MpegEncContext * s,
+int ff_pre_estimate_p_frame_motion(MPVEncContext * s,
                                     int mb_x, int mb_y)
 {
     MotionEstContext * const c= &s->me;
@@ -1111,7 +1111,7 @@ int ff_pre_estimate_p_frame_motion(MpegEncContext * s,
     return dmin;
 }
 
-static int estimate_motion_b(MpegEncContext *s, int mb_x, int mb_y,
+static int estimate_motion_b(MPVEncContext *s, int mb_x, int mb_y,
                              int16_t (*mv_table)[2], int ref_index, int f_code)
 {
     MotionEstContext * const c= &s->me;
@@ -1173,7 +1173,7 @@ static int estimate_motion_b(MpegEncContext *s, int mb_x, int mb_y,
     return dmin;
 }
 
-static inline int check_bidir_mv(MpegEncContext * s,
+static inline int check_bidir_mv(MPVEncContext * s,
                    int motion_fx, int motion_fy,
                    int motion_bx, int motion_by,
                    int pred_fx, int pred_fy,
@@ -1238,7 +1238,7 @@ static inline int check_bidir_mv(MpegEncContext * s,
 }
 
 /* refine the bidir vectors in hq mode and return the score in both lq & hq mode*/
-static inline int bidir_refine(MpegEncContext * s, int mb_x, int mb_y)
+static inline int bidir_refine(MPVEncContext * s, int mb_x, int mb_y)
 {
     MotionEstContext * const c= &s->me;
     const int mot_stride = s->mb_stride;
@@ -1385,7 +1385,7 @@ CHECK_BIDIR(-(a),-(b),-(c),-(d))
     return fbmin;
 }
 
-static inline int direct_search(MpegEncContext * s, int mb_x, int mb_y)
+static inline int direct_search(MPVEncContext * s, int mb_x, int mb_y)
 {
     MotionEstContext * const c= &s->me;
     int P[10][2];
@@ -1487,7 +1487,7 @@ static inline int direct_search(MpegEncContext * s, int mb_x, int mb_y)
     return dmin;
 }
 
-void ff_estimate_b_frame_motion(MpegEncContext * s,
+void ff_estimate_b_frame_motion(MPVEncContext * s,
                              int mb_x, int mb_y)
 {
     MotionEstContext * const c= &s->me;
@@ -1595,7 +1595,7 @@ void ff_estimate_b_frame_motion(MpegEncContext * s,
 }
 
 /* find best f_code for ME which do unlimited searches */
-int ff_get_best_fcode(MpegEncContext * s, int16_t (*mv_table)[2], int type)
+int ff_get_best_fcode(MPVEncContext * s, int16_t (*mv_table)[2], int type)
 {
     if (s->motion_est != FF_ME_ZERO) {
         int score[8];
@@ -1648,7 +1648,7 @@ int ff_get_best_fcode(MpegEncContext * s, int16_t (*mv_table)[2], int type)
     }
 }
 
-void ff_fix_long_p_mvs(MpegEncContext * s, int type)
+void ff_fix_long_p_mvs(MPVEncContext * s, int type)
 {
     MotionEstContext * const c= &s->me;
     const int f_code= s->f_code;
@@ -1697,7 +1697,7 @@ void ff_fix_long_p_mvs(MpegEncContext * s, int type)
 /**
  * @param truncate 1 for truncation, 0 for using intra
  */
-void ff_fix_long_mvs(MpegEncContext * s, uint8_t *field_select_table, int field_select,
+void ff_fix_long_mvs(MPVEncContext * s, uint8_t *field_select_table, int field_select,
                      int16_t (*mv_table)[2], int f_code, int type, int truncate)
 {
     MotionEstContext * const c= &s->me;
diff --git a/libavcodec/motion_est.h b/libavcodec/motion_est.h
index 5742e51486..b52b91ab3f 100644
--- a/libavcodec/motion_est.h
+++ b/libavcodec/motion_est.h
@@ -27,7 +27,8 @@
 #include "hpeldsp.h"
 #include "qpeldsp.h"
 
-struct MpegEncContext;
+#define MPVEncContext MPVContext
+struct MPVEncContext;
 
 #if ARCH_IA64 // Limit static arrays to avoid gcc failing "short data segment overflowed"
 #define MAX_MV 1024
@@ -92,7 +93,7 @@ typedef struct MotionEstContext {
     qpel_mc_func(*qpel_avg)[16];
     const uint8_t (*mv_penalty)[MAX_DMV * 2 + 1]; ///< bit amount needed to encode a MV
     const uint8_t *current_mv_penalty;
-    int (*sub_motion_search)(struct MpegEncContext *s,
+    int (*sub_motion_search)(struct MPVEncContext *s,
                              int *mx_ptr, int *my_ptr, int dmin,
                              int src_index, int ref_index,
                              int size, int h);
@@ -108,28 +109,28 @@ static inline int ff_h263_round_chroma(int x)
     return h263_chroma_roundtab[x & 0xf] + (x >> 3);
 }
 
-int ff_init_me(struct MpegEncContext *s);
+int ff_init_me(struct MPVEncContext *s);
 
-void ff_estimate_p_frame_motion(struct MpegEncContext *s, int mb_x, int mb_y);
-void ff_estimate_b_frame_motion(struct MpegEncContext *s, int mb_x, int mb_y);
+void ff_estimate_p_frame_motion(struct MPVEncContext *s, int mb_x, int mb_y);
+void ff_estimate_b_frame_motion(struct MPVEncContext *s, int mb_x, int mb_y);
 
-int ff_pre_estimate_p_frame_motion(struct MpegEncContext *s,
+int ff_pre_estimate_p_frame_motion(struct MPVEncContext *s,
                                    int mb_x, int mb_y);
 
-int ff_epzs_motion_search(struct MpegEncContext *s, int *mx_ptr, int *my_ptr,
+int ff_epzs_motion_search(struct MPVEncContext *s, int *mx_ptr, int *my_ptr,
                           int P[10][2], int src_index, int ref_index,
                           int16_t (*last_mv)[2], int ref_mv_scale, int size,
                           int h);
 
-int ff_get_mb_score(struct MpegEncContext *s, int mx, int my, int src_index,
+int ff_get_mb_score(struct MPVEncContext *s, int mx, int my, int src_index,
                     int ref_index, int size, int h, int add_rate);
 
-int ff_get_best_fcode(struct MpegEncContext *s,
+int ff_get_best_fcode(struct MPVEncContext *s,
                       int16_t (*mv_table)[2], int type);
 
-void ff_fix_long_p_mvs(struct MpegEncContext *s, int type);
-void ff_fix_long_mvs(struct MpegEncContext *s, uint8_t *field_select_table,
+void ff_fix_long_p_mvs(struct MPVEncContext *s, int type);
+void ff_fix_long_mvs(struct MPVEncContext *s, uint8_t *field_select_table,
                      int field_select, int16_t (*mv_table)[2], int f_code,
                      int type, int truncate);
-
+#undef MPVEncContext
 #endif /* AVCODEC_MOTION_EST_H */
diff --git a/libavcodec/motion_est_template.c b/libavcodec/motion_est_template.c
index 6ab0ea13dc..57df6436c3 100644
--- a/libavcodec/motion_est_template.c
+++ b/libavcodec/motion_est_template.c
@@ -47,7 +47,7 @@
     COPY3_IF_LT(dmin, d, bx, hx, by, hy)\
 }
 
-static int hpel_motion_search(MpegEncContext * s,
+static int hpel_motion_search(MPVEncContext * s,
                                   int *mx_ptr, int *my_ptr, int dmin,
                                   int src_index, int ref_index,
                                   int size, int h)
@@ -152,7 +152,7 @@ static int hpel_motion_search(MpegEncContext * s,
     return dmin;
 }
 
-static int no_sub_motion_search(MpegEncContext * s,
+static int no_sub_motion_search(MPVEncContext * s,
           int *mx_ptr, int *my_ptr, int dmin,
                                   int src_index, int ref_index,
                                   int size, int h)
@@ -162,7 +162,7 @@ static int no_sub_motion_search(MpegEncContext * s,
     return dmin;
 }
 
-static inline int get_mb_score(MpegEncContext *s, int mx, int my,
+static inline int get_mb_score(MPVEncContext *s, int mx, int my,
                                int src_index, int ref_index, int size,
                                int h, int add_rate)
 {
@@ -189,7 +189,7 @@ static inline int get_mb_score(MpegEncContext *s, int mx, int my,
     return d;
 }
 
-int ff_get_mb_score(MpegEncContext *s, int mx, int my, int src_index,
+int ff_get_mb_score(MPVEncContext *s, int mx, int my, int src_index,
                     int ref_index, int size, int h, int add_rate)
 {
     return get_mb_score(s, mx, my, src_index, ref_index, size, h, add_rate);
@@ -204,7 +204,7 @@ int ff_get_mb_score(MpegEncContext *s, int mx, int my, int src_index,
     COPY3_IF_LT(dmin, d, bx, hx, by, hy)\
 }
 
-static int qpel_motion_search(MpegEncContext * s,
+static int qpel_motion_search(MPVEncContext * s,
                                   int *mx_ptr, int *my_ptr, int dmin,
                                   int src_index, int ref_index,
                                   int size, int h)
@@ -413,7 +413,7 @@ if( (y)>(ymax<<(S)) ) av_log(NULL, AV_LOG_ERROR, "%d %d %d %d %d ymax" #v, ymax,
     const int qpel= flags&FLAG_QPEL;\
     const int shift= 1+qpel;\
 
-static av_always_inline int small_diamond_search(MpegEncContext * s, int *best, int dmin,
+static av_always_inline int small_diamond_search(MPVEncContext * s, int *best, int dmin,
                                        int src_index, int ref_index, const int penalty_factor,
                                        int size, int h, int flags)
 {
@@ -454,7 +454,7 @@ static av_always_inline int small_diamond_search(MpegEncContext * s, int *best,
     }
 }
 
-static int funny_diamond_search(MpegEncContext * s, int *best, int dmin,
+static int funny_diamond_search(MPVEncContext * s, int *best, int dmin,
                                        int src_index, int ref_index, const int penalty_factor,
                                        int size, int h, int flags)
 {
@@ -496,7 +496,7 @@ static int funny_diamond_search(MpegEncContext * s, int *best, int dmin,
     return dmin;
 }
 
-static int hex_search(MpegEncContext * s, int *best, int dmin,
+static int hex_search(MPVEncContext * s, int *best, int dmin,
                                        int src_index, int ref_index, const int penalty_factor,
                                        int size, int h, int flags, int dia_size)
 {
@@ -530,7 +530,7 @@ static int hex_search(MpegEncContext * s, int *best, int dmin,
     return dmin;
 }
 
-static int l2s_dia_search(MpegEncContext * s, int *best, int dmin,
+static int l2s_dia_search(MPVEncContext * s, int *best, int dmin,
                                        int src_index, int ref_index, const int penalty_factor,
                                        int size, int h, int flags)
 {
@@ -568,7 +568,7 @@ static int l2s_dia_search(MpegEncContext * s, int *best, int dmin,
     return dmin;
 }
 
-static int umh_search(MpegEncContext * s, int *best, int dmin,
+static int umh_search(MPVEncContext * s, int *best, int dmin,
                                        int src_index, int ref_index, const int penalty_factor,
                                        int size, int h, int flags)
 {
@@ -615,7 +615,7 @@ static int umh_search(MpegEncContext * s, int *best, int dmin,
     return hex_search(s, best, dmin, src_index, ref_index, penalty_factor, size, h, flags, 2);
 }
 
-static int full_search(MpegEncContext * s, int *best, int dmin,
+static int full_search(MPVEncContext * s, int *best, int dmin,
                                        int src_index, int ref_index, const int penalty_factor,
                                        int size, int h, int flags)
 {
@@ -678,7 +678,7 @@ static int full_search(MpegEncContext * s, int *best, int dmin,
 }
 
 #define MAX_SAB_SIZE ME_MAP_SIZE
-static int sab_diamond_search(MpegEncContext * s, int *best, int dmin,
+static int sab_diamond_search(MPVEncContext * s, int *best, int dmin,
                                        int src_index, int ref_index, const int penalty_factor,
                                        int size, int h, int flags)
 {
@@ -768,7 +768,7 @@ static int sab_diamond_search(MpegEncContext * s, int *best, int dmin,
     return dmin;
 }
 
-static int var_diamond_search(MpegEncContext * s, int *best, int dmin,
+static int var_diamond_search(MPVEncContext * s, int *best, int dmin,
                                        int src_index, int ref_index, const int penalty_factor,
                                        int size, int h, int flags)
 {
@@ -829,7 +829,7 @@ static int var_diamond_search(MpegEncContext * s, int *best, int dmin,
     return dmin;
 }
 
-static av_always_inline int diamond_search(MpegEncContext * s, int *best, int dmin,
+static av_always_inline int diamond_search(MPVEncContext * s, int *best, int dmin,
                                        int src_index, int ref_index, const int penalty_factor,
                                        int size, int h, int flags){
     MotionEstContext * const c= &s->me;
@@ -857,7 +857,7 @@ static av_always_inline int diamond_search(MpegEncContext * s, int *best, int dm
    it takes fewer iterations. And it increases the chance that we find the
    optimal mv.
  */
-static av_always_inline int epzs_motion_search_internal(MpegEncContext * s, int *mx_ptr, int *my_ptr,
+static av_always_inline int epzs_motion_search_internal(MPVEncContext * s, int *mx_ptr, int *my_ptr,
                              int P[10][2], int src_index, int ref_index, int16_t (*last_mv)[2],
                              int ref_mv_scale, int flags, int size, int h)
 {
@@ -974,7 +974,7 @@ static av_always_inline int epzs_motion_search_internal(MpegEncContext * s, int
 }
 
 //this function is dedicated to the brain damaged gcc
-int ff_epzs_motion_search(MpegEncContext *s, int *mx_ptr, int *my_ptr,
+int ff_epzs_motion_search(MPVEncContext *s, int *mx_ptr, int *my_ptr,
                           int P[10][2], int src_index, int ref_index,
                           int16_t (*last_mv)[2], int ref_mv_scale,
                           int size, int h)
@@ -990,7 +990,7 @@ int ff_epzs_motion_search(MpegEncContext *s, int *mx_ptr, int *my_ptr,
     }
 }
 
-static int epzs_motion_search2(MpegEncContext * s,
+static int epzs_motion_search2(MPVEncContext * s,
                              int *mx_ptr, int *my_ptr, int P[10][2],
                              int src_index, int ref_index, int16_t (*last_mv)[2],
                              int ref_mv_scale, const int size)
diff --git a/libavcodec/mpeg12.c b/libavcodec/mpeg12.c
index 58e03c05d4..c65805bd8f 100644
--- a/libavcodec/mpeg12.c
+++ b/libavcodec/mpeg12.c
@@ -103,7 +103,7 @@ av_cold void ff_init_2d_vlc_rl(RLTable *rl, unsigned static_size, int flags)
     }
 }
 
-av_cold void ff_mpeg12_common_init(MpegEncContext *s)
+av_cold void ff_mpeg12_common_init(MPVMainContext *s)
 {
 
     s->y_dc_scale_table =
@@ -111,7 +111,7 @@ av_cold void ff_mpeg12_common_init(MpegEncContext *s)
 
 }
 
-void ff_mpeg1_clean_buffers(MpegEncContext *s)
+void ff_mpeg1_clean_buffers(MPVContext *s)
 {
     s->last_dc[0] = 1 << (7 + s->intra_dc_precision);
     s->last_dc[1] = s->last_dc[0];
diff --git a/libavcodec/mpeg12.h b/libavcodec/mpeg12.h
index 7ab2527a36..b18568daa8 100644
--- a/libavcodec/mpeg12.h
+++ b/libavcodec/mpeg12.h
@@ -24,6 +24,7 @@
 
 #include "mpeg12vlc.h"
 #include "mpegvideo.h"
+#include "mpegvideoenc.h"
 #include "rl.h"
 
 /* Start codes. */
@@ -36,7 +37,7 @@
 #define EXT_START_CODE          0x000001b5
 #define USER_START_CODE         0x000001b2
 
-void ff_mpeg12_common_init(MpegEncContext *s);
+void ff_mpeg12_common_init(MPVMainContext *s);
 
 #define INIT_2D_VLC_RL(rl, static_size, flags)\
 {\
@@ -70,16 +71,16 @@ int ff_mpeg1_decode_block_intra(GetBitContext *gb,
                                 uint8_t *const scantable, int last_dc[3],
                                 int16_t *block, int index, int qscale);
 
-void ff_mpeg1_clean_buffers(MpegEncContext *s);
+void ff_mpeg1_clean_buffers(MPVContext *s);
 #if FF_API_FLAG_TRUNCATED
 int ff_mpeg1_find_frame_end(ParseContext *pc, const uint8_t *buf, int buf_size, AVCodecParserContext *s);
 #endif
 
-void ff_mpeg1_encode_picture_header(MpegEncContext *s, int picture_number);
-void ff_mpeg1_encode_mb(MpegEncContext *s, int16_t block[8][64],
+void ff_mpeg1_encode_picture_header(MPVMainEncContext *s, int picture_number);
+void ff_mpeg1_encode_mb(MPVEncContext *s, int16_t block[8][64],
                         int motion_x, int motion_y);
-void ff_mpeg1_encode_init(MpegEncContext *s);
-void ff_mpeg1_encode_slice_header(MpegEncContext *s);
+void ff_mpeg1_encode_init(MPVMainEncContext *s);
+void ff_mpeg1_encode_slice_header(MPVEncContext *s);
 
 void ff_mpeg12_find_best_frame_rate(AVRational frame_rate,
                                     int *code, int *ext_n, int *ext_d,
diff --git a/libavcodec/mpeg12dec.c b/libavcodec/mpeg12dec.c
index 4a7bd6d466..4c53451d8c 100644
--- a/libavcodec/mpeg12dec.c
+++ b/libavcodec/mpeg12dec.c
@@ -55,8 +55,8 @@
 #define A53_MAX_CC_COUNT 2000
 
 typedef struct Mpeg1Context {
-    MpegEncContext mpeg_enc_ctx;
-    int mpeg_enc_ctx_allocated; /* true if decoding context allocated */
+    MPVMainDecContext mpeg_ctx;
+    int mpeg_ctx_allocated;     /* true if decoding context allocated */
     int repeat_field;           /* true if we must repeat the field */
     AVPanScan pan_scan;         /* some temporary storage for the panscan */
     AVStereo3D stereo3d;
@@ -106,7 +106,7 @@ static const uint32_t btype2mb_type[11] = {
 };
 
 /* as H.263, but only 17 codes */
-static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred)
+static int mpeg_decode_motion(MPVDecContext *s, int fcode, int pred)
 {
     int code, sign, val, shift;
 
@@ -142,7 +142,7 @@ static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred)
         }                                                                     \
     } while (0)
 
-static inline int mpeg1_decode_block_inter(MpegEncContext *s,
+static inline int mpeg1_decode_block_inter(MPVDecContext *s,
                                            int16_t *block, int n)
 {
     int level, i, j, run;
@@ -231,7 +231,7 @@ end:
  * Changing this would eat up any speed benefits it has.
  * Do not use "fast" flag if you need the code to be robust.
  */
-static inline int mpeg1_fast_decode_block_inter(MpegEncContext *s,
+static inline int mpeg1_fast_decode_block_inter(MPVDecContext *s,
                                                 int16_t *block, int n)
 {
     int level, i, j, run;
@@ -316,7 +316,7 @@ end:
     return 0;
 }
 
-static inline int mpeg2_decode_block_non_intra(MpegEncContext *s,
+static inline int mpeg2_decode_block_non_intra(MPVDecContext *s,
                                                int16_t *block, int n)
 {
     int level, i, j, run;
@@ -406,7 +406,7 @@ end:
  * Changing this would eat up any speed benefits it has.
  * Do not use "fast" flag if you need the code to be robust.
  */
-static inline int mpeg2_fast_decode_block_non_intra(MpegEncContext *s,
+static inline int mpeg2_fast_decode_block_non_intra(MPVDecContext *s,
                                                     int16_t *block, int n)
 {
     int level, i, j, run;
@@ -478,7 +478,7 @@ end:
     return 0;
 }
 
-static inline int mpeg2_decode_block_intra(MpegEncContext *s,
+static inline int mpeg2_decode_block_intra(MPVDecContext *s,
                                            int16_t *block, int n)
 {
     int level, dc, diff, i, j, run;
@@ -564,7 +564,7 @@ static inline int mpeg2_decode_block_intra(MpegEncContext *s,
  * Changing this would eat up any speed benefits it has.
  * Do not use "fast" flag if you need the code to be robust.
  */
-static inline int mpeg2_fast_decode_block_intra(MpegEncContext *s,
+static inline int mpeg2_fast_decode_block_intra(MPVDecContext *s,
                                                 int16_t *block, int n)
 {
     int level, dc, diff, i, j, run;
@@ -640,7 +640,7 @@ static inline int mpeg2_fast_decode_block_intra(MpegEncContext *s,
 /******************************************/
 /* decoding */
 
-static inline int get_dmv(MpegEncContext *s)
+static inline int get_dmv(MPVDecContext *s)
 {
     if (get_bits1(&s->gb))
         return 1 - (get_bits1(&s->gb) << 1);
@@ -654,7 +654,7 @@ static inline int get_dmv(MpegEncContext *s)
 #define MT_16X8  2
 #define MT_DMV   3
 
-static int mpeg_decode_mb(MpegEncContext *s, int16_t block[12][64])
+static int mpeg_decode_mb(MPVDecContext *s, int16_t block[12][64])
 {
     int i, j, k, cbp, val, mb_type, motion_type;
     const int mb_block_count = 4 + (1 << s->chroma_format);
@@ -1054,7 +1054,7 @@ static int mpeg_decode_mb(MpegEncContext *s, int16_t block[12][64])
 static av_cold int mpeg_decode_init(AVCodecContext *avctx)
 {
     Mpeg1Context *s    = avctx->priv_data;
-    MpegEncContext *s2 = &s->mpeg_enc_ctx;
+    MPVMainDecContext *const s2 = &s->mpeg_ctx;
 
     if (   avctx->codec_tag != AV_RL32("VCR2")
         && avctx->codec_tag != AV_RL32("BW10"))
@@ -1064,11 +1064,11 @@ static av_cold int mpeg_decode_init(AVCodecContext *avctx)
     /* we need some permutation to store matrices,
      * until the decoder sets the real permutation. */
     ff_mpv_idct_init(s2);
-    ff_mpeg12_common_init(&s->mpeg_enc_ctx);
+    ff_mpeg12_common_init(&s->mpeg_ctx);
     ff_mpeg12_init_vlcs();
 
     s2->chroma_format              = 1;
-    s->mpeg_enc_ctx_allocated      = 0;
+    s->mpeg_ctx_allocated      = 0;
     s->repeat_field                = 0;
     avctx->color_range             = AVCOL_RANGE_MPEG;
     return 0;
@@ -1079,11 +1079,11 @@ static int mpeg_decode_update_thread_context(AVCodecContext *avctx,
                                              const AVCodecContext *avctx_from)
 {
     Mpeg1Context *ctx = avctx->priv_data, *ctx_from = avctx_from->priv_data;
-    MpegEncContext *s = &ctx->mpeg_enc_ctx, *s1 = &ctx_from->mpeg_enc_ctx;
+    MPVMainDecContext *const s = &ctx->mpeg_ctx, *s1 = &ctx_from->mpeg_ctx;
     int err;
 
     if (avctx == avctx_from               ||
-        !ctx_from->mpeg_enc_ctx_allocated ||
+        !ctx_from->mpeg_ctx_allocated ||
         !s1->context_initialized)
         return 0;
 
@@ -1091,8 +1091,8 @@ static int mpeg_decode_update_thread_context(AVCodecContext *avctx,
     if (err)
         return err;
 
-    if (!ctx->mpeg_enc_ctx_allocated)
-        memcpy(s + 1, s1 + 1, sizeof(Mpeg1Context) - sizeof(MpegEncContext));
+    if (!ctx->mpeg_ctx_allocated)
+        memcpy(s + 1, s1 + 1, sizeof(Mpeg1Context) - sizeof(MPVMainDecContext));
 
     return 0;
 }
@@ -1164,7 +1164,7 @@ static const enum AVPixelFormat mpeg12_pixfmt_list_444[] = {
 static enum AVPixelFormat mpeg_get_pixelformat(AVCodecContext *avctx)
 {
     Mpeg1Context *s1  = avctx->priv_data;
-    MpegEncContext *s = &s1->mpeg_enc_ctx;
+    MPVMainDecContext *const s = &s1->mpeg_ctx;
     const enum AVPixelFormat *pix_fmts;
 
     if (CONFIG_GRAY && (avctx->flags & AV_CODEC_FLAG_GRAY))
@@ -1191,7 +1191,7 @@ static void setup_hwaccel_for_pixfmt(AVCodecContext *avctx)
 
     if (avctx->hwaccel && avctx->pix_fmt == AV_PIX_FMT_XVMC) {
         Mpeg1Context *s1 = avctx->priv_data;
-        MpegEncContext *s = &s1->mpeg_enc_ctx;
+        MPVMainDecContext *const s = &s1->mpeg_ctx;
 
         s->pack_pblocks = 1;
     }
@@ -1202,7 +1202,7 @@ static void setup_hwaccel_for_pixfmt(AVCodecContext *avctx)
 static int mpeg_decode_postinit(AVCodecContext *avctx)
 {
     Mpeg1Context *s1  = avctx->priv_data;
-    MpegEncContext *s = &s1->mpeg_enc_ctx;
+    MPVMainDecContext *const s = &s1->mpeg_ctx;
     uint8_t old_permutation[64];
     int ret;
 
@@ -1257,7 +1257,7 @@ static int mpeg_decode_postinit(AVCodecContext *avctx)
         avctx->sample_aspect_ratio = (AVRational){ 0, 1 };
     }
 
-    if ((s1->mpeg_enc_ctx_allocated == 0)                   ||
+    if ((s1->mpeg_ctx_allocated == 0)                   ||
         avctx->coded_width       != s->width                ||
         avctx->coded_height      != s->height               ||
         s1->save_width           != s->width                ||
@@ -1265,7 +1265,7 @@ static int mpeg_decode_postinit(AVCodecContext *avctx)
         av_cmp_q(s1->save_aspect, s->avctx->sample_aspect_ratio) ||
         (s1->save_progressive_seq != s->progressive_sequence && FFALIGN(s->height, 16) != FFALIGN(s->height, 32)) ||
         0) {
-        if (s1->mpeg_enc_ctx_allocated) {
+        if (s1->mpeg_ctx_allocated) {
 #if FF_API_FLAG_TRUNCATED
             ParseContext pc = s->parse_context;
             s->parse_context.buffer = 0;
@@ -1274,7 +1274,7 @@ static int mpeg_decode_postinit(AVCodecContext *avctx)
 #else
             ff_mpv_common_end(s);
 #endif
-            s1->mpeg_enc_ctx_allocated = 0;
+            s1->mpeg_ctx_allocated = 0;
         }
 
         ret = ff_set_dimensions(avctx, s->width, s->height);
@@ -1335,7 +1335,7 @@ static int mpeg_decode_postinit(AVCodecContext *avctx)
         quant_matrix_rebuild(s->chroma_intra_matrix, old_permutation, s->idsp.idct_permutation);
         quant_matrix_rebuild(s->chroma_inter_matrix, old_permutation, s->idsp.idct_permutation);
 
-        s1->mpeg_enc_ctx_allocated = 1;
+        s1->mpeg_ctx_allocated = 1;
     }
     return 0;
 }
@@ -1344,7 +1344,7 @@ static int mpeg1_decode_picture(AVCodecContext *avctx, const uint8_t *buf,
                                 int buf_size)
 {
     Mpeg1Context *s1  = avctx->priv_data;
-    MpegEncContext *s = &s1->mpeg_enc_ctx;
+    MPVMainDecContext *const s = &s1->mpeg_ctx;
     int ref, f_code, vbv_delay, ret;
 
     ret = init_get_bits8(&s->gb, buf, buf_size);
@@ -1391,7 +1391,7 @@ static int mpeg1_decode_picture(AVCodecContext *avctx, const uint8_t *buf,
 
 static void mpeg_decode_sequence_extension(Mpeg1Context *s1)
 {
-    MpegEncContext *s = &s1->mpeg_enc_ctx;
+    MPVMainDecContext *const s = &s1->mpeg_ctx;
     int horiz_size_ext, vert_size_ext;
     int bit_rate_ext;
     AVCPBProperties *cpb_props;
@@ -1441,7 +1441,7 @@ static void mpeg_decode_sequence_extension(Mpeg1Context *s1)
 
 static void mpeg_decode_sequence_display_extension(Mpeg1Context *s1)
 {
-    MpegEncContext *s = &s1->mpeg_enc_ctx;
+    MPVMainDecContext *const s = &s1->mpeg_ctx;
     int color_description, w, h;
 
     skip_bits(&s->gb, 3); /* video format */
@@ -1465,7 +1465,7 @@ static void mpeg_decode_sequence_display_extension(Mpeg1Context *s1)
 
 static void mpeg_decode_picture_display_extension(Mpeg1Context *s1)
 {
-    MpegEncContext *s = &s1->mpeg_enc_ctx;
+    MPVMainDecContext *const s = &s1->mpeg_ctx;
     int i, nofco;
 
     nofco = 1;
@@ -1497,7 +1497,7 @@ static void mpeg_decode_picture_display_extension(Mpeg1Context *s1)
                s1->pan_scan.position[2][0], s1->pan_scan.position[2][1]);
 }
 
-static int load_matrix(MpegEncContext *s, uint16_t matrix0[64],
+static int load_matrix(MPVMainDecContext *s, uint16_t matrix0[64],
                        uint16_t matrix1[64], int intra)
 {
     int i;
@@ -1520,7 +1520,7 @@ static int load_matrix(MpegEncContext *s, uint16_t matrix0[64],
     return 0;
 }
 
-static void mpeg_decode_quant_matrix_extension(MpegEncContext *s)
+static void mpeg_decode_quant_matrix_extension(MPVMainDecContext *s)
 {
     ff_dlog(s->avctx, "matrix extension\n");
 
@@ -1536,7 +1536,7 @@ static void mpeg_decode_quant_matrix_extension(MpegEncContext *s)
 
 static int mpeg_decode_picture_coding_extension(Mpeg1Context *s1)
 {
-    MpegEncContext *s = &s1->mpeg_enc_ctx;
+    MPVMainDecContext *const s = &s1->mpeg_ctx;
 
     s->full_pel[0]       = s->full_pel[1] = 0;
     s->mpeg_f_code[0][0] = get_bits(&s->gb, 4);
@@ -1547,7 +1547,7 @@ static int mpeg_decode_picture_coding_extension(Mpeg1Context *s1)
     s->mpeg_f_code[0][1] += !s->mpeg_f_code[0][1];
     s->mpeg_f_code[1][0] += !s->mpeg_f_code[1][0];
     s->mpeg_f_code[1][1] += !s->mpeg_f_code[1][1];
-    if (!s->pict_type && s1->mpeg_enc_ctx_allocated) {
+    if (!s->pict_type && s1->mpeg_ctx_allocated) {
         av_log(s->avctx, AV_LOG_ERROR, "Missing picture start code\n");
         if (s->avctx->err_recognition & AV_EF_EXPLODE)
             return AVERROR_INVALIDDATA;
@@ -1597,7 +1597,7 @@ static int mpeg_decode_picture_coding_extension(Mpeg1Context *s1)
     return 0;
 }
 
-static int mpeg_field_start(MpegEncContext *s, const uint8_t *buf, int buf_size)
+static int mpeg_field_start(MPVMainDecContext *s, const uint8_t *buf, int buf_size)
 {
     AVCodecContext *avctx = s->avctx;
     Mpeg1Context *s1      = (Mpeg1Context *) s;
@@ -1705,11 +1705,11 @@ static int mpeg_field_start(MpegEncContext *s, const uint8_t *buf, int buf_size)
 
 /**
  * Decode a slice.
- * MpegEncContext.mb_y must be set to the MB row from the startcode.
+ * MPVDecContext.mb_y must be set to the MB row from the startcode.
  * @return DECODE_SLICE_ERROR if the slice is damaged,
  *         DECODE_SLICE_OK if this slice is OK
  */
-static int mpeg_decode_slice(MpegEncContext *s, int mb_y,
+static int mpeg_decode_slice(MPVDecContext *s, int mb_y,
                              const uint8_t **buf, int buf_size)
 {
     AVCodecContext *avctx = s->avctx;
@@ -1988,7 +1988,7 @@ eos: // end of slice
 
 static int slice_decode_thread(AVCodecContext *c, void *arg)
 {
-    MpegEncContext *s   = *(void **) arg;
+    MPVDecContext *s   = *(void **) arg;
     const uint8_t *buf  = s->gb.buffer;
     int mb_y            = s->start_mb_y;
     const int field_pic = s->picture_structure != PICT_FRAME;
@@ -2042,9 +2042,9 @@ static int slice_decode_thread(AVCodecContext *c, void *arg)
 static int slice_end(AVCodecContext *avctx, AVFrame *pict)
 {
     Mpeg1Context *s1  = avctx->priv_data;
-    MpegEncContext *s = &s1->mpeg_enc_ctx;
+    MPVMainDecContext *const s = &s1->mpeg_ctx;
 
-    if (!s1->mpeg_enc_ctx_allocated || !s->current_picture_ptr)
+    if (!s1->mpeg_ctx_allocated || !s->current_picture_ptr)
         return 0;
 
     if (s->avctx->hwaccel) {
@@ -2091,7 +2091,7 @@ static int mpeg1_decode_sequence(AVCodecContext *avctx,
                                  const uint8_t *buf, int buf_size)
 {
     Mpeg1Context *s1  = avctx->priv_data;
-    MpegEncContext *s = &s1->mpeg_enc_ctx;
+    MPVMainDecContext *const s = &s1->mpeg_ctx;
     int width, height;
     int i, v, j;
 
@@ -2179,14 +2179,14 @@ static int mpeg1_decode_sequence(AVCodecContext *avctx,
 static int vcr2_init_sequence(AVCodecContext *avctx)
 {
     Mpeg1Context *s1  = avctx->priv_data;
-    MpegEncContext *s = &s1->mpeg_enc_ctx;
+    MPVMainDecContext *const s = &s1->mpeg_ctx;
     int i, v, ret;
 
     /* start new MPEG-1 context decoding */
     s->out_format = FMT_MPEG1;
-    if (s1->mpeg_enc_ctx_allocated) {
+    if (s1->mpeg_ctx_allocated) {
         ff_mpv_common_end(s);
-        s1->mpeg_enc_ctx_allocated = 0;
+        s1->mpeg_ctx_allocated = 0;
     }
     s->width            = avctx->coded_width;
     s->height           = avctx->coded_height;
@@ -2199,7 +2199,7 @@ static int vcr2_init_sequence(AVCodecContext *avctx)
     ff_mpv_idct_init(s);
     if ((ret = ff_mpv_common_init(s)) < 0)
         return ret;
-    s1->mpeg_enc_ctx_allocated = 1;
+    s1->mpeg_ctx_allocated = 1;
 
     for (i = 0; i < 64; i++) {
         int j = s->idsp.idct_permutation[i];
@@ -2290,7 +2290,7 @@ static int mpeg_decode_a53_cc(AVCodecContext *avctx,
                         cap[0] = cap[1] = cap[2] = 0x00;
                     } else {
                         field = (field == 2 ? 1 : 0);
-                        if (!s1->mpeg_enc_ctx.top_field_first) field = !field;
+                        if (!s1->mpeg_ctx.top_field_first) field = !field;
                         cap[0] = 0x04 | field;
                         cap[1] = ff_reverse[cc1];
                         cap[2] = ff_reverse[cc2];
@@ -2439,7 +2439,7 @@ static void mpeg_decode_gop(AVCodecContext *avctx,
                             const uint8_t *buf, int buf_size)
 {
     Mpeg1Context *s1  = avctx->priv_data;
-    MpegEncContext *s = &s1->mpeg_enc_ctx;
+    MPVMainDecContext *const s = &s1->mpeg_ctx;
     int broken_link;
     int64_t tc;
 
@@ -2466,7 +2466,7 @@ static int decode_chunks(AVCodecContext *avctx, AVFrame *picture,
                          int *got_output, const uint8_t *buf, int buf_size)
 {
     Mpeg1Context *s = avctx->priv_data;
-    MpegEncContext *s2 = &s->mpeg_enc_ctx;
+    MPVMainDecContext *const s2 = &s->mpeg_ctx;
     const uint8_t *buf_ptr = buf;
     const uint8_t *buf_end = buf + buf_size;
     int ret, input_size;
@@ -2721,7 +2721,7 @@ static int decode_chunks(AVCodecContext *avctx, AVFrame *picture,
                     break;
                 }
 
-                if (!s->mpeg_enc_ctx_allocated)
+                if (!s->mpeg_ctx_allocated)
                     break;
 
                 if (s2->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
@@ -2757,7 +2757,7 @@ static int decode_chunks(AVCodecContext *avctx, AVFrame *picture,
                                     s2->slice_context_count;
                     av_assert0(avctx->thread_count > 1);
                     if (threshold <= mb_y) {
-                        MpegEncContext *thread_context = s2->thread_context[s->slice_count];
+                        MPVDecContext *const thread_context = s2->thread_context[s->slice_count];
 
                         thread_context->start_mb_y = mb_y;
                         thread_context->end_mb_y   = s2->mb_height;
@@ -2802,7 +2802,7 @@ static int mpeg_decode_frame(AVCodecContext *avctx, void *data,
     int buf_size = avpkt->size;
     Mpeg1Context *s = avctx->priv_data;
     AVFrame *picture = data;
-    MpegEncContext *s2 = &s->mpeg_enc_ctx;
+    MPVMainDecContext *const s2 = &s->mpeg_ctx;
 
     if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == SEQ_END_CODE)) {
         /* special case for last picture */
@@ -2830,7 +2830,7 @@ static int mpeg_decode_frame(AVCodecContext *avctx, void *data,
 #endif
 
     s2->codec_tag = ff_toupper4(avctx->codec_tag);
-    if (s->mpeg_enc_ctx_allocated == 0 && (   s2->codec_tag == AV_RL32("VCR2")
+    if (s->mpeg_ctx_allocated == 0 && (   s2->codec_tag == AV_RL32("VCR2")
                                            || s2->codec_tag == AV_RL32("BW10")
                                           ))
         vcr2_init_sequence(avctx);
@@ -2889,8 +2889,8 @@ static av_cold int mpeg_decode_end(AVCodecContext *avctx)
 {
     Mpeg1Context *s = avctx->priv_data;
 
-    if (s->mpeg_enc_ctx_allocated)
-        ff_mpv_common_end(&s->mpeg_enc_ctx);
+    if (s->mpeg_ctx_allocated)
+        ff_mpv_common_end(&s->mpeg_ctx);
     av_buffer_unref(&s->a53_buf_ref);
     return 0;
 }
@@ -3001,7 +3001,7 @@ const AVCodec ff_mpegvideo_decoder = {
 };
 
 typedef struct IPUContext {
-    MpegEncContext m;
+    MPVMainDecContext m;
 
     int flags;
     DECLARE_ALIGNED(32, int16_t, block)[6][64];
@@ -3011,7 +3011,7 @@ static int ipu_decode_frame(AVCodecContext *avctx, void *data,
                             int *got_frame, AVPacket *avpkt)
 {
     IPUContext *s = avctx->priv_data;
-    MpegEncContext *m = &s->m;
+    MPVMainDecContext *const m = &s->m;
     GetBitContext *gb = &m->gb;
     AVFrame * const frame = data;
     int ret;
@@ -3111,7 +3111,7 @@ static int ipu_decode_frame(AVCodecContext *avctx, void *data,
 static av_cold int ipu_decode_init(AVCodecContext *avctx)
 {
     IPUContext *s = avctx->priv_data;
-    MpegEncContext *m = &s->m;
+    MPVMainDecContext *const m = &s->m;
 
     avctx->pix_fmt = AV_PIX_FMT_YUV420P;
 
diff --git a/libavcodec/mpeg12enc.c b/libavcodec/mpeg12enc.c
index 3ec3ac1860..4d01a9215a 100644
--- a/libavcodec/mpeg12enc.c
+++ b/libavcodec/mpeg12enc.c
@@ -64,7 +64,7 @@ static uint32_t mpeg1_lum_dc_uni[512];
 static uint32_t mpeg1_chr_dc_uni[512];
 
 typedef struct MPEG12EncContext {
-    MpegEncContext mpeg;
+    MPVMainEncContext mpeg;
     AVRational frame_rate_ext;
     unsigned frame_rate_index;
 
@@ -122,7 +122,7 @@ 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)
 {
-    MpegEncContext *const s = &mpeg12->mpeg;
+    MPVMainEncContext *const s = &mpeg12->mpeg;
     int i;
     AVRational bestq = (AVRational) {0, 0};
     AVRational ext;
@@ -163,7 +163,7 @@ static int find_frame_rate_index(MPEG12EncContext *mpeg12)
 static av_cold int encode_init(AVCodecContext *avctx)
 {
     MPEG12EncContext *const mpeg12 = avctx->priv_data;
-    MpegEncContext *const s = &mpeg12->mpeg;
+    MPVMainEncContext *const s = &mpeg12->mpeg;
     int ret;
     int max_size = avctx->codec_id == AV_CODEC_ID_MPEG2VIDEO ? 16383 : 4095;
 
@@ -255,7 +255,7 @@ static av_cold int encode_init(AVCodecContext *avctx)
     return 0;
 }
 
-static void put_header(MpegEncContext *s, int header)
+static void put_header(MPVEncContext *s, int header)
 {
     align_put_bits(&s->pb);
     put_bits(&s->pb, 16, header >> 16);
@@ -263,7 +263,7 @@ static void put_header(MpegEncContext *s, int header)
 }
 
 /* put sequence header if needed */
-static void mpeg1_encode_sequence_header(MpegEncContext *s)
+static void mpeg1_encode_sequence_header(MPVMainEncContext *s)
 {
     MPEG12EncContext *const mpeg12 = (MPEG12EncContext*)s;
     unsigned int vbv_buffer_size, fps, v;
@@ -422,7 +422,7 @@ static void mpeg1_encode_sequence_header(MpegEncContext *s)
     put_bits(&s->pb, 1, 0);                     // broken link
 }
 
-static inline void encode_mb_skip_run(MpegEncContext *s, int run)
+static inline void encode_mb_skip_run(MPVEncContext *s, int run)
 {
     while (run >= 33) {
         put_bits(&s->pb, 11, 0x008);
@@ -432,12 +432,12 @@ static inline void encode_mb_skip_run(MpegEncContext *s, int run)
              ff_mpeg12_mbAddrIncrTable[run][0]);
 }
 
-static av_always_inline void put_qscale(MpegEncContext *s)
+static av_always_inline void put_qscale(MPVEncContext *s)
 {
     put_bits(&s->pb, 5, s->qscale);
 }
 
-void ff_mpeg1_encode_slice_header(MpegEncContext *s)
+void ff_mpeg1_encode_slice_header(MPVEncContext *s)
 {
     if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && s->height > 2800) {
         put_header(s, SLICE_MIN_START_CODE + (s->mb_y & 127));
@@ -451,7 +451,7 @@ void ff_mpeg1_encode_slice_header(MpegEncContext *s)
     put_bits(&s->pb, 1, 0);
 }
 
-void ff_mpeg1_encode_picture_header(MpegEncContext *s, int picture_number)
+void ff_mpeg1_encode_picture_header(MPVMainEncContext *s, int picture_number)
 {
     MPEG12EncContext *const mpeg12 = (MPEG12EncContext*)s;
     AVFrameSideData *side_data;
@@ -611,7 +611,7 @@ void ff_mpeg1_encode_picture_header(MpegEncContext *s, int picture_number)
     ff_mpeg1_encode_slice_header(s);
 }
 
-static inline void put_mb_modes(MpegEncContext *s, int n, int bits,
+static inline void put_mb_modes(MPVEncContext *s, int n, int bits,
                                 int has_mv, int field_motion)
 {
     put_bits(&s->pb, n, bits);
@@ -624,7 +624,7 @@ static inline void put_mb_modes(MpegEncContext *s, int n, int bits,
 }
 
 // RAL: Parameter added: f_or_b_code
-static void mpeg1_encode_motion(MpegEncContext *s, int val, int f_or_b_code)
+static void mpeg1_encode_motion(MPVEncContext *s, int val, int f_or_b_code)
 {
     if (val == 0) {
         /* zero vector, corresponds to ff_mpeg12_mbMotionVectorTable[0] */
@@ -661,7 +661,7 @@ static void mpeg1_encode_motion(MpegEncContext *s, int val, int f_or_b_code)
     }
 }
 
-static inline void encode_dc(MpegEncContext *s, int diff, int component)
+static inline void encode_dc(MPVEncContext *s, int diff, int component)
 {
     unsigned int diff_u = diff + 255;
     if (diff_u >= 511) {
@@ -695,7 +695,7 @@ static inline void encode_dc(MpegEncContext *s, int diff, int component)
     }
 }
 
-static void mpeg1_encode_block(MpegEncContext *s, int16_t *block, int n)
+static void mpeg1_encode_block(MPVEncContext *s, int16_t *block, int n)
 {
     int alevel, level, last_non_zero, dc, diff, i, j, run, last_index, sign;
     int code, component;
@@ -776,7 +776,7 @@ next_coef:
     put_bits(&s->pb, table_vlc[112][1], table_vlc[112][0]);
 }
 
-static av_always_inline void mpeg1_encode_mb_internal(MpegEncContext *s,
+static av_always_inline void mpeg1_encode_mb_internal(MPVEncContext *s,
                                                       int16_t block[8][64],
                                                       int motion_x, int motion_y,
                                                       int mb_block_count,
@@ -1057,7 +1057,7 @@ static av_always_inline void mpeg1_encode_mb_internal(MpegEncContext *s,
     }
 }
 
-void ff_mpeg1_encode_mb(MpegEncContext *s, int16_t block[8][64],
+void ff_mpeg1_encode_mb(MPVEncContext *s, int16_t block[8][64],
                         int motion_x, int motion_y)
 {
     if (s->chroma_format == CHROMA_420)
@@ -1131,7 +1131,7 @@ static av_cold void mpeg12_encode_init_static(void)
             fcode_tab[mv + MAX_MV] = f_code;
 }
 
-av_cold void ff_mpeg1_encode_init(MpegEncContext *s)
+av_cold void ff_mpeg1_encode_init(MPVMainEncContext *s)
 {
     static AVOnce init_static_once = AV_ONCE_INIT;
 
diff --git a/libavcodec/mpeg4video.c b/libavcodec/mpeg4video.c
index ffeaf822b2..68be7e21ed 100644
--- a/libavcodec/mpeg4video.c
+++ b/libavcodec/mpeg4video.c
@@ -39,7 +39,7 @@ av_cold void ff_mpeg4_init_rl_intra(void)
     ff_thread_once(&init_static_once, mpeg4_init_rl_intra);
 }
 
-int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s)
+int ff_mpeg4_get_video_packet_prefix_length(MPVContext *s)
 {
     switch (s->pict_type) {
     case AV_PICTURE_TYPE_I:
@@ -54,7 +54,7 @@ int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s)
     }
 }
 
-void ff_mpeg4_clean_buffers(MpegEncContext *s)
+void ff_mpeg4_clean_buffers(MPVContext *s)
 {
     int c_wrap, c_xy, l_wrap, l_xy;
 
@@ -80,7 +80,7 @@ void ff_mpeg4_clean_buffers(MpegEncContext *s)
 #define tab_bias (tab_size / 2)
 
 // used by MPEG-4 and rv10 decoder
-void ff_mpeg4_init_direct_mv(MpegEncContext *s)
+void ff_mpeg4_init_direct_mv(MPVMainContext *s)
 {
     int i;
     for (i = 0; i < tab_size; i++) {
@@ -90,7 +90,7 @@ void ff_mpeg4_init_direct_mv(MpegEncContext *s)
     }
 }
 
-static inline void ff_mpeg4_set_one_direct_mv(MpegEncContext *s, int mx,
+static inline void ff_mpeg4_set_one_direct_mv(MPVContext *s, int mx,
                                               int my, int i)
 {
     int xy           = s->block_index[i];
@@ -126,7 +126,7 @@ static inline void ff_mpeg4_set_one_direct_mv(MpegEncContext *s, int mx,
 /**
  * @return the mb_type
  */
-int ff_mpeg4_set_direct_mv(MpegEncContext *s, int mx, int my)
+int ff_mpeg4_set_direct_mv(MPVContext *s, int mx, int my)
 {
     const int mb_index          = s->mb_x + s->mb_y * s->mb_stride;
     const int colocated_mb_type = s->next_picture.mb_type[mb_index];
diff --git a/libavcodec/mpeg4video.h b/libavcodec/mpeg4video.h
index 14fc5e1396..6e72c6478a 100644
--- a/libavcodec/mpeg4video.h
+++ b/libavcodec/mpeg4video.h
@@ -27,6 +27,7 @@
 
 #include "get_bits.h"
 #include "mpegvideo.h"
+#include "mpegvideoenc.h"
 
 // shapes
 #define RECT_SHAPE       0
@@ -71,7 +72,7 @@
 #define MAX_NVOP_SIZE 19
 
 typedef struct Mpeg4DecContext {
-    MpegEncContext m;
+    MPVMainDecContext m;
 
     /// number of bits to represent the fractional part of time
     int time_increment_bits;
@@ -124,37 +125,37 @@ typedef struct Mpeg4DecContext {
 } Mpeg4DecContext;
 
 
-void ff_mpeg4_decode_studio(MpegEncContext *s, uint8_t *dest_y, uint8_t *dest_cb,
+void ff_mpeg4_decode_studio(MPVContext *s, uint8_t *dest_y, uint8_t *dest_cb,
                             uint8_t *dest_cr, int block_size, int uvlinesize,
                             int dct_linesize, int dct_offset);
-void ff_mpeg4_encode_mb(MpegEncContext *s,
+void ff_mpeg4_encode_mb(MPVEncContext *s,
                         int16_t block[6][64],
                         int motion_x, int motion_y);
-void ff_mpeg4_pred_ac(MpegEncContext *s, int16_t *block, int n,
+void ff_mpeg4_pred_ac(MPVDecContext *s, int16_t *block, int n,
                       int dir);
-void ff_set_mpeg4_time(MpegEncContext *s);
-int ff_mpeg4_encode_picture_header(MpegEncContext *s, int picture_number);
+void ff_set_mpeg4_time(MPVMainEncContext *s);
+int ff_mpeg4_encode_picture_header(MPVMainEncContext *s, int picture_number);
 
 int ff_mpeg4_decode_picture_header(Mpeg4DecContext *ctx, GetBitContext *gb,
                                    int header, int parse_only);
-void ff_mpeg4_encode_video_packet_header(MpegEncContext *s);
-void ff_mpeg4_clean_buffers(MpegEncContext *s);
+void ff_mpeg4_encode_video_packet_header(MPVEncContext *s);
+void ff_mpeg4_clean_buffers(MPVContext *s);
 void ff_mpeg4_stuffing(PutBitContext *pbc);
-void ff_mpeg4_init_partitions(MpegEncContext *s);
-void ff_mpeg4_merge_partitions(MpegEncContext *s);
-void ff_clean_mpeg4_qscales(MpegEncContext *s);
+void ff_mpeg4_init_partitions(MPVEncContext *s);
+void ff_mpeg4_merge_partitions(MPVEncContext *s);
+void ff_clean_mpeg4_qscales(MPVMainEncContext *s);
 int ff_mpeg4_decode_partitions(Mpeg4DecContext *ctx);
-int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s);
+int ff_mpeg4_get_video_packet_prefix_length(MPVContext *s);
 int ff_mpeg4_decode_video_packet_header(Mpeg4DecContext *ctx);
 int ff_mpeg4_decode_studio_slice_header(Mpeg4DecContext *ctx);
-void ff_mpeg4_init_direct_mv(MpegEncContext *s);
+void ff_mpeg4_init_direct_mv(MPVContext *s);
 int ff_mpeg4_workaround_bugs(AVCodecContext *avctx);
 int ff_mpeg4_frame_end(AVCodecContext *avctx, const uint8_t *buf, int buf_size);
 
 /**
  * @return the mb_type
  */
-int ff_mpeg4_set_direct_mv(MpegEncContext *s, int mx, int my);
+int ff_mpeg4_set_direct_mv(MPVContext *s, int mx, int my);
 
 #if 0 //3IV1 is quite rare and it slows things down a tiny bit
 #define IS_3IV1 s->codec_tag == AV_RL32("3IV1")
@@ -169,7 +170,7 @@ int ff_mpeg4_set_direct_mv(MpegEncContext *s, int mx, int my);
  * @param n block index (0-3 are luma, 4-5 are chroma)
  * @param dir_ptr pointer to an integer where the prediction direction will be stored
  */
-static inline int ff_mpeg4_pred_dc(MpegEncContext *s, int n, int level,
+static inline int ff_mpeg4_pred_dc(MPVContext *s, int n, int level,
                                    int *dir_ptr, int encoding)
 {
     int a, b, c, wrap, pred, scale, ret;
diff --git a/libavcodec/mpeg4video_parser.c b/libavcodec/mpeg4video_parser.c
index 1f89bae490..46601ab1e1 100644
--- a/libavcodec/mpeg4video_parser.c
+++ b/libavcodec/mpeg4video_parser.c
@@ -91,7 +91,7 @@ static int mpeg4_decode_header(AVCodecParserContext *s1, AVCodecContext *avctx,
 {
     struct Mp4vParseContext *pc = s1->priv_data;
     Mpeg4DecContext *dec_ctx = &pc->dec_ctx;
-    MpegEncContext *s = &dec_ctx->m;
+    MPVDecContext *const s = &dec_ctx->m;
     GetBitContext gb1, *gb = &gb1;
     int ret;
 
diff --git a/libavcodec/mpeg4videodec.c b/libavcodec/mpeg4videodec.c
index c0eaa00eba..8f67c9bdd0 100644
--- a/libavcodec/mpeg4videodec.c
+++ b/libavcodec/mpeg4videodec.c
@@ -68,7 +68,7 @@ static const int mb_type_b_map[4] = {
     MB_TYPE_L0      | MB_TYPE_16x16,
 };
 
-void ff_mpeg4_decode_studio(MpegEncContext *s, uint8_t *dest_y, uint8_t *dest_cb,
+void ff_mpeg4_decode_studio(MPVContext *s, uint8_t *dest_y, uint8_t *dest_cb,
                             uint8_t *dest_cr, int block_size, int uvlinesize,
                             int dct_linesize, int dct_offset)
 {
@@ -136,7 +136,7 @@ void ff_mpeg4_decode_studio(MpegEncContext *s, uint8_t *dest_y, uint8_t *dest_cb
  * @param n block index (0-3 are luma, 4-5 are chroma)
  * @param dir the ac prediction direction
  */
-void ff_mpeg4_pred_ac(MpegEncContext *s, int16_t *block, int n, int dir)
+void ff_mpeg4_pred_ac(MPVDecContext *s, int16_t *block, int n, int dir)
 {
     int i;
     int16_t *ac_val, *ac_val1;
@@ -193,7 +193,7 @@ void ff_mpeg4_pred_ac(MpegEncContext *s, int16_t *block, int n, int dir)
  */
 static inline int mpeg4_is_resync(Mpeg4DecContext *ctx)
 {
-    MpegEncContext *s = &ctx->m;
+    MPVDecContext *const s = &ctx->m;
     int bits_count = get_bits_count(&s->gb);
     int v          = show_bits(&s->gb, 16);
 
@@ -243,7 +243,7 @@ static inline int mpeg4_is_resync(Mpeg4DecContext *ctx)
 
 static int mpeg4_decode_sprite_trajectory(Mpeg4DecContext *ctx, GetBitContext *gb)
 {
-    MpegEncContext *s = &ctx->m;
+    MPVDecContext *const s = &ctx->m;
     int a     = 2 << s->sprite_warping_accuracy;
     int rho   = 3  - s->sprite_warping_accuracy;
     int r     = 16 / a;
@@ -495,7 +495,7 @@ overflow:
 }
 
 static int decode_new_pred(Mpeg4DecContext *ctx, GetBitContext *gb) {
-    MpegEncContext *s = &ctx->m;
+    MPVDecContext *const s = &ctx->m;
     int len = FFMIN(ctx->time_increment_bits + 3, 15);
 
     get_bits(gb, len);
@@ -512,7 +512,7 @@ static int decode_new_pred(Mpeg4DecContext *ctx, GetBitContext *gb) {
  */
 int ff_mpeg4_decode_video_packet_header(Mpeg4DecContext *ctx)
 {
-    MpegEncContext *s = &ctx->m;
+    MPVMainDecContext *const s = &ctx->m;
 
     int mb_num_bits      = av_log2(s->mb_num - 1) + 1;
     int header_extension = 0, mb_num, len;
@@ -599,7 +599,7 @@ int ff_mpeg4_decode_video_packet_header(Mpeg4DecContext *ctx)
     return 0;
 }
 
-static void reset_studio_dc_predictors(MpegEncContext *s)
+static void reset_studio_dc_predictors(MPVDecContext *s)
 {
     /* Reset DC Predictors */
     s->last_dc[0] =
@@ -613,7 +613,7 @@ static void reset_studio_dc_predictors(MpegEncContext *s)
  */
 int ff_mpeg4_decode_studio_slice_header(Mpeg4DecContext *ctx)
 {
-    MpegEncContext *s = &ctx->m;
+    MPVMainDecContext *const s = &ctx->m;
     GetBitContext *gb = &s->gb;
     unsigned vlc_len;
     uint16_t mb_num;
@@ -655,7 +655,7 @@ int ff_mpeg4_decode_studio_slice_header(Mpeg4DecContext *ctx)
  */
 static inline int get_amv(Mpeg4DecContext *ctx, int n)
 {
-    MpegEncContext *s = &ctx->m;
+    MPVDecContext *const s = &ctx->m;
     int x, y, mb_v, sum, dx, dy, shift;
     int len     = 1 << (s->f_code + 4);
     const int a = s->sprite_warping_accuracy;
@@ -706,7 +706,7 @@ static inline int get_amv(Mpeg4DecContext *ctx, int n)
  * @param dir_ptr the prediction direction will be stored here
  * @return the quantized dc
  */
-static inline int mpeg4_decode_dc(MpegEncContext *s, int n, int *dir_ptr)
+static inline int mpeg4_decode_dc(MPVDecContext *s, int n, int *dir_ptr)
 {
     int level, code;
 
@@ -755,7 +755,7 @@ static inline int mpeg4_decode_dc(MpegEncContext *s, int n, int *dir_ptr)
  */
 static int mpeg4_decode_partition_a(Mpeg4DecContext *ctx)
 {
-    MpegEncContext *s = &ctx->m;
+    MPVMainDecContext *const s = &ctx->m;
     int mb_num = 0;
     static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
 
@@ -947,7 +947,7 @@ try_again:
  * decode second partition.
  * @return <0 if an error occurred
  */
-static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count)
+static int mpeg4_decode_partition_b(MPVMainDecContext *s, int mb_count)
 {
     int mb_num = 0;
     static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
@@ -1042,7 +1042,7 @@ static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count)
  */
 int ff_mpeg4_decode_partitions(Mpeg4DecContext *ctx)
 {
-    MpegEncContext *s = &ctx->m;
+    MPVMainDecContext *const s = &ctx->m;
     int mb_num;
     int ret;
     const int part_a_error = s->pict_type == AV_PICTURE_TYPE_I ? (ER_DC_ERROR | ER_MV_ERROR) : ER_MV_ERROR;
@@ -1109,7 +1109,7 @@ static inline int mpeg4_decode_block(Mpeg4DecContext *ctx, int16_t *block,
                                      int n, int coded, int intra,
                                      int use_intra_dc_vlc, int rvlc)
 {
-    MpegEncContext *s = &ctx->m;
+    MPVDecContext *const s = &ctx->m;
     int level, i, last, run, qmul, qadd;
     int av_uninit(dc_pred_dir);
     RLTable *rl;
@@ -1377,7 +1377,7 @@ not_coded:
  * decode partition C of one MB.
  * @return <0 if an error occurred
  */
-static int mpeg4_decode_partitioned_mb(MpegEncContext *s, int16_t block[6][64])
+static int mpeg4_decode_partitioned_mb(MPVDecContext *s, int16_t block[6][64])
 {
     Mpeg4DecContext *ctx = s->avctx->priv_data;
     int cbp, mb_type, use_intra_dc_vlc;
@@ -1465,7 +1465,7 @@ static int mpeg4_decode_partitioned_mb(MpegEncContext *s, int16_t block[6][64])
     }
 }
 
-static int mpeg4_decode_mb(MpegEncContext *s, int16_t block[6][64])
+static int mpeg4_decode_mb(MPVDecContext *s, int16_t block[6][64])
 {
     Mpeg4DecContext *ctx = s->avctx->priv_data;
     int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
@@ -1885,7 +1885,7 @@ static const uint8_t ac_state_tab[22][2] =
     {0, 11}
 };
 
-static int mpeg4_decode_studio_block(MpegEncContext *s, int32_t block[64], int n)
+static int mpeg4_decode_studio_block(MPVDecContext *s, int32_t block[64], int n)
 {
     Mpeg4DecContext *ctx = s->avctx->priv_data;
 
@@ -2000,7 +2000,7 @@ static int mpeg4_decode_studio_block(MpegEncContext *s, int32_t block[64], int n
     return 0;
 }
 
-static int mpeg4_decode_dpcm_macroblock(MpegEncContext *s, int16_t macroblock[256], int n)
+static int mpeg4_decode_dpcm_macroblock(MPVDecContext *s, int16_t macroblock[256], int n)
 {
     int i, j, w, h, idx = 0;
     int block_mean, rice_parameter, rice_prefix_code, rice_suffix_code,
@@ -2083,7 +2083,7 @@ static int mpeg4_decode_dpcm_macroblock(MpegEncContext *s, int16_t macroblock[25
     return 0;
 }
 
-static int mpeg4_decode_studio_mb(MpegEncContext *s, int16_t block_[12][64])
+static int mpeg4_decode_studio_mb(MPVDecContext *s, int16_t block_[12][64])
 {
     Mpeg4DecContext *const ctx = (Mpeg4DecContext*)s;
     int i;
@@ -2131,7 +2131,7 @@ static int mpeg4_decode_studio_mb(MpegEncContext *s, int16_t block_[12][64])
     return SLICE_OK;
 }
 
-static int mpeg4_decode_gop_header(MpegEncContext *s, GetBitContext *gb)
+static int mpeg4_decode_gop_header(MPVMainDecContext *s, GetBitContext *gb)
 {
     int hours, minutes, seconds;
 
@@ -2153,7 +2153,7 @@ static int mpeg4_decode_gop_header(MpegEncContext *s, GetBitContext *gb)
     return 0;
 }
 
-static int mpeg4_decode_profile_level(MpegEncContext *s, GetBitContext *gb, int *profile, int *level)
+static int mpeg4_decode_profile_level(GetBitContext *gb, int *profile, int *level)
 {
 
     *profile = get_bits(gb, 4);
@@ -2167,7 +2167,7 @@ static int mpeg4_decode_profile_level(MpegEncContext *s, GetBitContext *gb, int
     return 0;
 }
 
-static int mpeg4_decode_visual_object(MpegEncContext *s, GetBitContext *gb)
+static int mpeg4_decode_visual_object(MPVMainDecContext *s, GetBitContext *gb)
 {
     int visual_object_type;
     int is_visual_object_identifier = get_bits1(gb);
@@ -2199,7 +2199,7 @@ static int mpeg4_decode_visual_object(MpegEncContext *s, GetBitContext *gb)
     return 0;
 }
 
-static void mpeg4_load_default_matrices(MpegEncContext *s)
+static void mpeg4_load_default_matrices(MPVMainDecContext *s)
 {
     int i, v;
 
@@ -2216,7 +2216,7 @@ static void mpeg4_load_default_matrices(MpegEncContext *s)
     }
 }
 
-static int read_quant_matrix_ext(MpegEncContext *s, GetBitContext *gb)
+static int read_quant_matrix_ext(MPVMainDecContext *s, GetBitContext *gb)
 {
     int i, j, v;
 
@@ -2265,7 +2265,7 @@ static int read_quant_matrix_ext(MpegEncContext *s, GetBitContext *gb)
     return 0;
 }
 
-static void extension_and_user_data(MpegEncContext *s, GetBitContext *gb, int id)
+static void extension_and_user_data(MPVMainDecContext *s, GetBitContext *gb, int id)
 {
     uint32_t startcode;
     uint8_t extension_type;
@@ -2284,7 +2284,7 @@ static void extension_and_user_data(MpegEncContext *s, GetBitContext *gb, int id
 
 static int decode_studio_vol_header(Mpeg4DecContext *ctx, GetBitContext *gb)
 {
-    MpegEncContext *s = &ctx->m;
+    MPVMainDecContext *const s = &ctx->m;
     int width, height, aspect_ratio_info;
     int bits_per_raw_sample;
     int rgb, chroma_format;
@@ -2370,7 +2370,7 @@ static int decode_studio_vol_header(Mpeg4DecContext *ctx, GetBitContext *gb)
 
 static int decode_vol_header(Mpeg4DecContext *ctx, GetBitContext *gb)
 {
-    MpegEncContext *s = &ctx->m;
+    MPVMainDecContext *const s = &ctx->m;
     int width, height, vo_ver_id, aspect_ratio_info;
 
     /* vol header */
@@ -2745,7 +2745,7 @@ no_cplx_est:
  */
 static int decode_user_data(Mpeg4DecContext *ctx, GetBitContext *gb)
 {
-    MpegEncContext *s = &ctx->m;
+    MPVMainDecContext *const s = &ctx->m;
     char buf[256];
     int i;
     int e;
@@ -2803,7 +2803,7 @@ static int decode_user_data(Mpeg4DecContext *ctx, GetBitContext *gb)
 int ff_mpeg4_workaround_bugs(AVCodecContext *avctx)
 {
     Mpeg4DecContext *ctx = avctx->priv_data;
-    MpegEncContext *s = &ctx->m;
+    MPVMainDecContext *const s = &ctx->m;
 
     if (ctx->xvid_build == -1 && ctx->divx_version == -1 && ctx->lavc_build == -1) {
         if (s->codec_tag        == AV_RL32("XVID") ||
@@ -2921,7 +2921,7 @@ int ff_mpeg4_workaround_bugs(AVCodecContext *avctx)
 static int decode_vop_header(Mpeg4DecContext *ctx, GetBitContext *gb,
                              int parse_only)
 {
-    MpegEncContext *s = &ctx->m;
+    MPVMainDecContext *const s = &ctx->m;
     int time_incr, time_increment;
     int64_t pts;
 
@@ -3203,7 +3203,7 @@ end:
 
 static void decode_smpte_tc(Mpeg4DecContext *ctx, GetBitContext *gb)
 {
-    MpegEncContext *s = &ctx->m;
+    MPVMainDecContext *const s = &ctx->m;
 
     skip_bits(gb, 16); /* Time_code[63..48] */
     check_marker(s->avctx, gb, "after Time_code[63..48]");
@@ -3222,7 +3222,7 @@ static void decode_smpte_tc(Mpeg4DecContext *ctx, GetBitContext *gb)
  */
 static int decode_studio_vop_header(Mpeg4DecContext *ctx, GetBitContext *gb)
 {
-    MpegEncContext *s = &ctx->m;
+    MPVMainDecContext *const s = &ctx->m;
 
     if (get_bits_left(gb) <= 32)
         return 0;
@@ -3277,7 +3277,7 @@ static int decode_studio_vop_header(Mpeg4DecContext *ctx, GetBitContext *gb)
 
 static int decode_studiovisualobject(Mpeg4DecContext *ctx, GetBitContext *gb)
 {
-    MpegEncContext *s = &ctx->m;
+    MPVMainDecContext *const s = &ctx->m;
     int visual_object_type;
 
     skip_bits(gb, 4); /* visual_object_verid */
@@ -3306,7 +3306,7 @@ static int decode_studiovisualobject(Mpeg4DecContext *ctx, GetBitContext *gb)
 int ff_mpeg4_decode_picture_header(Mpeg4DecContext *ctx, GetBitContext *gb,
                                    int header, int parse_only)
 {
-    MpegEncContext *s = &ctx->m;
+    MPVMainDecContext *const s = &ctx->m;
     unsigned startcode, v;
     int ret;
     int vol = 0;
@@ -3420,7 +3420,7 @@ int ff_mpeg4_decode_picture_header(Mpeg4DecContext *ctx, GetBitContext *gb,
             mpeg4_decode_gop_header(s, gb);
         } else if (startcode == VOS_STARTCODE) {
             int profile, level;
-            mpeg4_decode_profile_level(s, gb, &profile, &level);
+            mpeg4_decode_profile_level(gb, &profile, &level);
             if (profile == FF_PROFILE_MPEG4_SIMPLE_STUDIO &&
                 (level > 0 && level < 9)) {
                 s->studio_profile = 1;
@@ -3464,7 +3464,7 @@ end:
 int ff_mpeg4_frame_end(AVCodecContext *avctx, const uint8_t *buf, int buf_size)
 {
     Mpeg4DecContext *ctx = avctx->priv_data;
-    MpegEncContext    *s = &ctx->m;
+    MPVMainDecContext *const s = &ctx->m;
 
     /* divx 5.01+ bitstream reorder stuff */
     /* Since this clobbers the input buffer and hwaccel codecs still need the
@@ -3560,8 +3560,8 @@ static int mpeg4_update_thread_context(AVCodecContext *dst,
 static int mpeg4_update_thread_context_for_user(AVCodecContext *dst,
                                                 const AVCodecContext *src)
 {
-    MpegEncContext *m = dst->priv_data;
-    const MpegEncContext *m1 = src->priv_data;
+    MPVMainDecContext *const m = dst->priv_data;
+    const MPVMainDecContext *const m1 = src->priv_data;
 
     m->quarter_sample = m1->quarter_sample;
     m->divx_packed    = m1->divx_packed;
@@ -3621,7 +3621,7 @@ static av_cold int decode_init(AVCodecContext *avctx)
 {
     static AVOnce init_static_once = AV_ONCE_INIT;
     Mpeg4DecContext *ctx = avctx->priv_data;
-    MpegEncContext *s = &ctx->m;
+    MPVMainDecContext *const s = &ctx->m;
     int ret;
 
     ctx->divx_version =
@@ -3644,7 +3644,7 @@ static av_cold int decode_init(AVCodecContext *avctx)
     return 0;
 }
 
-#define OFFSET(x) offsetof(MpegEncContext, x)
+#define OFFSET(x) offsetof(MPVMainDecContext, x)
 #define FLAGS AV_OPT_FLAG_EXPORT | AV_OPT_FLAG_READONLY
 static const AVOption mpeg4_options[] = {
     {"quarter_sample", "1/4 subpel MC", OFFSET(quarter_sample), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, FLAGS},
diff --git a/libavcodec/mpeg4videoenc.c b/libavcodec/mpeg4videoenc.c
index d09e20605d..cd7ce1f382 100644
--- a/libavcodec/mpeg4videoenc.c
+++ b/libavcodec/mpeg4videoenc.c
@@ -66,7 +66,7 @@ static uint8_t  uni_mpeg4_inter_rl_len[64 * 64 * 2 * 2];
  * Return the number of bits that encoding the 8x8 block in block would need.
  * @param[in]  block_last_index last index in scantable order that refers to a non zero element in block.
  */
-static inline int get_block_rate(MpegEncContext *s, int16_t block[64],
+static inline int get_block_rate(MPVEncContext *s, int16_t block[64],
                                  int block_last_index, uint8_t scantable[64])
 {
     int last = 0;
@@ -101,7 +101,7 @@ static inline int get_block_rate(MpegEncContext *s, int16_t block[64],
  * @param[out] st scantable for each 8x8 block
  * @param[in] zigzag_last_index index referring to the last non zero coefficient in zigzag order
  */
-static inline void restore_ac_coeffs(MpegEncContext *s, int16_t block[6][64],
+static inline void restore_ac_coeffs(MPVEncContext *s, int16_t block[6][64],
                                      const int dir[6], uint8_t *st[6],
                                      const int zigzag_last_index[6])
 {
@@ -132,7 +132,7 @@ static inline void restore_ac_coeffs(MpegEncContext *s, int16_t block[6][64],
  * @param[out] st scantable for each 8x8 block
  * @param[out] zigzag_last_index index referring to the last non zero coefficient in zigzag order
  */
-static inline int decide_ac_pred(MpegEncContext *s, int16_t block[6][64],
+static inline int decide_ac_pred(MPVEncContext *s, int16_t block[6][64],
                                  const int dir[6], uint8_t *st[6],
                                  int zigzag_last_index[6])
 {
@@ -215,7 +215,7 @@ static inline int decide_ac_pred(MpegEncContext *s, int16_t block[6][64],
 /**
  * modify mb_type & qscale so that encoding is actually possible in MPEG-4
  */
-void ff_clean_mpeg4_qscales(MpegEncContext *s)
+void ff_clean_mpeg4_qscales(MPVMainEncContext *s)
 {
     int i;
     int8_t *const qscale_table = s->current_picture.qscale_table;
@@ -284,7 +284,7 @@ static inline int mpeg4_get_dc_length(int level, int n)
  * Encode an 8x8 block.
  * @param n block index (0-3 are luma, 4-5 are chroma)
  */
-static inline void mpeg4_encode_block(MpegEncContext *s,
+static inline void mpeg4_encode_block(MPVEncContext *s,
                                       int16_t *block, int n, int intra_dc,
                                       uint8_t *scan_table, PutBitContext *dc_pb,
                                       PutBitContext *ac_pb)
@@ -345,7 +345,7 @@ static inline void mpeg4_encode_block(MpegEncContext *s,
     }
 }
 
-static int mpeg4_get_block_length(MpegEncContext *s,
+static int mpeg4_get_block_length(MPVEncContext *s,
                                   int16_t *block, int n,
                                   int intra_dc, uint8_t *scan_table)
 {
@@ -399,7 +399,7 @@ static int mpeg4_get_block_length(MpegEncContext *s,
     return len;
 }
 
-static inline void mpeg4_encode_blocks(MpegEncContext *s, int16_t block[6][64],
+static inline void mpeg4_encode_blocks(MPVEncContext *s, int16_t block[6][64],
                                        int intra_dc[6], uint8_t **scan_table,
                                        PutBitContext *dc_pb,
                                        PutBitContext *ac_pb)
@@ -433,7 +433,7 @@ static inline void mpeg4_encode_blocks(MpegEncContext *s, int16_t block[6][64],
     }
 }
 
-static inline int get_b_cbp(MpegEncContext *s, int16_t block[6][64],
+static inline int get_b_cbp(MPVEncContext *s, int16_t block[6][64],
                             int motion_x, int motion_y, int mb_type)
 {
     int cbp = 0, i;
@@ -477,7 +477,7 @@ static inline int get_b_cbp(MpegEncContext *s, int16_t block[6][64],
 // FIXME this is duplicated to h263.c
 static const int dquant_code[5] = { 1, 0, 9, 2, 3 };
 
-void ff_mpeg4_encode_mb(MpegEncContext *s, int16_t block[6][64],
+void ff_mpeg4_encode_mb(MPVEncContext *s, int16_t block[6][64],
                         int motion_x, int motion_y)
 {
     int cbpc, cbpy, pred_x, pred_y;
@@ -875,7 +875,7 @@ void ff_mpeg4_stuffing(PutBitContext *pbc)
 }
 
 /* must be called before writing the header */
-void ff_set_mpeg4_time(MpegEncContext *s)
+void ff_set_mpeg4_time(MPVMainEncContext *s)
 {
     if (s->pict_type == AV_PICTURE_TYPE_B) {
         ff_mpeg4_init_direct_mv(s);
@@ -885,7 +885,7 @@ void ff_set_mpeg4_time(MpegEncContext *s)
     }
 }
 
-static void mpeg4_encode_gop_header(MpegEncContext *s)
+static void mpeg4_encode_gop_header(MPVMainEncContext *s)
 {
     int64_t hours, minutes, seconds;
     int64_t time;
@@ -915,7 +915,7 @@ static void mpeg4_encode_gop_header(MpegEncContext *s)
     ff_mpeg4_stuffing(&s->pb);
 }
 
-static void mpeg4_encode_visual_object_header(MpegEncContext *s)
+static void mpeg4_encode_visual_object_header(MPVMainEncContext *s)
 {
     int profile_and_level_indication;
     int vo_ver_id;
@@ -959,7 +959,7 @@ static void mpeg4_encode_visual_object_header(MpegEncContext *s)
     ff_mpeg4_stuffing(&s->pb);
 }
 
-static void mpeg4_encode_vol_header(MpegEncContext *s,
+static void mpeg4_encode_vol_header(MPVMainEncContext *s,
                                     int vo_number,
                                     int vol_number)
 {
@@ -1060,7 +1060,7 @@ static void mpeg4_encode_vol_header(MpegEncContext *s,
 }
 
 /* write MPEG-4 VOP header */
-int ff_mpeg4_encode_picture_header(MpegEncContext *s, int picture_number)
+int ff_mpeg4_encode_picture_header(MPVMainEncContext *s, int picture_number)
 {
     uint64_t time_incr;
     int64_t time_div, time_mod;
@@ -1283,7 +1283,7 @@ 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;
-    MpegEncContext *s = avctx->priv_data;
+    MPVMainEncContext *const s = avctx->priv_data;
     int ret;
 
     if (avctx->width >= (1<<13) || avctx->height >= (1<<13)) {
@@ -1324,7 +1324,7 @@ static av_cold int encode_init(AVCodecContext *avctx)
     return 0;
 }
 
-void ff_mpeg4_init_partitions(MpegEncContext *s)
+void ff_mpeg4_init_partitions(MPVEncContext *s)
 {
     uint8_t *start = put_bits_ptr(&s->pb);
     uint8_t *end   = s->pb.buf_end;
@@ -1337,7 +1337,7 @@ void ff_mpeg4_init_partitions(MpegEncContext *s)
     init_put_bits(&s->pb2, start + pb_size + tex_size, pb_size);
 }
 
-void ff_mpeg4_merge_partitions(MpegEncContext *s)
+void ff_mpeg4_merge_partitions(MPVEncContext *s)
 {
     const int pb2_len    = put_bits_count(&s->pb2);
     const int tex_pb_len = put_bits_count(&s->tex_pb);
@@ -1363,7 +1363,7 @@ void ff_mpeg4_merge_partitions(MpegEncContext *s)
     s->last_bits = put_bits_count(&s->pb);
 }
 
-void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
+void ff_mpeg4_encode_video_packet_header(MPVEncContext *s)
 {
     int mb_num_bits = av_log2(s->mb_num - 1) + 1;
 
@@ -1375,7 +1375,7 @@ void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
     put_bits(&s->pb, 1, 0); /* no HEC */
 }
 
-#define OFFSET(x) offsetof(MpegEncContext, x)
+#define OFFSET(x) offsetof(MPVMainEncContext, 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 },
@@ -1404,7 +1404,7 @@ const AVCodec ff_mpeg4_encoder = {
     .long_name      = NULL_IF_CONFIG_SMALL("MPEG-4 part 2"),
     .type           = AVMEDIA_TYPE_VIDEO,
     .id             = AV_CODEC_ID_MPEG4,
-    .priv_data_size = sizeof(MpegEncContext),
+    .priv_data_size = sizeof(MPVMainEncContext),
     .init           = encode_init,
     .encode2        = ff_mpv_encode_picture,
     .close          = ff_mpv_encode_end,
diff --git a/libavcodec/mpeg_er.c b/libavcodec/mpeg_er.c
index f54cb8548b..bdbcea7ccd 100644
--- a/libavcodec/mpeg_er.c
+++ b/libavcodec/mpeg_er.c
@@ -43,7 +43,7 @@ static void set_erpic(ERPicture *dst, Picture *src)
     dst->field_picture = src->field_picture;
 }
 
-void ff_mpeg_er_frame_start(MpegEncContext *s)
+void ff_mpeg_er_frame_start(MPVMainDecContext *s)
 {
     ERContext *er = &s->er;
 
@@ -63,7 +63,7 @@ static void mpeg_er_decode_mb(void *opaque, int ref, int mv_dir, int mv_type,
                               int (*mv)[2][4][2], int mb_x, int mb_y,
                               int mb_intra, int mb_skipped)
 {
-    MpegEncContext *s = opaque;
+    MPVDecContext *const s = opaque;
 
     s->mv_dir     = mv_dir;
     s->mv_type    = mv_type;
@@ -97,7 +97,7 @@ static void mpeg_er_decode_mb(void *opaque, int ref, int mv_dir, int mv_type,
     ff_mpv_reconstruct_mb(s, s->block);
 }
 
-int ff_mpeg_er_init(MpegEncContext *s)
+int ff_mpeg_er_init(MPVDecContext *s)
 {
     ERContext *er = &s->er;
     int mb_array_size = s->mb_height * s->mb_stride;
diff --git a/libavcodec/mpeg_er.h b/libavcodec/mpeg_er.h
index bb627a4d06..b3c284c9a3 100644
--- a/libavcodec/mpeg_er.h
+++ b/libavcodec/mpeg_er.h
@@ -21,7 +21,7 @@
 
 #include "mpegvideo.h"
 
-int ff_mpeg_er_init(MpegEncContext *s);
-void ff_mpeg_er_frame_start(MpegEncContext *s);
+int ff_mpeg_er_init(MPVDecContext *s);
+void ff_mpeg_er_frame_start(MPVMainDecContext *s);
 
 #endif /* AVCODEC_MPEG_ER_H */
diff --git a/libavcodec/mpegvideo.c b/libavcodec/mpegvideo.c
index bbcf00b014..500f8af19d 100644
--- a/libavcodec/mpegvideo.c
+++ b/libavcodec/mpegvideo.c
@@ -47,7 +47,7 @@
 #include "wmv2.h"
 #include <limits.h>
 
-static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
+static void dct_unquantize_mpeg1_intra_c(MPVContext *s,
                                    int16_t *block, int n, int qscale)
 {
     int i, level, nCoeffs;
@@ -76,7 +76,7 @@ static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
     }
 }
 
-static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
+static void dct_unquantize_mpeg1_inter_c(MPVContext *s,
                                    int16_t *block, int n, int qscale)
 {
     int i, level, nCoeffs;
@@ -105,7 +105,7 @@ static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
     }
 }
 
-static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
+static void dct_unquantize_mpeg2_intra_c(MPVContext *s,
                                    int16_t *block, int n, int qscale)
 {
     int i, level, nCoeffs;
@@ -135,7 +135,7 @@ static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
     }
 }
 
-static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
+static void dct_unquantize_mpeg2_intra_bitexact(MPVContext *s,
                                    int16_t *block, int n, int qscale)
 {
     int i, level, nCoeffs;
@@ -169,7 +169,7 @@ static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
     block[63]^=sum&1;
 }
 
-static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
+static void dct_unquantize_mpeg2_inter_c(MPVContext *s,
                                    int16_t *block, int n, int qscale)
 {
     int i, level, nCoeffs;
@@ -203,7 +203,7 @@ static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
     block[63]^=sum&1;
 }
 
-static void dct_unquantize_h263_intra_c(MpegEncContext *s,
+static void dct_unquantize_h263_intra_c(MPVContext *s,
                                   int16_t *block, int n, int qscale)
 {
     int i, level, qmul, qadd;
@@ -237,7 +237,7 @@ static void dct_unquantize_h263_intra_c(MpegEncContext *s,
     }
 }
 
-static void dct_unquantize_h263_inter_c(MpegEncContext *s,
+static void dct_unquantize_h263_inter_c(MPVContext *s,
                                   int16_t *block, int n, int qscale)
 {
     int i, level, qmul, qadd;
@@ -277,7 +277,7 @@ static void gray8(uint8_t *dst, const uint8_t *src, ptrdiff_t linesize, int h)
 }
 
 /* init common dct for both encoder and decoder */
-static av_cold int dct_init(MpegEncContext *s)
+static av_cold int dct_init(MPVMainContext *s)
 {
     ff_blockdsp_init(&s->bdsp, s->avctx);
     ff_h264chroma_init(&s->h264chroma, 8); //for lowres
@@ -324,7 +324,7 @@ static av_cold int dct_init(MpegEncContext *s)
     return 0;
 }
 
-av_cold void ff_mpv_idct_init(MpegEncContext *s)
+av_cold void ff_mpv_idct_init(MPVMainContext *s)
 {
     if (s->codec_id == AV_CODEC_ID_MPEG4)
         s->idsp.mpeg4_studio_profile = s->studio_profile;
@@ -344,7 +344,7 @@ av_cold void ff_mpv_idct_init(MpegEncContext *s)
     ff_init_scantable(s->idsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
 }
 
-static int init_duplicate_context(MpegEncContext *s)
+static int init_duplicate_context(MPVContext *s)
 {
     int y_size = s->b8_stride * (2 * s->mb_height + 1);
     int c_size = s->mb_stride * (s->mb_height + 1);
@@ -389,7 +389,7 @@ static int init_duplicate_context(MpegEncContext *s)
     return 0;
 }
 
-int ff_mpv_init_duplicate_contexts(MpegEncContext *s)
+int ff_mpv_init_duplicate_contexts(MPVMainContext *s)
 {
     int nb_slices = s->slice_context_count, ret;
 
@@ -397,7 +397,7 @@ int ff_mpv_init_duplicate_contexts(MpegEncContext *s)
      * fields allocated in init_duplicate_context are NULL after
      * copying. This prevents double-frees upon allocation error. */
     for (int i = 1; i < nb_slices; i++) {
-        s->thread_context[i] = av_memdup(s, sizeof(MpegEncContext));
+        s->thread_context[i] = av_memdup(s, sizeof(MPVContext));
         if (!s->thread_context[i])
             return AVERROR(ENOMEM);
         if ((ret = init_duplicate_context(s->thread_context[i])) < 0)
@@ -413,7 +413,7 @@ int ff_mpv_init_duplicate_contexts(MpegEncContext *s)
     return init_duplicate_context(s);
 }
 
-static void free_duplicate_context(MpegEncContext *s)
+static void free_duplicate_context(MPVContext *s)
 {
     if (!s)
         return;
@@ -433,7 +433,7 @@ static void free_duplicate_context(MpegEncContext *s)
     s->block = NULL;
 }
 
-static void free_duplicate_contexts(MpegEncContext *s)
+static void free_duplicate_contexts(MPVMainContext *s)
 {
     for (int i = 1; i < s->slice_context_count; i++) {
         free_duplicate_context(s->thread_context[i]);
@@ -442,7 +442,7 @@ static void free_duplicate_contexts(MpegEncContext *s)
     free_duplicate_context(s);
 }
 
-static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src)
+static void backup_duplicate_context(MPVContext *bak, MPVContext *src)
 {
 #define COPY(a) bak->a = src->a
     COPY(sc.edge_emu_buffer);
@@ -469,13 +469,13 @@ static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src)
 #undef COPY
 }
 
-int ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src)
+int ff_update_duplicate_context(MPVContext *dst, MPVContext *src)
 {
-    MpegEncContext bak;
+    MPVContext bak;
     int i, ret;
     // FIXME copy only needed parts
     backup_duplicate_context(&bak, dst);
-    memcpy(dst, src, sizeof(MpegEncContext));
+    memcpy(dst, src, sizeof(*dst));
     backup_duplicate_context(dst, &bak);
     for (i = 0; i < 12; i++) {
         dst->pblocks[i] = &dst->block[i];
@@ -495,12 +495,12 @@ int ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src)
 }
 
 /**
- * Set the given MpegEncContext to common defaults
+ * Set the given MPVMainContext to common defaults
  * (same for encoding and decoding).
  * The changed fields will not depend upon the
- * prior state of the MpegEncContext.
+ * prior state of the MPVMainContext.
  */
-void ff_mpv_common_defaults(MpegEncContext *s)
+void ff_mpv_common_defaults(MPVMainContext *s)
 {
     s->y_dc_scale_table      =
     s->c_dc_scale_table      = ff_mpeg1_dc_scale_table;
@@ -518,7 +518,7 @@ void ff_mpv_common_defaults(MpegEncContext *s)
     s->slice_context_count   = 1;
 }
 
-int ff_mpv_init_context_frame(MpegEncContext *s)
+int ff_mpv_init_context_frame(MPVContext *s)
 {
     int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
 
@@ -652,7 +652,7 @@ int ff_mpv_init_context_frame(MpegEncContext *s)
     return !CONFIG_MPEGVIDEODEC || s->encoding ? 0 : ff_mpeg_er_init(s);
 }
 
-static void clear_context(MpegEncContext *s)
+static void clear_context(MPVMainContext *s)
 {
     int i, j, k;
 
@@ -731,7 +731,7 @@ static void clear_context(MpegEncContext *s)
  * init common structure for both encoder and decoder.
  * this assumes that some variables like width/height are already set
  */
-av_cold int ff_mpv_common_init(MpegEncContext *s)
+av_cold int ff_mpv_common_init(MPVMainContext *s)
 {
     int i, ret;
     int nb_slices = (HAVE_THREADS &&
@@ -818,7 +818,7 @@ av_cold int ff_mpv_common_init(MpegEncContext *s)
     return ret;
 }
 
-void ff_mpv_free_context_frame(MpegEncContext *s)
+void ff_mpv_free_context_frame(MPVMainContext *s)
 {
     int i, j, k;
 
@@ -872,7 +872,7 @@ void ff_mpv_free_context_frame(MpegEncContext *s)
 }
 
 /* init common structure for both encoder and decoder */
-void ff_mpv_common_end(MpegEncContext *s)
+void ff_mpv_common_end(MPVMainContext *s)
 {
     if (!s)
         return;
@@ -911,7 +911,7 @@ void ff_mpv_common_end(MpegEncContext *s)
 }
 
 
-static inline int hpel_motion_lowres(MpegEncContext *s,
+static inline int hpel_motion_lowres(MPVContext *s,
                                      uint8_t *dest, uint8_t *src,
                                      int field_based, int field_select,
                                      int src_x, int src_y,
@@ -958,7 +958,7 @@ static inline int hpel_motion_lowres(MpegEncContext *s,
 }
 
 /* apply one mpeg motion vector to the three components */
-static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
+static av_always_inline void mpeg_motion_lowres(MPVContext *s,
                                                 uint8_t *dest_y,
                                                 uint8_t *dest_cb,
                                                 uint8_t *dest_cr,
@@ -1097,7 +1097,7 @@ static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
     // FIXME h261 lowres loop filter
 }
 
-static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
+static inline void chroma_4mv_motion_lowres(MPVContext *s,
                                             uint8_t *dest_cb, uint8_t *dest_cr,
                                             uint8_t **ref_picture,
                                             h264_chroma_mc_func * pix_op,
@@ -1165,7 +1165,7 @@ static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
  * @param pix_op halfpel motion compensation function (average or put normally)
  * the motion vectors are taken from s->mv and the MV type from s->mv_type
  */
-static inline void MPV_motion_lowres(MpegEncContext *s,
+static inline void MPV_motion_lowres(MPVContext *s,
                                      uint8_t *dest_y, uint8_t *dest_cb,
                                      uint8_t *dest_cr,
                                      int dir, uint8_t **ref_picture,
@@ -1299,7 +1299,7 @@ static inline void MPV_motion_lowres(MpegEncContext *s,
 /**
  * find the lowest MB row referenced in the MVs
  */
-static int lowest_referenced_row(MpegEncContext *s, int dir)
+static int lowest_referenced_row(MPVContext *s, int dir)
 {
     int my_max = INT_MIN, my_min = INT_MAX, qpel_shift = !s->quarter_sample;
     int my, off, i, mvs;
@@ -1335,7 +1335,7 @@ unhandled:
 }
 
 /* put block[] to dest[] */
-static inline void put_dct(MpegEncContext *s,
+static inline void put_dct(MPVContext *s,
                            int16_t *block, int i, uint8_t *dest, int line_size, int qscale)
 {
     s->dct_unquantize_intra(s, block, i, qscale);
@@ -1343,7 +1343,7 @@ static inline void put_dct(MpegEncContext *s,
 }
 
 /* add block[] to dest[] */
-static inline void add_dct(MpegEncContext *s,
+static inline void add_dct(MPVContext *s,
                            int16_t *block, int i, uint8_t *dest, int line_size)
 {
     if (s->block_last_index[i] >= 0) {
@@ -1351,7 +1351,7 @@ static inline void add_dct(MpegEncContext *s,
     }
 }
 
-static inline void add_dequant_dct(MpegEncContext *s,
+static inline void add_dequant_dct(MPVContext *s,
                            int16_t *block, int i, uint8_t *dest, int line_size, int qscale)
 {
     if (s->block_last_index[i] >= 0) {
@@ -1364,7 +1364,7 @@ static inline void add_dequant_dct(MpegEncContext *s,
 /**
  * Clean dc, ac, coded_block for the current non-intra MB.
  */
-void ff_clean_intra_table_entries(MpegEncContext *s)
+void ff_clean_intra_table_entries(MPVContext *s)
 {
     int wrap = s->b8_stride;
     int xy = s->block_index[0];
@@ -1405,7 +1405,7 @@ void ff_clean_intra_table_entries(MpegEncContext *s)
    s->interlaced_dct : true if interlaced dct used (mpeg2)
  */
 static av_always_inline
-void mpv_reconstruct_mb_internal(MpegEncContext *s, int16_t block[12][64],
+void mpv_reconstruct_mb_internal(MPVContext *s, int16_t block[12][64],
                             int lowres_flag, int is_mpeg12)
 {
 #define IS_ENCODER(s) (CONFIG_MPEGVIDEOENC && !lowres_flag && (s)->encoding)
@@ -1642,7 +1642,7 @@ skip_idct:
     }
 }
 
-void ff_mpv_reconstruct_mb(MpegEncContext *s, int16_t block[12][64])
+void ff_mpv_reconstruct_mb(MPVContext *s, int16_t block[12][64])
 {
     if (CONFIG_XVMC &&
         s->avctx->hwaccel && s->avctx->hwaccel->decode_mb) {
@@ -1672,7 +1672,8 @@ void ff_mpv_reconstruct_mb(MpegEncContext *s, int16_t block[12][64])
     else                  mpv_reconstruct_mb_internal(s, block, 0, 0);
 }
 
-void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
+void ff_init_block_index(MPVContext *s) //FIXME maybe rename
+{
     const int linesize   = s->current_picture.f->linesize[0]; //not s->linesize as this would be wrong for field pics
     const int uvlinesize = s->current_picture.f->linesize[1];
     const int width_of_mb = (4 + (s->avctx->bits_per_raw_sample > 8)) - s->avctx->lowres;
@@ -1708,7 +1709,7 @@ void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
 /**
  * set qscale and update qscale dependent variables.
  */
-void ff_set_qscale(MpegEncContext * s, int qscale)
+void ff_set_qscale(MPVContext *s, int qscale)
 {
     if (qscale < 1)
         qscale = 1;
diff --git a/libavcodec/mpegvideo.h b/libavcodec/mpegvideo.h
index 8f65f53c2a..1bad288ea5 100644
--- a/libavcodec/mpegvideo.h
+++ b/libavcodec/mpegvideo.h
@@ -60,9 +60,9 @@
 #define MAX_B_FRAMES 16
 
 /**
- * MpegEncContext.
+ * MPVContext.
  */
-typedef struct MpegEncContext {
+typedef struct MPVContext {
     AVClass *class;
 
     int y_dc_scale, c_dc_scale;
@@ -139,7 +139,7 @@ typedef struct MpegEncContext {
 
     int start_mb_y;            ///< start mb_y of this thread (so current thread should process start_mb_y <= row < end_mb_y)
     int end_mb_y;              ///< end   mb_y of this thread (so current thread should process start_mb_y <= row < end_mb_y)
-    struct MpegEncContext *thread_context[MAX_THREADS];
+    struct MPVContext *thread_context[MAX_THREADS];
     int slice_context_count;   ///< number of used thread_contexts
 
     /**
@@ -474,32 +474,32 @@ typedef struct MpegEncContext {
 
     int16_t (*block)[64]; ///< points to one of the following blocks
     int16_t (*blocks)[12][64]; // for HQ mode we need to keep the best block
-    int (*decode_mb)(struct MpegEncContext *s, int16_t block[12][64]); // used by some codecs to avoid a switch()
+    int (*decode_mb)(struct MPVContext *s, int16_t block[12][64]); // used by some codecs to avoid a switch()
 
 #define SLICE_OK         0
 #define SLICE_ERROR     -1
 #define SLICE_END       -2 ///<end marker found
 #define SLICE_NOEND     -3 ///<no end marker or error found but mb count exceeded
 
-    void (*dct_unquantize_mpeg1_intra)(struct MpegEncContext *s,
+    void (*dct_unquantize_mpeg1_intra)(struct MPVContext *s,
                            int16_t *block/*align 16*/, int n, int qscale);
-    void (*dct_unquantize_mpeg1_inter)(struct MpegEncContext *s,
+    void (*dct_unquantize_mpeg1_inter)(struct MPVContext *s,
                            int16_t *block/*align 16*/, int n, int qscale);
-    void (*dct_unquantize_mpeg2_intra)(struct MpegEncContext *s,
+    void (*dct_unquantize_mpeg2_intra)(struct MPVContext *s,
                            int16_t *block/*align 16*/, int n, int qscale);
-    void (*dct_unquantize_mpeg2_inter)(struct MpegEncContext *s,
+    void (*dct_unquantize_mpeg2_inter)(struct MPVContext *s,
                            int16_t *block/*align 16*/, int n, int qscale);
-    void (*dct_unquantize_h263_intra)(struct MpegEncContext *s,
+    void (*dct_unquantize_h263_intra)(struct MPVContext *s,
                            int16_t *block/*align 16*/, int n, int qscale);
-    void (*dct_unquantize_h263_inter)(struct MpegEncContext *s,
+    void (*dct_unquantize_h263_inter)(struct MPVContext *s,
                            int16_t *block/*align 16*/, int n, int qscale);
-    void (*dct_unquantize_intra)(struct MpegEncContext *s, // unquantizer to use (MPEG-4 can use both)
+    void (*dct_unquantize_intra)(struct MPVContext *s, // unquantizer to use (MPEG-4 can use both)
                            int16_t *block/*align 16*/, int n, int qscale);
-    void (*dct_unquantize_inter)(struct MpegEncContext *s, // unquantizer to use (MPEG-4 can use both)
+    void (*dct_unquantize_inter)(struct MPVContext *s, // unquantizer to use (MPEG-4 can use both)
                            int16_t *block/*align 16*/, int n, int qscale);
-    int (*dct_quantize)(struct MpegEncContext *s, int16_t *block/*align 16*/, int n, int qscale, int *overflow);
-    int (*fast_dct_quantize)(struct MpegEncContext *s, int16_t *block/*align 16*/, int n, int qscale, int *overflow);
-    void (*denoise_dct)(struct MpegEncContext *s, int16_t *block);
+    int (*dct_quantize)(struct MPVContext *s, int16_t *block/*align 16*/, int n, int qscale, int *overflow);
+    int (*fast_dct_quantize)(struct MPVContext *s, int16_t *block/*align 16*/, int n, int qscale, int *overflow);
+    void (*denoise_dct)(struct MPVContext *s, int16_t *block);
 
     int mpv_flags;      ///< flags set by private options
     int quantizer_noise_shaping;
@@ -549,79 +549,83 @@ typedef struct MpegEncContext {
 #if FF_API_MPEGVIDEO_OPTS || FF_API_MJPEG_PRED
     int dummy;               ///< used as target for deprecated options
 #endif
-} MpegEncContext;
+} MPVContext;
 
+typedef MPVContext MPVDecContext;
+typedef MPVContext MPVMainContext;
+typedef MPVContext MPVMainDecContext;
 
 /**
- * Set the given MpegEncContext to common defaults (same for encoding
+ * Set the given MPVContext to common defaults (same for encoding
  * and decoding).  The changed fields will not depend upon the prior
- * state of the MpegEncContext.
+ * state of the MPVContext.
  */
-void ff_mpv_common_defaults(MpegEncContext *s);
-
-int ff_mpv_common_init(MpegEncContext *s);
-void ff_mpv_common_init_arm(MpegEncContext *s);
-void ff_mpv_common_init_axp(MpegEncContext *s);
-void ff_mpv_common_init_neon(MpegEncContext *s);
-void ff_mpv_common_init_ppc(MpegEncContext *s);
-void ff_mpv_common_init_x86(MpegEncContext *s);
-void ff_mpv_common_init_mips(MpegEncContext *s);
+void ff_mpv_common_defaults(MPVMainContext *s);
+
+int ff_mpv_common_init(MPVMainContext *s);
+void ff_mpv_common_init_arm(MPVMainContext *s);
+void ff_mpv_common_init_axp(MPVMainContext *s);
+void ff_mpv_common_init_neon(MPVMainContext *s);
+void ff_mpv_common_init_ppc(MPVMainContext *s);
+void ff_mpv_common_init_x86(MPVMainContext *s);
+void ff_mpv_common_init_mips(MPVMainContext *s);
 /**
- * Initialize an MpegEncContext's thread contexts. Presumes that
+ * Initialize an MPVContext's thread contexts. Presumes that
  * slice_context_count is already set and that all the fields
  * that are freed/reset in free_duplicate_context() are NULL.
  */
-int ff_mpv_init_duplicate_contexts(MpegEncContext *s);
+int ff_mpv_init_duplicate_contexts(MPVContext *s);
 /**
- * Initialize and allocates MpegEncContext fields dependent on the resolution.
+ * Initialize and allocates MPVContext fields dependent on the resolution.
  */
-int ff_mpv_init_context_frame(MpegEncContext *s);
+int ff_mpv_init_context_frame(MPVContext *s);
 /**
- * Frees and resets MpegEncContext fields depending on the resolution
+ * Frees and resets MPVContext fields depending on the resolution
  * as well as the slice thread contexts.
  * Is used during resolution changes to avoid a full reinitialization of the
  * codec.
  */
-void ff_mpv_free_context_frame(MpegEncContext *s);
+void ff_mpv_free_context_frame(MPVContext *s);
 
-int ff_mpv_common_frame_size_change(MpegEncContext *s);
-void ff_mpv_common_end(MpegEncContext *s);
+int ff_mpv_common_frame_size_change(MPVContext *s);
+void ff_mpv_common_end(MPVMainContext *s);
 
 /**
- * Initialize the given MpegEncContext for decoding.
+ * Initialize the given MPVContext for decoding.
  * the changed fields will not depend upon
- * the prior state of the MpegEncContext.
+ * the prior state of the MPVContext.
  */
-void ff_mpv_decode_init(MpegEncContext *s, AVCodecContext *avctx);
-void ff_mpv_reconstruct_mb(MpegEncContext *s, int16_t block[12][64]);
-void ff_mpv_report_decode_progress(MpegEncContext *s);
+void ff_mpv_decode_init(MPVMainDecContext *s, AVCodecContext *avctx);
+void ff_mpv_reconstruct_mb(MPVDecContext *s, int16_t block[12][64]);
+void ff_mpv_report_decode_progress(MPVDecContext *s);
 
-int ff_mpv_frame_start(MpegEncContext *s, AVCodecContext *avctx);
-void ff_mpv_frame_end(MpegEncContext *s);
+int ff_mpv_frame_start(MPVContext *s, AVCodecContext *avctx);
+void ff_mpv_frame_end(MPVContext *s);
 
-void ff_clean_intra_table_entries(MpegEncContext *s);
-void ff_mpeg_draw_horiz_band(MpegEncContext *s, int y, int h);
+void ff_clean_intra_table_entries(MPVContext *s);
+void ff_mpeg_draw_horiz_band(MPVContext *s, int y, int h);
 void ff_mpeg_flush(AVCodecContext *avctx);
 
-void ff_print_debug_info(MpegEncContext *s, Picture *p, AVFrame *pict);
+void ff_print_debug_info(MPVContext *s, Picture *p, AVFrame *pict);
 
-int ff_mpv_export_qp_table(MpegEncContext *s, AVFrame *f, Picture *p, int qp_type);
+int ff_mpv_export_qp_table(MPVContext *s, AVFrame *f, Picture *p, int qp_type);
 
-int ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src);
+int ff_update_duplicate_context(MPVMainDecContext *dst, MPVMainDecContext *src);
 int ff_mpeg_update_thread_context(AVCodecContext *dst, const AVCodecContext *src);
-void ff_set_qscale(MpegEncContext * s, int qscale);
+void ff_set_qscale(MPVContext * s, int qscale);
 
-void ff_mpv_idct_init(MpegEncContext *s);
-void ff_init_block_index(MpegEncContext *s);
+void ff_mpv_idct_init(MPVContext *s);
+void ff_init_block_index(MPVContext *s);
 
-void ff_mpv_motion(MpegEncContext *s,
+void ff_mpv_motion(MPVContext *s,
                    uint8_t *dest_y, uint8_t *dest_cb,
                    uint8_t *dest_cr, int dir,
                    uint8_t **ref_picture,
                    op_pixels_func (*pix_op)[4],
                    qpel_mc_func (*qpix_op)[16]);
 
-static inline void ff_update_block_index(MpegEncContext *s){
+static inline void ff_update_block_index(MPVContext *s)
+{
     const int bytes_per_pixel = 1 + (s->avctx->bits_per_raw_sample > 8);
     const int block_size= (8*bytes_per_pixel) >> s->avctx->lowres;
 
@@ -636,7 +640,7 @@ static inline void ff_update_block_index(MpegEncContext *s){
     s->dest[2]+= (2 >> s->chroma_x_shift) * block_size;
 }
 
-static inline int mpeg_get_qscale(MpegEncContext *s)
+static inline int mpeg_get_qscale(MPVContext *s)
 {
     int qscale = get_bits(&s->gb, 5);
     if (s->q_scale_type)
diff --git a/libavcodec/mpegvideo_dec.c b/libavcodec/mpegvideo_dec.c
index dc38f6b267..4be0c3ad8a 100644
--- a/libavcodec/mpegvideo_dec.c
+++ b/libavcodec/mpegvideo_dec.c
@@ -33,7 +33,7 @@
 #include "mpegvideo.h"
 #include "thread.h"
 
-void ff_mpv_decode_init(MpegEncContext *s, AVCodecContext *avctx)
+void ff_mpv_decode_init(MPVMainDecContext *s, AVCodecContext *avctx)
 {
     ff_mpv_common_defaults(s);
 
@@ -50,8 +50,8 @@ void ff_mpv_decode_init(MpegEncContext *s, AVCodecContext *avctx)
 int ff_mpeg_update_thread_context(AVCodecContext *dst,
                                   const AVCodecContext *src)
 {
-    MpegEncContext *const s1 = src->priv_data;
-    MpegEncContext *const s  = dst->priv_data;
+    MPVMainDecContext *const s1 = src->priv_data;
+    MPVMainDecContext *const s  = dst->priv_data;
     int ret;
 
     if (dst == src)
@@ -189,7 +189,7 @@ do {\
     return 0;
 }
 
-int ff_mpv_common_frame_size_change(MpegEncContext *s)
+int ff_mpv_common_frame_size_change(MPVMainDecContext *s)
 {
     int err = 0;
 
@@ -243,7 +243,7 @@ int ff_mpv_common_frame_size_change(MpegEncContext *s)
     return err;
 }
 
-static int alloc_picture(MpegEncContext *s, Picture *pic)
+static int alloc_picture(MPVMainDecContext *s, Picture *pic)
 {
     return ff_alloc_picture(s->avctx, pic, &s->me, &s->sc, 0, 0,
                             s->chroma_x_shift, s->chroma_y_shift, s->out_format,
@@ -271,7 +271,7 @@ static void gray_frame(AVFrame *frame)
  * generic function called after decoding
  * the header and before a frame is decoded.
  */
-int ff_mpv_frame_start(MpegEncContext *s, AVCodecContext *avctx)
+int ff_mpv_frame_start(MPVMainDecContext *s, AVCodecContext *avctx)
 {
     Picture *pic;
     int idx, ret;
@@ -495,7 +495,7 @@ int ff_mpv_frame_start(MpegEncContext *s, AVCodecContext *avctx)
 }
 
 /* called after a frame has been decoded. */
-void ff_mpv_frame_end(MpegEncContext *s)
+void ff_mpv_frame_end(MPVMainDecContext *s)
 {
     emms_c();
 
@@ -503,14 +503,14 @@ void ff_mpv_frame_end(MpegEncContext *s)
         ff_thread_report_progress(&s->current_picture_ptr->tf, INT_MAX, 0);
 }
 
-void ff_print_debug_info(MpegEncContext *s, Picture *p, AVFrame *pict)
+void ff_print_debug_info(MPVMainDecContext *s, Picture *p, AVFrame *pict)
 {
     ff_print_debug_info2(s->avctx, pict, s->mbskip_table, p->mb_type,
                          p->qscale_table, p->motion_val,
                          s->mb_width, s->mb_height, s->mb_stride, s->quarter_sample);
 }
 
-int ff_mpv_export_qp_table(MpegEncContext *s, AVFrame *f, Picture *p, int qp_type)
+int ff_mpv_export_qp_table(MPVMainDecContext *s, AVFrame *f, Picture *p, int qp_type)
 {
     AVVideoEncParams *par;
     int mult = (qp_type == FF_QSCALE_TYPE_MPEG1) ? 2 : 1;
@@ -540,7 +540,7 @@ int ff_mpv_export_qp_table(MpegEncContext *s, AVFrame *f, Picture *p, int qp_typ
     return 0;
 }
 
-void ff_mpeg_draw_horiz_band(MpegEncContext *s, int y, int h)
+void ff_mpeg_draw_horiz_band(MPVDecContext *s, int y, int h)
 {
     ff_draw_horiz_band(s->avctx, s->current_picture_ptr->f,
                        s->last_picture_ptr ? s->last_picture_ptr->f : NULL,
@@ -550,7 +550,7 @@ void ff_mpeg_draw_horiz_band(MpegEncContext *s, int y, int h)
 
 void ff_mpeg_flush(AVCodecContext *avctx)
 {
-    MpegEncContext *const s = avctx->priv_data;
+    MPVMainDecContext *const s = avctx->priv_data;
 
     if (!s->picture)
         return;
@@ -577,7 +577,7 @@ void ff_mpeg_flush(AVCodecContext *avctx)
     s->pp_time = 0;
 }
 
-void ff_mpv_report_decode_progress(MpegEncContext *s)
+void ff_mpv_report_decode_progress(MPVDecContext *s)
 {
     if (s->pict_type != AV_PICTURE_TYPE_B && !s->partitioned_frame && !s->er.error_occurred)
         ff_thread_report_progress(&s->current_picture_ptr->tf, s->mb_y, 0);
diff --git a/libavcodec/mpegvideo_enc.c b/libavcodec/mpegvideo_enc.c
index a76b4b9f60..02efc9c2e9 100644
--- a/libavcodec/mpegvideo_enc.c
+++ b/libavcodec/mpegvideo_enc.c
@@ -80,11 +80,11 @@
 #define QMAT_SHIFT_MMX 16
 #define QMAT_SHIFT 21
 
-static int encode_picture(MpegEncContext *s, int picture_number);
-static int dct_quantize_refine(MpegEncContext *s, int16_t *block, int16_t *weight, int16_t *orig, int n, int qscale);
-static int sse_mb(MpegEncContext *s);
-static void denoise_dct_c(MpegEncContext *s, int16_t *block);
-static int dct_quantize_trellis_c(MpegEncContext *s, int16_t *block, int n, int qscale, int *overflow);
+static int encode_picture(MPVMainEncContext *s, int picture_number);
+static int dct_quantize_refine(MPVEncContext *s, int16_t *block, int16_t *weight, int16_t *orig, int n, int qscale);
+static int sse_mb(MPVEncContext *s);
+static void denoise_dct_c(MPVEncContext *s, int16_t *block);
+static int dct_quantize_trellis_c(MPVEncContext *s, int16_t *block, int n, int qscale, int *overflow);
 
 static uint8_t default_mv_penalty[MAX_FCODE + 1][MAX_DMV * 2 + 1];
 static uint8_t default_fcode_tab[MAX_MV * 2 + 1];
@@ -107,7 +107,7 @@ const AVClass ff_mpv_enc_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-void ff_convert_matrix(MpegEncContext *s, int (*qmat)[64],
+void ff_convert_matrix(MPVEncContext *s, int (*qmat)[64],
                        uint16_t (*qmat16)[2][64],
                        const uint16_t *quant_matrix,
                        int bias, int qmin, int qmax, int intra)
@@ -191,7 +191,7 @@ void ff_convert_matrix(MpegEncContext *s, int (*qmat)[64],
     }
 }
 
-static inline void update_qscale(MpegEncContext *s)
+static inline void update_qscale(MPVEncContext *s)
 {
     if (s->q_scale_type == 1 && 0) {
         int i;
@@ -235,7 +235,7 @@ 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(MpegEncContext *s)
+void ff_init_qscale_tab(MPVMainEncContext *s)
 {
     int8_t * const qscale_table = s->current_picture.qscale_table;
     int i;
@@ -248,8 +248,8 @@ void ff_init_qscale_tab(MpegEncContext *s)
     }
 }
 
-static void update_duplicate_context_after_me(MpegEncContext *dst,
-                                              MpegEncContext *src)
+static void update_duplicate_context_after_me(MPVEncContext *dst,
+                                              MPVEncContext *src)
 {
 #define COPY(a) dst->a= src->a
     COPY(pict_type);
@@ -273,10 +273,10 @@ static void mpv_encode_init_static(void)
 }
 
 /**
- * Set the given MpegEncContext to defaults for encoding.
- * the changed fields will not depend upon the prior state of the MpegEncContext.
+ * 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(MpegEncContext *s)
+static void mpv_encode_defaults(MPVMainEncContext *s)
 {
     static AVOnce init_static_once = AV_ONCE_INIT;
 
@@ -291,7 +291,7 @@ static void mpv_encode_defaults(MpegEncContext *s)
     s->picture_in_gop_number = 0;
 }
 
-av_cold int ff_dct_encode_init(MpegEncContext *s)
+av_cold int ff_dct_encode_init(MPVEncContext *s)
 {
     if (ARCH_X86)
         ff_dct_encode_init_x86(s);
@@ -312,7 +312,7 @@ av_cold int ff_dct_encode_init(MpegEncContext *s)
 /* init video encoder */
 av_cold int ff_mpv_encode_init(AVCodecContext *avctx)
 {
-    MpegEncContext *s = avctx->priv_data;
+    MPVMainEncContext *const s = avctx->priv_data;
     AVCPBProperties *cpb_props;
     int i, ret;
 
@@ -927,7 +927,7 @@ av_cold int ff_mpv_encode_init(AVCodecContext *avctx)
 
 av_cold int ff_mpv_encode_end(AVCodecContext *avctx)
 {
-    MpegEncContext *s = avctx->priv_data;
+    MPVMainEncContext *const s = avctx->priv_data;
     int i;
 
     ff_rate_control_uninit(s);
@@ -970,7 +970,7 @@ static int get_sae(uint8_t *src, int ref, int stride)
     return acc;
 }
 
-static int get_intra_count(MpegEncContext *s, uint8_t *src,
+static int get_intra_count(MPVMainEncContext *s, uint8_t *src,
                            uint8_t *ref, int stride)
 {
     int x, y, w, h;
@@ -993,7 +993,7 @@ static int get_intra_count(MpegEncContext *s, uint8_t *src,
     return acc;
 }
 
-static int alloc_picture(MpegEncContext *s, Picture *pic, int shared)
+static int alloc_picture(MPVMainEncContext *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,
@@ -1001,7 +1001,7 @@ static int alloc_picture(MpegEncContext *s, Picture *pic, int shared)
                             &s->linesize, &s->uvlinesize);
 }
 
-static int load_input_picture(MpegEncContext *s, const AVFrame *pic_arg)
+static int load_input_picture(MPVMainEncContext *s, const AVFrame *pic_arg)
 {
     Picture *pic = NULL;
     int64_t pts;
@@ -1152,7 +1152,7 @@ static int load_input_picture(MpegEncContext *s, const AVFrame *pic_arg)
     return 0;
 }
 
-static int skip_check(MpegEncContext *s, Picture *p, Picture *ref)
+static int skip_check(MPVMainEncContext *s, Picture *p, Picture *ref)
 {
     int x, y, plane;
     int score = 0;
@@ -1214,7 +1214,7 @@ static int encode_frame(AVCodecContext *c, AVFrame *frame, AVPacket *pkt)
     return size;
 }
 
-static int estimate_best_b_count(MpegEncContext *s)
+static int estimate_best_b_count(MPVMainEncContext *s)
 {
     const AVCodec *codec = avcodec_find_encoder(s->avctx->codec_id);
     AVPacket *pkt;
@@ -1361,7 +1361,7 @@ fail:
     return best_b_count;
 }
 
-static int select_input_picture(MpegEncContext *s)
+static int select_input_picture(MPVMainEncContext *s)
 {
     int i, ret;
 
@@ -1538,7 +1538,7 @@ no_output_pic:
     return 0;
 }
 
-static void frame_end(MpegEncContext *s)
+static void frame_end(MPVMainEncContext *s)
 {
     if (s->unrestricted_mv &&
         s->current_picture.reference &&
@@ -1575,7 +1575,7 @@ static void frame_end(MpegEncContext *s)
         s->last_non_b_pict_type = s->pict_type;
 }
 
-static void update_noise_reduction(MpegEncContext *s)
+static void update_noise_reduction(MPVMainEncContext *s)
 {
     int intra, i;
 
@@ -1596,7 +1596,7 @@ static void update_noise_reduction(MpegEncContext *s)
     }
 }
 
-static int frame_start(MpegEncContext *s)
+static int frame_start(MPVMainEncContext *s)
 {
     int ret;
 
@@ -1670,7 +1670,7 @@ static int frame_start(MpegEncContext *s)
 int ff_mpv_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
                           const AVFrame *pic_arg, int *got_packet)
 {
-    MpegEncContext *s = avctx->priv_data;
+    MPVMainEncContext *const s = avctx->priv_data;
     int i, stuffing_count, ret;
     int context_count = s->slice_context_count;
 
@@ -1903,7 +1903,7 @@ vbv_retry:
     return 0;
 }
 
-static inline void dct_single_coeff_elimination(MpegEncContext *s,
+static inline void dct_single_coeff_elimination(MPVEncContext *s,
                                                 int n, int threshold)
 {
     static const char tab[64] = {
@@ -1959,7 +1959,7 @@ static inline void dct_single_coeff_elimination(MpegEncContext *s,
         s->block_last_index[n] = -1;
 }
 
-static inline void clip_coeffs(MpegEncContext *s, int16_t *block,
+static inline void clip_coeffs(MPVEncContext *s, int16_t *block,
                                int last_index)
 {
     int i;
@@ -2017,7 +2017,7 @@ static void get_visual_weight(int16_t *weight, uint8_t *ptr, int stride)
     }
 }
 
-static av_always_inline void encode_mb_internal(MpegEncContext *s,
+static av_always_inline void encode_mb_internal(MPVEncContext *s,
                                                 int motion_x, int motion_y,
                                                 int mb_block_height,
                                                 int mb_block_width,
@@ -2409,7 +2409,7 @@ static av_always_inline void encode_mb_internal(MpegEncContext *s,
     }
 }
 
-static av_always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
+static av_always_inline void encode_mb(MPVEncContext *s, int motion_x, int motion_y)
 {
     if (s->chroma_format == CHROMA_420)
         encode_mb_internal(s, motion_x, motion_y,  8, 8, 6, 1, 1, CHROMA_420);
@@ -2419,7 +2419,9 @@ static av_always_inline void encode_mb(MpegEncContext *s, int motion_x, int moti
         encode_mb_internal(s, motion_x, motion_y, 16, 16, 12, 0, 0, CHROMA_444);
 }
 
-static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
+static inline void copy_context_before_encode(MPVEncContext *d,
+                                              const MPVEncContext *s, int type)
+{
     int i;
 
     memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
@@ -2447,7 +2449,9 @@ static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext
     d->esc3_level_length= s->esc3_level_length;
 }
 
-static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
+static inline void copy_context_after_encode(MPVEncContext *d,
+                                             const MPVEncContext *s, int type)
+{
     int i;
 
     memcpy(d->mv, s->mv, 2*4*2*sizeof(int));
@@ -2486,7 +2490,7 @@ static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *
     d->esc3_level_length= s->esc3_level_length;
 }
 
-static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
+static inline void encode_mb_hq(MPVEncContext *s, MPVEncContext *backup, MPVEncContext *best, int type,
                            PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
                            int *dmin, int *next_block, int motion_x, int motion_y)
 {
@@ -2537,7 +2541,9 @@ static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegE
     }
 }
 
-static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
+static int sse(MPVEncContext *s, uint8_t *src1, uint8_t *src2,
+               int w, int h, int stride)
+{
     const uint32_t *sq = ff_square_tab + 256;
     int acc=0;
     int x,y;
@@ -2558,7 +2564,8 @@ static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, in
     return acc;
 }
 
-static int sse_mb(MpegEncContext *s){
+static int sse_mb(MPVEncContext *s)
+{
     int w= 16;
     int h= 16;
 
@@ -2582,7 +2589,7 @@ static int sse_mb(MpegEncContext *s){
 }
 
 static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
-    MpegEncContext *s= *(void**)arg;
+    MPVEncContext *const s = *(void**)arg;
 
 
     s->me.pre_pass=1;
@@ -2601,7 +2608,7 @@ static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
 }
 
 static int estimate_motion_thread(AVCodecContext *c, void *arg){
-    MpegEncContext *s= *(void**)arg;
+    MPVEncContext *const s = *(void**)arg;
 
     s->me.dia_size= s->avctx->dia_size;
     s->first_slice_line=1;
@@ -2626,7 +2633,7 @@ static int estimate_motion_thread(AVCodecContext *c, void *arg){
 }
 
 static int mb_var_thread(AVCodecContext *c, void *arg){
-    MpegEncContext *s= *(void**)arg;
+    MPVEncContext *const s = *(void**)arg;
     int mb_x, mb_y;
 
     for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
@@ -2648,7 +2655,8 @@ static int mb_var_thread(AVCodecContext *c, void *arg){
     return 0;
 }
 
-static void write_slice_end(MpegEncContext *s){
+static void write_slice_end(MPVEncContext *s)
+{
     if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4){
         if(s->partitioned_frame){
             ff_mpeg4_merge_partitions(s);
@@ -2668,7 +2676,7 @@ static void write_slice_end(MpegEncContext *s){
         s->misc_bits+= get_bits_diff(s);
 }
 
-static void write_mb_info(MpegEncContext *s)
+static void write_mb_info(MPVEncContext *s)
 {
     uint8_t *ptr = s->mb_info_ptr + s->mb_info_size - 12;
     int offset = put_bits_count(&s->pb);
@@ -2688,7 +2696,7 @@ static void write_mb_info(MpegEncContext *s)
     bytestream_put_byte(&ptr, 0); /* vmv2 */
 }
 
-static void update_mb_info(MpegEncContext *s, int startcode)
+static void update_mb_info(MPVEncContext *s, int startcode)
 {
     if (!s->mb_info)
         return;
@@ -2711,7 +2719,7 @@ static void update_mb_info(MpegEncContext *s, int startcode)
     write_mb_info(s);
 }
 
-int ff_mpv_reallocate_putbitbuffer(MpegEncContext *s, size_t threshold, size_t size_increase)
+int ff_mpv_reallocate_putbitbuffer(MPVEncContext *s, size_t threshold, size_t size_increase)
 {
     if (put_bytes_left(&s->pb, 0) < threshold
         && s->slice_context_count == 1
@@ -2746,11 +2754,11 @@ int ff_mpv_reallocate_putbitbuffer(MpegEncContext *s, size_t threshold, size_t s
 }
 
 static int encode_thread(AVCodecContext *c, void *arg){
-    MpegEncContext *s= *(void**)arg;
+    MPVEncContext *const s = *(void**)arg;
     int mb_x, mb_y, mb_y_order;
     int chr_h= 16>>s->chroma_y_shift;
     int i, j;
-    MpegEncContext best_s = { 0 }, backup_s;
+    MPVEncContext best_s = { 0 }, backup_s;
     uint8_t bit_buf[2][MAX_MB_BYTES];
     uint8_t bit_buf2[2][MAX_MB_BYTES];
     uint8_t bit_buf_tex[2][MAX_MB_BYTES];
@@ -3384,13 +3392,15 @@ static int encode_thread(AVCodecContext *c, void *arg){
 }
 
 #define MERGE(field) dst->field += src->field; src->field=0
-static void merge_context_after_me(MpegEncContext *dst, MpegEncContext *src){
+static void merge_context_after_me(MPVEncContext *dst, MPVEncContext *src)
+{
     MERGE(me.scene_change_score);
     MERGE(me.mc_mb_var_sum_temp);
     MERGE(me.mb_var_sum_temp);
 }
 
-static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src){
+static void merge_context_after_encode(MPVEncContext *dst, MPVEncContext *src)
+{
     int i;
 
     MERGE(dct_count[0]); //note, the other dct vars are not part of the context
@@ -3420,7 +3430,8 @@ static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src)
     flush_put_bits(&dst->pb);
 }
 
-static int estimate_qp(MpegEncContext *s, int dry_run){
+static int estimate_qp(MPVMainEncContext *s, int dry_run)
+{
     if (s->next_lambda){
         s->current_picture_ptr->f->quality =
         s->current_picture.f->quality = s->next_lambda;
@@ -3458,7 +3469,8 @@ static int estimate_qp(MpegEncContext *s, int dry_run){
 }
 
 /* must be called before writing the header */
-static void set_frame_distances(MpegEncContext * s){
+static void set_frame_distances(MPVMainEncContext *s)
+{
     av_assert1(s->current_picture_ptr->f->pts != AV_NOPTS_VALUE);
     s->time = s->current_picture_ptr->f->pts * s->avctx->time_base.num;
 
@@ -3472,7 +3484,7 @@ static void set_frame_distances(MpegEncContext * s){
     }
 }
 
-static int encode_picture(MpegEncContext *s, int picture_number)
+static int encode_picture(MPVMainEncContext *s, int picture_number)
 {
     int i, ret;
     int bits;
@@ -3753,7 +3765,8 @@ static int encode_picture(MpegEncContext *s, int picture_number)
     return 0;
 }
 
-static void denoise_dct_c(MpegEncContext *s, int16_t *block){
+static void denoise_dct_c(MPVEncContext *s, int16_t *block)
+{
     const int intra= s->mb_intra;
     int i;
 
@@ -3777,7 +3790,7 @@ static void denoise_dct_c(MpegEncContext *s, int16_t *block){
     }
 }
 
-static int dct_quantize_trellis_c(MpegEncContext *s,
+static int dct_quantize_trellis_c(MPVEncContext *s,
                                   int16_t *block, int n,
                                   int qscale, int *overflow){
     const int *qmat;
@@ -4111,7 +4124,7 @@ static void build_basis(uint8_t *perm){
     }
 }
 
-static int dct_quantize_refine(MpegEncContext *s, //FIXME breaks denoise?
+static int dct_quantize_refine(MPVEncContext *s, //FIXME breaks denoise?
                         int16_t *block, int16_t *weight, int16_t *orig,
                         int n, int qscale){
     int16_t rem[64];
@@ -4463,7 +4476,7 @@ void ff_block_permute(int16_t *block, uint8_t *permutation,
     }
 }
 
-int ff_dct_quantize_c(MpegEncContext *s,
+int ff_dct_quantize_c(MPVEncContext *s,
                         int16_t *block, int n,
                         int qscale, int *overflow)
 {
diff --git a/libavcodec/mpegvideo_motion.c b/libavcodec/mpegvideo_motion.c
index 876a7375f8..12ae984537 100644
--- a/libavcodec/mpegvideo_motion.c
+++ b/libavcodec/mpegvideo_motion.c
@@ -32,7 +32,7 @@
 #include "qpeldsp.h"
 #include "wmv2.h"
 
-static void gmc1_motion(MpegEncContext *s,
+static void gmc1_motion(MPVContext *s,
                         uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
                         uint8_t **ref_picture)
 {
@@ -129,7 +129,7 @@ static void gmc1_motion(MpegEncContext *s,
                  motion_x & 15, motion_y & 15, 128 - s->no_rounding);
 }
 
-static void gmc_motion(MpegEncContext *s,
+static void gmc_motion(MPVContext *s,
                        uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
                        uint8_t **ref_picture)
 {
@@ -187,7 +187,7 @@ static void gmc_motion(MpegEncContext *s,
                 (s->h_edge_pos + 1) >> 1, (s->v_edge_pos + 1) >> 1);
 }
 
-static inline int hpel_motion(MpegEncContext *s,
+static inline int hpel_motion(MPVContext *s,
                               uint8_t *dest, uint8_t *src,
                               int src_x, int src_y,
                               op_pixels_func *pix_op,
@@ -223,7 +223,7 @@ static inline int hpel_motion(MpegEncContext *s,
 }
 
 static av_always_inline
-void mpeg_motion_internal(MpegEncContext *s,
+void mpeg_motion_internal(MPVContext *s,
                           uint8_t *dest_y,
                           uint8_t *dest_cb,
                           uint8_t *dest_cr,
@@ -365,7 +365,7 @@ void mpeg_motion_internal(MpegEncContext *s,
     }
 }
 /* apply one mpeg motion vector to the three components */
-static void mpeg_motion(MpegEncContext *s,
+static void mpeg_motion(MPVContext *s,
                         uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
                         int field_select, uint8_t **ref_picture,
                         op_pixels_func (*pix_op)[4],
@@ -383,7 +383,7 @@ static void mpeg_motion(MpegEncContext *s,
                              motion_x, motion_y, h, 0, is_16x8, mb_y);
 }
 
-static void mpeg_motion_field(MpegEncContext *s, uint8_t *dest_y,
+static void mpeg_motion_field(MPVContext *s, uint8_t *dest_y,
                               uint8_t *dest_cb, uint8_t *dest_cr,
                               int bottom_field, int field_select,
                               uint8_t **ref_picture,
@@ -456,7 +456,7 @@ static inline void put_obmc(uint8_t *dst, uint8_t *src[5], int stride)
 }
 
 /* obmc for 1 8x8 luma block */
-static inline void obmc_motion(MpegEncContext *s,
+static inline void obmc_motion(MPVContext *s,
                                uint8_t *dest, uint8_t *src,
                                int src_x, int src_y,
                                op_pixels_func *pix_op,
@@ -482,7 +482,7 @@ static inline void obmc_motion(MpegEncContext *s,
     put_obmc(dest, ptr, s->linesize);
 }
 
-static inline void qpel_motion(MpegEncContext *s,
+static inline void qpel_motion(MPVContext *s,
                                uint8_t *dest_y,
                                uint8_t *dest_cb,
                                uint8_t *dest_cr,
@@ -589,7 +589,7 @@ static inline void qpel_motion(MpegEncContext *s,
 /**
  * H.263 chroma 4mv motion compensation.
  */
-static void chroma_4mv_motion(MpegEncContext *s,
+static void chroma_4mv_motion(MPVContext *s,
                               uint8_t *dest_cb, uint8_t *dest_cr,
                               uint8_t **ref_picture,
                               op_pixels_func *pix_op,
@@ -641,7 +641,7 @@ static void chroma_4mv_motion(MpegEncContext *s,
     pix_op[dxy](dest_cr, ptr, s->uvlinesize, 8);
 }
 
-static inline void prefetch_motion(MpegEncContext *s, uint8_t **pix, int dir)
+static inline void prefetch_motion(MPVContext *s, uint8_t **pix, int dir)
 {
     /* fetch pixels for estimated mv 4 macroblocks ahead
      * optimized for 64byte cache lines */
@@ -655,7 +655,7 @@ static inline void prefetch_motion(MpegEncContext *s, uint8_t **pix, int dir)
     s->vdsp.prefetch(pix[1] + off, pix[2] - pix[1], 2);
 }
 
-static inline void apply_obmc(MpegEncContext *s,
+static inline void apply_obmc(MPVContext *s,
                               uint8_t *dest_y,
                               uint8_t *dest_cb,
                               uint8_t *dest_cr,
@@ -742,7 +742,7 @@ static inline void apply_obmc(MpegEncContext *s,
                           mx, my);
 }
 
-static inline void apply_8x8(MpegEncContext *s,
+static inline void apply_8x8(MPVContext *s,
                              uint8_t *dest_y,
                              uint8_t *dest_cb,
                              uint8_t *dest_cr,
@@ -826,7 +826,7 @@ static inline void apply_8x8(MpegEncContext *s,
  * @param qpix_op qpel motion compensation function (average or put normally)
  * the motion vectors are taken from s->mv and the MV type from s->mv_type
  */
-static av_always_inline void mpv_motion_internal(MpegEncContext *s,
+static av_always_inline void mpv_motion_internal(MPVContext *s,
                                                  uint8_t *dest_y,
                                                  uint8_t *dest_cb,
                                                  uint8_t *dest_cr,
@@ -969,7 +969,7 @@ static av_always_inline void mpv_motion_internal(MpegEncContext *s,
     }
 }
 
-void ff_mpv_motion(MpegEncContext *s,
+void ff_mpv_motion(MPVContext *s,
                    uint8_t *dest_y, uint8_t *dest_cb,
                    uint8_t *dest_cr, int dir,
                    uint8_t **ref_picture,
diff --git a/libavcodec/mpegvideo_xvmc.c b/libavcodec/mpegvideo_xvmc.c
index bfeb453834..28cb8e4d03 100644
--- a/libavcodec/mpegvideo_xvmc.c
+++ b/libavcodec/mpegvideo_xvmc.c
@@ -34,13 +34,13 @@
 #include "version.h"
 
 /**
- * Initialize the block field of the MpegEncContext pointer passed as
+ * Initialize the block field of the MPVDecContext pointer passed as
  * parameter after making sure that the data is not corrupted.
  * In order to implement something like direct rendering instead of decoding
  * coefficients in s->blocks and then copying them, copy them directly
  * into the data_blocks array provided by xvmc.
  */
-void ff_xvmc_init_block(MpegEncContext *s)
+void ff_xvmc_init_block(MPVDecContext *s)
 {
     struct xvmc_pix_fmt *render = (struct xvmc_pix_fmt*)s->current_picture.f->data[2];
     assert(render && render->xvmc_id == AV_XVMC_ID);
@@ -48,7 +48,7 @@ void ff_xvmc_init_block(MpegEncContext *s)
     s->block = (int16_t (*)[64])(render->data_blocks + render->next_free_data_block_num * 64);
 }
 
-static void exchange_uv(MpegEncContext *s)
+static void exchange_uv(MPVDecContext *s)
 {
     int16_t (*tmp)[64];
 
@@ -61,7 +61,7 @@ static void exchange_uv(MpegEncContext *s)
  * Fill individual block pointers, so there are no gaps in the data_block array
  * in case not all blocks in the macroblock are coded.
  */
-void ff_xvmc_pack_pblocks(MpegEncContext *s, int cbp)
+void ff_xvmc_pack_pblocks(MPVDecContext *s, int cbp)
 {
     int i, j = 0;
     const int mb_block_count = 4 + (1 << s->chroma_format);
@@ -86,7 +86,7 @@ void ff_xvmc_pack_pblocks(MpegEncContext *s, int cbp)
  */
 static int ff_xvmc_field_start(AVCodecContext *avctx, const uint8_t *buf, uint32_t buf_size)
 {
-    struct MpegEncContext *s = avctx->priv_data;
+    MPVDecContext *const s = avctx->priv_data;
     struct xvmc_pix_fmt *last, *next, *render = (struct xvmc_pix_fmt*)s->current_picture.f->data[2];
     const int mb_block_count = 4 + (1 << s->chroma_format);
 
@@ -155,7 +155,7 @@ return -1;
  */
 static int ff_xvmc_field_end(AVCodecContext *avctx)
 {
-    struct MpegEncContext *s = avctx->priv_data;
+    MPVDecContext *const s = avctx->priv_data;
     struct xvmc_pix_fmt *render = (struct xvmc_pix_fmt*)s->current_picture.f->data[2];
     assert(render);
 
@@ -170,7 +170,7 @@ static int ff_xvmc_field_end(AVCodecContext *avctx)
  */
 static void ff_xvmc_decode_mb(void *opaque)
 {
-    MpegEncContext *const s = opaque;
+    MPVDecContext *const s = opaque;
     XvMCMacroBlock *mv_block;
     struct xvmc_pix_fmt *render;
     int i, cbp, blocks_per_mb;
diff --git a/libavcodec/mpegvideoenc.h b/libavcodec/mpegvideoenc.h
index 21e7a55e13..94ebe0237f 100644
--- a/libavcodec/mpegvideoenc.h
+++ b/libavcodec/mpegvideoenc.h
@@ -32,6 +32,9 @@
 #include "internal.h"
 #include "mpegvideo.h"
 
+typedef MPVContext MPVEncContext;
+typedef MPVContext MPVMainEncContext;
+
 /* mpegvideo_enc common options */
 #define FF_MPV_FLAG_SKIP_RD      0x0001
 #define FF_MPV_FLAG_STRICT_GOP   0x0002
@@ -58,7 +61,7 @@
 { "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" }
 
 #ifndef FF_MPV_OFFSET
-#define FF_MPV_OFFSET(x) offsetof(MpegEncContext, x)
+#define FF_MPV_OFFSET(x) offsetof(MPVMainEncContext, x)
 #endif
 #define FF_MPV_OPT_FLAGS (AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM)
 #define FF_MPV_COMMON_OPTS \
@@ -129,26 +132,26 @@ FF_MPV_OPT_CMP_FUNC, \
 extern const AVClass ff_mpv_enc_class;
 
 int ff_mpv_encode_init(AVCodecContext *avctx);
-void ff_mpv_encode_init_x86(MpegEncContext *s);
+void ff_mpv_encode_init_x86(MPVMainEncContext *s);
 
 int ff_mpv_encode_end(AVCodecContext *avctx);
 int ff_mpv_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
                           const AVFrame *frame, int *got_packet);
-int ff_mpv_reallocate_putbitbuffer(MpegEncContext *s, size_t threshold, size_t size_increase);
+int ff_mpv_reallocate_putbitbuffer(MPVEncContext *s, size_t threshold, size_t size_increase);
 
 void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix);
 
-int ff_dct_encode_init(MpegEncContext *s);
-void ff_dct_encode_init_x86(MpegEncContext *s);
+int ff_dct_encode_init(MPVEncContext *s);
+void ff_dct_encode_init_x86(MPVEncContext *s);
 
-int ff_dct_quantize_c(MpegEncContext *s, int16_t *block, int n, int qscale, int *overflow);
-void ff_convert_matrix(MpegEncContext *s, int (*qmat)[64], uint16_t (*qmat16)[2][64],
+int ff_dct_quantize_c(MPVEncContext *s, int16_t *block, int n, int qscale, int *overflow);
+void ff_convert_matrix(MPVEncContext *s, int (*qmat)[64], uint16_t (*qmat16)[2][64],
                        const uint16_t *quant_matrix, int bias, int qmin, int qmax, int intra);
 
 void ff_block_permute(int16_t *block, uint8_t *permutation,
                       const uint8_t *scantable, int last);
 
-static inline int get_bits_diff(MpegEncContext *s)
+static inline int get_bits_diff(MPVEncContext *s)
 {
     const int bits = put_bits_count(&s->pb);
     const int last = s->last_bits;
diff --git a/libavcodec/msmpeg4.c b/libavcodec/msmpeg4.c
index f12586dd64..991b5f09c9 100644
--- a/libavcodec/msmpeg4.c
+++ b/libavcodec/msmpeg4.c
@@ -112,7 +112,7 @@ static av_cold void msmpeg4_common_init_static(void)
     init_h263_dc_for_msmpeg4();
 }
 
-av_cold void ff_msmpeg4_common_init(MpegEncContext *s)
+av_cold void ff_msmpeg4_common_init(MPVMainContext *s)
 {
     static AVOnce init_static_once = AV_ONCE_INIT;
 
@@ -158,7 +158,7 @@ av_cold void ff_msmpeg4_common_init(MpegEncContext *s)
 }
 
 /* predict coded block */
-int ff_msmpeg4_coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr)
+int ff_msmpeg4_coded_block_pred(MPVContext * s, int n, uint8_t **coded_block_ptr)
 {
     int xy, wrap, pred, a, b, c;
 
@@ -198,7 +198,7 @@ static int get_dc(uint8_t *src, int stride, int scale, int block_size)
 }
 
 /* dir = 0: left, dir = 1: top prediction */
-int ff_msmpeg4_pred_dc(MpegEncContext *s, int n,
+int ff_msmpeg4_pred_dc(MPVContext *s, int n,
                        int16_t **dc_val_ptr, int *dir_ptr)
 {
     int a, b, c, wrap, pred, scale;
diff --git a/libavcodec/msmpeg4.h b/libavcodec/msmpeg4.h
index dbe650cbbc..8d8ac31813 100644
--- a/libavcodec/msmpeg4.h
+++ b/libavcodec/msmpeg4.h
@@ -41,17 +41,17 @@
 extern VLC ff_mb_non_intra_vlc[4];
 extern VLC ff_inter_intra_vlc;
 
-void ff_msmpeg4_common_init(MpegEncContext *s);
-int ff_msmpeg4_coded_block_pred(MpegEncContext * s, int n,
+void ff_msmpeg4_common_init(MPVMainContext *s);
+int ff_msmpeg4_coded_block_pred(MPVContext * s, int n,
                                 uint8_t **coded_block_ptr);
 
 int ff_msmpeg4_decode_init(AVCodecContext *avctx);
-int ff_msmpeg4_decode_picture_header(MpegEncContext *s);
-int ff_msmpeg4_decode_ext_header(MpegEncContext *s, int buf_size);
-void ff_msmpeg4_decode_motion(MpegEncContext * s, int *mx_ptr, int *my_ptr);
-int ff_msmpeg4_decode_block(MpegEncContext * s, int16_t * block,
+int ff_msmpeg4_decode_picture_header(MPVMainDecContext *s);
+int ff_msmpeg4_decode_ext_header(MPVMainDecContext *s, int buf_size);
+void ff_msmpeg4_decode_motion(MPVDecContext * s, int *mx_ptr, int *my_ptr);
+int ff_msmpeg4_decode_block(MPVDecContext * s, int16_t * block,
                             int n, int coded, const uint8_t *scan_table);
-int ff_msmpeg4_pred_dc(MpegEncContext *s, int n,
+int ff_msmpeg4_pred_dc(MPVContext *s, int n,
                        int16_t **dc_val_ptr, int *dir_ptr);
 
 
diff --git a/libavcodec/msmpeg4dec.c b/libavcodec/msmpeg4dec.c
index 77ad8a8ff4..4bcb119923 100644
--- a/libavcodec/msmpeg4dec.c
+++ b/libavcodec/msmpeg4dec.c
@@ -44,7 +44,7 @@
 
 #define DEFAULT_INTER_INDEX 3
 
-static inline int msmpeg4v1_pred_dc(MpegEncContext * s, int n,
+static inline int msmpeg4v1_pred_dc(MPVDecContext * s, int n,
                                     int32_t **dc_val_ptr)
 {
     int i;
@@ -70,7 +70,7 @@ static VLC v2_mb_type_vlc;
 VLC ff_inter_intra_vlc;
 
 /* This is identical to H.263 except that its range is multiplied by 2. */
-static int msmpeg4v2_decode_motion(MpegEncContext * s, int pred, int f_code)
+static int msmpeg4v2_decode_motion(MPVDecContext * s, int pred, int f_code)
 {
     int code, val, sign, shift;
 
@@ -101,7 +101,7 @@ static int msmpeg4v2_decode_motion(MpegEncContext * s, int pred, int f_code)
     return val;
 }
 
-static int msmpeg4v12_decode_mb(MpegEncContext *s, int16_t block[6][64])
+static int msmpeg4v12_decode_mb(MPVDecContext *s, int16_t block[6][64])
 {
     int cbp, code, i;
     uint32_t * const mb_type_ptr = &s->current_picture.mb_type[s->mb_x + s->mb_y*s->mb_stride];
@@ -202,7 +202,7 @@ static int msmpeg4v12_decode_mb(MpegEncContext *s, int16_t block[6][64])
     return 0;
 }
 
-static int msmpeg4v34_decode_mb(MpegEncContext *s, int16_t block[6][64])
+static int msmpeg4v34_decode_mb(MPVDecContext *s, int16_t block[6][64])
 {
     int cbp, code, i;
     uint8_t *coded_val;
@@ -295,7 +295,7 @@ static int msmpeg4v34_decode_mb(MpegEncContext *s, int16_t block[6][64])
 /* init all vlc decoding tables */
 av_cold int ff_msmpeg4_decode_init(AVCodecContext *avctx)
 {
-    MpegEncContext *s = avctx->priv_data;
+    MPVMainDecContext *const s = avctx->priv_data;
     static volatile int done = 0;
     int ret;
     MVTable *mv;
@@ -398,7 +398,7 @@ av_cold int ff_msmpeg4_decode_init(AVCodecContext *avctx)
     return 0;
 }
 
-int ff_msmpeg4_decode_picture_header(MpegEncContext * s)
+int ff_msmpeg4_decode_picture_header(MPVMainDecContext * s)
 {
     int code;
 
@@ -554,7 +554,7 @@ int ff_msmpeg4_decode_picture_header(MpegEncContext * s)
     return 0;
 }
 
-int ff_msmpeg4_decode_ext_header(MpegEncContext * s, int buf_size)
+int ff_msmpeg4_decode_ext_header(MPVMainDecContext *s, int buf_size)
 {
     int left= buf_size*8 - get_bits_count(&s->gb);
     int length= s->msmpeg4_version>=3 ? 17 : 16;
@@ -582,7 +582,7 @@ int ff_msmpeg4_decode_ext_header(MpegEncContext * s, int buf_size)
     return 0;
 }
 
-static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
+static int msmpeg4_decode_dc(MPVDecContext * s, int n, int *dir_ptr)
 {
     int level, pred;
 
@@ -638,7 +638,7 @@ static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
     return level;
 }
 
-int ff_msmpeg4_decode_block(MpegEncContext * s, int16_t * block,
+int ff_msmpeg4_decode_block(MPVDecContext * s, int16_t * block,
                               int n, int coded, const uint8_t *scan_table)
 {
     int level, i, last, run, run_diff;
@@ -825,7 +825,7 @@ int ff_msmpeg4_decode_block(MpegEncContext * s, int16_t * block,
     return 0;
 }
 
-void ff_msmpeg4_decode_motion(MpegEncContext *s, int *mx_ptr, int *my_ptr)
+void ff_msmpeg4_decode_motion(MPVDecContext *s, int *mx_ptr, int *my_ptr)
 {
     MVTable *mv;
     int code, mx, my;
@@ -862,7 +862,7 @@ const AVCodec ff_msmpeg4v1_decoder = {
     .long_name      = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 1"),
     .type           = AVMEDIA_TYPE_VIDEO,
     .id             = AV_CODEC_ID_MSMPEG4V1,
-    .priv_data_size = sizeof(MpegEncContext),
+    .priv_data_size = sizeof(MPVMainDecContext),
     .init           = ff_msmpeg4_decode_init,
     .close          = ff_h263_decode_end,
     .decode         = ff_h263_decode_frame,
@@ -880,7 +880,7 @@ const AVCodec ff_msmpeg4v2_decoder = {
     .long_name      = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"),
     .type           = AVMEDIA_TYPE_VIDEO,
     .id             = AV_CODEC_ID_MSMPEG4V2,
-    .priv_data_size = sizeof(MpegEncContext),
+    .priv_data_size = sizeof(MPVMainDecContext),
     .init           = ff_msmpeg4_decode_init,
     .close          = ff_h263_decode_end,
     .decode         = ff_h263_decode_frame,
@@ -898,7 +898,7 @@ const AVCodec ff_msmpeg4v3_decoder = {
     .long_name      = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"),
     .type           = AVMEDIA_TYPE_VIDEO,
     .id             = AV_CODEC_ID_MSMPEG4V3,
-    .priv_data_size = sizeof(MpegEncContext),
+    .priv_data_size = sizeof(MPVMainDecContext),
     .init           = ff_msmpeg4_decode_init,
     .close          = ff_h263_decode_end,
     .decode         = ff_h263_decode_frame,
@@ -916,7 +916,7 @@ const AVCodec ff_wmv1_decoder = {
     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Video 7"),
     .type           = AVMEDIA_TYPE_VIDEO,
     .id             = AV_CODEC_ID_WMV1,
-    .priv_data_size = sizeof(MpegEncContext),
+    .priv_data_size = sizeof(MPVMainDecContext),
     .init           = ff_msmpeg4_decode_init,
     .close          = ff_h263_decode_end,
     .decode         = ff_h263_decode_frame,
diff --git a/libavcodec/msmpeg4enc.c b/libavcodec/msmpeg4enc.c
index 5e1ed9cc27..0c4d777cc2 100644
--- a/libavcodec/msmpeg4enc.c
+++ b/libavcodec/msmpeg4enc.c
@@ -136,7 +136,7 @@ static av_cold void msmpeg4_encode_init_static(void)
     }
 }
 
-av_cold void ff_msmpeg4_encode_init(MpegEncContext *s)
+av_cold void ff_msmpeg4_encode_init(MPVMainEncContext *s)
 {
     static AVOnce init_static_once = AV_ONCE_INIT;
 
@@ -152,7 +152,7 @@ av_cold void ff_msmpeg4_encode_init(MpegEncContext *s)
 
 static void find_best_tables(MSMPEG4EncContext *ms)
 {
-    MpegEncContext *const s = &ms->s;
+    MPVEncContext *const s = &ms->s;
     int i;
     int best        = 0, best_size        = INT_MAX;
     int chroma_best = 0, best_chroma_size = INT_MAX;
@@ -216,7 +216,7 @@ static void find_best_tables(MSMPEG4EncContext *ms)
 }
 
 /* write MSMPEG4 compatible frame header */
-void ff_msmpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
+void ff_msmpeg4_encode_picture_header(MPVMainEncContext * s, int picture_number)
 {
     MSMPEG4EncContext *const ms = (MSMPEG4EncContext*)s;
 
@@ -278,7 +278,7 @@ void ff_msmpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
     s->esc3_run_length= 0;
 }
 
-void ff_msmpeg4_encode_ext_header(MpegEncContext * s)
+void ff_msmpeg4_encode_ext_header(MPVEncContext * s)
 {
         unsigned fps = s->avctx->time_base.den / s->avctx->time_base.num / FFMAX(s->avctx->ticks_per_frame, 1);
         put_bits(&s->pb, 5, FFMIN(fps, 31)); //yes 29.97 -> 29
@@ -291,7 +291,7 @@ void ff_msmpeg4_encode_ext_header(MpegEncContext * s)
             av_assert0(s->flipflop_rounding==0);
 }
 
-void ff_msmpeg4_encode_motion(MpegEncContext * s,
+void ff_msmpeg4_encode_motion(MPVEncContext * s,
                                   int mx, int my)
 {
     int code;
@@ -324,7 +324,8 @@ void ff_msmpeg4_encode_motion(MpegEncContext * s,
     }
 }
 
-void ff_msmpeg4_handle_slices(MpegEncContext *s){
+void ff_msmpeg4_handle_slices(MPVEncContext *s)
+{
     if (s->mb_x == 0) {
         if (s->slice_height && (s->mb_y % s->slice_height) == 0) {
             if(s->msmpeg4_version < 4){
@@ -337,7 +338,7 @@ void ff_msmpeg4_handle_slices(MpegEncContext *s){
     }
 }
 
-static void msmpeg4v2_encode_motion(MpegEncContext * s, int val)
+static void msmpeg4v2_encode_motion(MPVEncContext * s, int val)
 {
     int range, bit_size, sign, code, bits;
 
@@ -370,7 +371,7 @@ static void msmpeg4v2_encode_motion(MpegEncContext * s, int val)
     }
 }
 
-void ff_msmpeg4_encode_mb(MpegEncContext * s,
+void ff_msmpeg4_encode_mb(MPVEncContext * s,
                           int16_t block[6][64],
                           int motion_x, int motion_y)
 {
@@ -493,7 +494,7 @@ void ff_msmpeg4_encode_mb(MpegEncContext * s,
     }
 }
 
-static void msmpeg4_encode_dc(MpegEncContext * s, int level, int n, int *dir_ptr)
+static void msmpeg4_encode_dc(MPVEncContext * s, int level, int n, int *dir_ptr)
 {
     int sign, code;
     int pred;
@@ -556,7 +557,7 @@ static void msmpeg4_encode_dc(MpegEncContext * s, int level, int n, int *dir_ptr
 
 /* Encoding of a block; very similar to MPEG-4 except for a different
  * escape coding (same as H.263) and more VLC tables. */
-void ff_msmpeg4_encode_block(MpegEncContext * s, int16_t * block, int n)
+void ff_msmpeg4_encode_block(MPVEncContext * s, int16_t * block, int n)
 {
     MSMPEG4EncContext *const ms = (MSMPEG4EncContext*)s;
     int level, run, last, i, j, last_index;
diff --git a/libavcodec/msmpeg4enc.h b/libavcodec/msmpeg4enc.h
index 98044913b1..80f7b0709e 100644
--- a/libavcodec/msmpeg4enc.h
+++ b/libavcodec/msmpeg4enc.h
@@ -23,25 +23,25 @@
 #define AVCODEC_MSMPEG4ENC_H
 
 #include "config.h"
-#include "mpegvideo.h"
+#include "mpegvideoenc.h"
 #include "put_bits.h"
 #include "rl.h"
 
 typedef struct MSMPEG4EncContext {
-    MpegEncContext s;
+    MPVMainEncContext s;
 
     /** [mb_intra][isChroma][level][run][last] */
     unsigned ac_stats[2][2][MAX_LEVEL + 1][MAX_RUN + 1][2];
 } MSMPEG4EncContext;
 
-void ff_msmpeg4_encode_init(MpegEncContext *s);
-void ff_msmpeg4_encode_picture_header(MpegEncContext *s, int picture_number);
-void ff_msmpeg4_encode_ext_header(MpegEncContext *s);
-void ff_msmpeg4_encode_mb(MpegEncContext *s, int16_t block[6][64],
+void ff_msmpeg4_encode_init(MPVMainEncContext *s);
+void ff_msmpeg4_encode_picture_header(MPVMainEncContext *s, int picture_number);
+void ff_msmpeg4_encode_ext_header(MPVEncContext *s);
+void ff_msmpeg4_encode_mb(MPVEncContext *s, int16_t block[6][64],
                           int motion_x, int motion_y);
-void ff_msmpeg4_encode_block(MpegEncContext * s, int16_t * block, int n);
-void ff_msmpeg4_handle_slices(MpegEncContext *s);
-void ff_msmpeg4_encode_motion(MpegEncContext * s, int mx, int my);
+void ff_msmpeg4_encode_block(MPVEncContext * s, int16_t * block, int n);
+void ff_msmpeg4_handle_slices(MPVEncContext *s);
+void ff_msmpeg4_encode_motion(MPVEncContext * s, int mx, int my);
 
 void ff_msmpeg4_code012(PutBitContext *pb, int n);
 
diff --git a/libavcodec/mss2.c b/libavcodec/mss2.c
index d7a19f6ad2..64888540ac 100644
--- a/libavcodec/mss2.c
+++ b/libavcodec/mss2.c
@@ -381,7 +381,7 @@ static int decode_wmv9(AVCodecContext *avctx, const uint8_t *buf, int buf_size,
     MSS2Context *ctx  = avctx->priv_data;
     MSS12Context *c   = &ctx->c;
     VC1Context *v     = avctx->priv_data;
-    MpegEncContext *s = &v->s;
+    MPVMainDecContext *const s = &v->s;
     AVFrame *f;
     int ret;
 
diff --git a/libavcodec/neon/mpegvideo.c b/libavcodec/neon/mpegvideo.c
index 8f05d77a65..e5c21290fd 100644
--- a/libavcodec/neon/mpegvideo.c
+++ b/libavcodec/neon/mpegvideo.c
@@ -83,7 +83,7 @@ static void inline ff_dct_unquantize_h263_neon(int qscale, int qadd, int nCoeffs
     vst1_s16(block, d0s16);
 }
 
-static void dct_unquantize_h263_inter_neon(MpegEncContext *s, int16_t *block,
+static void dct_unquantize_h263_inter_neon(MPVContext *s, int16_t *block,
                                            int n, int qscale)
 {
     int nCoeffs = s->inter_scantable.raster_end[s->block_last_index[n]];
@@ -92,7 +92,7 @@ static void dct_unquantize_h263_inter_neon(MpegEncContext *s, int16_t *block,
     ff_dct_unquantize_h263_neon(qscale, qadd, nCoeffs + 1, block);
 }
 
-static void dct_unquantize_h263_intra_neon(MpegEncContext *s, int16_t *block,
+static void dct_unquantize_h263_intra_neon(MPVContext *s, int16_t *block,
                                            int n, int qscale)
 {
     int qadd;
@@ -124,7 +124,7 @@ static void dct_unquantize_h263_intra_neon(MpegEncContext *s, int16_t *block,
 }
 
 
-av_cold void ff_mpv_common_init_neon(MpegEncContext *s)
+av_cold void ff_mpv_common_init_neon(MPVMainContext *s)
 {
     int cpu_flags = av_get_cpu_flags();
 
diff --git a/libavcodec/nvdec_mpeg12.c b/libavcodec/nvdec_mpeg12.c
index b8db4250bb..c3b92f2111 100644
--- a/libavcodec/nvdec_mpeg12.c
+++ b/libavcodec/nvdec_mpeg12.c
@@ -28,7 +28,7 @@
 
 static int nvdec_mpeg12_start_frame(AVCodecContext *avctx, const uint8_t *buffer, uint32_t size)
 {
-    MpegEncContext *s = avctx->priv_data;
+    MPVDecContext *const s = avctx->priv_data;
 
     NVDECContext      *ctx = avctx->internal->hwaccel_priv_data;
     CUVIDPICPARAMS     *pp = &ctx->pic_params;
diff --git a/libavcodec/nvdec_mpeg4.c b/libavcodec/nvdec_mpeg4.c
index 2b2b1b87a1..5d3ed31a69 100644
--- a/libavcodec/nvdec_mpeg4.c
+++ b/libavcodec/nvdec_mpeg4.c
@@ -29,7 +29,7 @@
 static int nvdec_mpeg4_start_frame(AVCodecContext *avctx, const uint8_t *buffer, uint32_t size)
 {
     Mpeg4DecContext *m = avctx->priv_data;
-    MpegEncContext *s = &m->m;
+    MPVEncContext *const s = &m->m;
 
     NVDECContext      *ctx = avctx->internal->hwaccel_priv_data;
     CUVIDPICPARAMS     *pp = &ctx->pic_params;
diff --git a/libavcodec/nvdec_vc1.c b/libavcodec/nvdec_vc1.c
index 10e7b5ab0d..9dc9f49b6a 100644
--- a/libavcodec/nvdec_vc1.c
+++ b/libavcodec/nvdec_vc1.c
@@ -28,7 +28,7 @@
 static int nvdec_vc1_start_frame(AVCodecContext *avctx, const uint8_t *buffer, uint32_t size)
 {
     VC1Context *v = avctx->priv_data;
-    MpegEncContext *s = &v->s;
+    MPVDecContext *const s = &v->s;
 
     NVDECContext      *ctx = avctx->internal->hwaccel_priv_data;
     CUVIDPICPARAMS     *pp = &ctx->pic_params;
diff --git a/libavcodec/ppc/me_cmp.c b/libavcodec/ppc/me_cmp.c
index 17f9a4f016..31a1881f01 100644
--- a/libavcodec/ppc/me_cmp.c
+++ b/libavcodec/ppc/me_cmp.c
@@ -28,7 +28,7 @@
 #include "libavutil/ppc/util_altivec.h"
 
 #include "libavcodec/avcodec.h"
-#include "libavcodec/mpegvideo.h"
+#include "libavcodec/mpegvideoenc.h"
 #include "libavcodec/me_cmp.h"
 
 #if HAVE_ALTIVEC
@@ -51,7 +51,7 @@
     iv = vec_vsx_ld(1,  pix);\
 }
 #endif
-static int sad16_x2_altivec(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
+static int sad16_x2_altivec(MPVEncContext *v, uint8_t *pix1, uint8_t *pix2,
                             ptrdiff_t stride, int h)
 {
     int i;
@@ -91,7 +91,7 @@ static int sad16_x2_altivec(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
     return s;
 }
 
-static int sad16_y2_altivec(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
+static int sad16_y2_altivec(MPVEncContext *v, uint8_t *pix1, uint8_t *pix2,
                             ptrdiff_t stride, int h)
 {
     int i;
@@ -141,7 +141,7 @@ static int sad16_y2_altivec(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
     return s;
 }
 
-static int sad16_xy2_altivec(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
+static int sad16_xy2_altivec(MPVEncContext *v, uint8_t *pix1, uint8_t *pix2,
                              ptrdiff_t stride, int h)
 {
     int i;
@@ -230,7 +230,7 @@ static int sad16_xy2_altivec(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
     return s;
 }
 
-static int sad16_altivec(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
+static int sad16_altivec(MPVEncContext *v, uint8_t *pix1, uint8_t *pix2,
                          ptrdiff_t stride, int h)
 {
     int i;
@@ -265,7 +265,7 @@ static int sad16_altivec(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
     return s;
 }
 
-static int sad8_altivec(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
+static int sad8_altivec(MPVEncContext *v, uint8_t *pix1, uint8_t *pix2,
                         ptrdiff_t stride, int h)
 {
     int i;
@@ -309,7 +309,7 @@ static int sad8_altivec(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
 
 /* Sum of Squared Errors for an 8x8 block, AltiVec-enhanced.
  * It's the sad8_altivec code above w/ squaring added. */
-static int sse8_altivec(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
+static int sse8_altivec(MPVEncContext *v, uint8_t *pix1, uint8_t *pix2,
                         ptrdiff_t stride, int h)
 {
     int i;
@@ -354,7 +354,7 @@ static int sse8_altivec(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
 
 /* Sum of Squared Errors for a 16x16 block, AltiVec-enhanced.
  * It's the sad16_altivec code above w/ squaring added. */
-static int sse16_altivec(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
+static int sse16_altivec(MPVEncContext *v, uint8_t *pix1, uint8_t *pix2,
                          ptrdiff_t stride, int h)
 {
     int i;
@@ -392,7 +392,7 @@ static int sse16_altivec(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
     return s;
 }
 
-static int hadamard8_diff8x8_altivec(MpegEncContext *s, uint8_t *dst,
+static int hadamard8_diff8x8_altivec(MPVEncContext *s, uint8_t *dst,
                                      uint8_t *src, ptrdiff_t stride, int h)
 {
     int __attribute__((aligned(16))) sum;
@@ -518,7 +518,7 @@ static int hadamard8_diff8x8_altivec(MpegEncContext *s, uint8_t *dst,
  * On the 970, the hand-made RA is still a win (around 690 vs. around 780),
  * but xlc goes to around 660 on the regular C code...
  */
-static int hadamard8_diff16x8_altivec(MpegEncContext *s, uint8_t *dst,
+static int hadamard8_diff16x8_altivec(MPVEncContext *s, uint8_t *dst,
                                       uint8_t *src, ptrdiff_t stride, int h)
 {
     int __attribute__((aligned(16))) sum;
@@ -709,7 +709,7 @@ static int hadamard8_diff16x8_altivec(MpegEncContext *s, uint8_t *dst,
     return sum;
 }
 
-static int hadamard8_diff16_altivec(MpegEncContext *s, uint8_t *dst,
+static int hadamard8_diff16_altivec(MPVEncContext *s, uint8_t *dst,
                                     uint8_t *src, ptrdiff_t stride, int h)
 {
     int score = hadamard8_diff16x8_altivec(s, dst, src, stride, 8);
diff --git a/libavcodec/ppc/mpegvideo_altivec.c b/libavcodec/ppc/mpegvideo_altivec.c
index bcb59ba845..e8f8413a39 100644
--- a/libavcodec/ppc/mpegvideo_altivec.c
+++ b/libavcodec/ppc/mpegvideo_altivec.c
@@ -38,7 +38,7 @@
 
 /* AltiVec version of dct_unquantize_h263
    this code assumes `block' is 16 bytes-aligned */
-static void dct_unquantize_h263_altivec(MpegEncContext *s,
+static void dct_unquantize_h263_altivec(MPVContext *s,
                                  int16_t *block, int n, int qscale)
 {
     int i, level, qmul, qadd;
@@ -116,7 +116,7 @@ static void dct_unquantize_h263_altivec(MpegEncContext *s,
 
 #endif /* HAVE_ALTIVEC */
 
-av_cold void ff_mpv_common_init_ppc(MpegEncContext *s)
+av_cold void ff_mpv_common_init_ppc(MPVMainContext *s)
 {
 #if HAVE_ALTIVEC
     if (!PPC_ALTIVEC(av_get_cpu_flags()))
diff --git a/libavcodec/ratecontrol.c b/libavcodec/ratecontrol.c
index f814e23ed5..c5088d6790 100644
--- a/libavcodec/ratecontrol.c
+++ b/libavcodec/ratecontrol.c
@@ -35,7 +35,7 @@
 #include "mpegvideoenc.h"
 #include "libavutil/eval.h"
 
-void ff_write_pass1_stats(MpegEncContext *s)
+void ff_write_pass1_stats(MPVMainEncContext *s)
 {
     snprintf(s->avctx->stats_out, 256,
              "in:%d out:%d type:%d q:%d itex:%d ptex:%d mv:%d misc:%d "
@@ -77,7 +77,7 @@ 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(MpegEncContext *s, RateControlEntry *rce, double q)
+static double get_diff_limited_q(MPVMainEncContext *s, RateControlEntry *rce, double q)
 {
     RateControlContext *rcc   = &s->rc_context;
     AVCodecContext *a         = s->avctx;
@@ -116,7 +116,7 @@ static double get_diff_limited_q(MpegEncContext *s, RateControlEntry *rce, doubl
 /**
  * Get the qmin & qmax for pict_type.
  */
-static void get_qminmax(int *qmin_ret, int *qmax_ret, MpegEncContext *s, int pict_type)
+static void get_qminmax(int *qmin_ret, int *qmax_ret, MPVMainEncContext *s, int pict_type)
 {
     int qmin = s->lmin;
     int qmax = s->lmax;
@@ -144,7 +144,7 @@ static void get_qminmax(int *qmin_ret, int *qmax_ret, MpegEncContext *s, int pic
     *qmax_ret = qmax;
 }
 
-static double modify_qscale(MpegEncContext *s, RateControlEntry *rce,
+static double modify_qscale(MPVMainEncContext *s, RateControlEntry *rce,
                             double q, int frame_num)
 {
     RateControlContext *rcc  = &s->rc_context;
@@ -235,7 +235,7 @@ static double modify_qscale(MpegEncContext *s, RateControlEntry *rce,
 /**
  * Modify the bitrate curve from pass1 for one frame.
  */
-static double get_qscale(MpegEncContext *s, RateControlEntry *rce,
+static double get_qscale(MPVMainEncContext *s, RateControlEntry *rce,
                          double rate_factor, int frame_num)
 {
     RateControlContext *rcc = &s->rc_context;
@@ -308,7 +308,7 @@ static double get_qscale(MpegEncContext *s, RateControlEntry *rce,
     return q;
 }
 
-static int init_pass2(MpegEncContext *s)
+static int init_pass2(MPVMainEncContext *s)
 {
     RateControlContext *rcc = &s->rc_context;
     AVCodecContext *a       = s->avctx;
@@ -469,7 +469,7 @@ static int init_pass2(MpegEncContext *s)
     return 0;
 }
 
-av_cold int ff_rate_control_init(MpegEncContext *s)
+av_cold int ff_rate_control_init(MPVMainEncContext *s)
 {
     RateControlContext *rcc = &s->rc_context;
     int i, res;
@@ -669,7 +669,7 @@ av_cold int ff_rate_control_init(MpegEncContext *s)
     return 0;
 }
 
-av_cold void ff_rate_control_uninit(MpegEncContext *s)
+av_cold void ff_rate_control_uninit(MPVMainEncContext *s)
 {
     RateControlContext *rcc = &s->rc_context;
     emms_c();
@@ -678,7 +678,7 @@ av_cold void ff_rate_control_uninit(MpegEncContext *s)
     av_freep(&rcc->entry);
 }
 
-int ff_vbv_update(MpegEncContext *s, int frame_size)
+int ff_vbv_update(MPVMainEncContext *s, int frame_size)
 {
     RateControlContext *rcc = &s->rc_context;
     const double fps        = get_fps(s->avctx);
@@ -737,7 +737,7 @@ static void update_predictor(Predictor *p, double q, double var, double size)
     p->coeff += new_coeff;
 }
 
-static void adaptive_quantization(MpegEncContext *s, double q)
+static void adaptive_quantization(MPVMainEncContext *s, double q)
 {
     int i;
     const float lumi_masking         = s->avctx->lumi_masking / (128.0 * 128.0);
@@ -854,7 +854,7 @@ static void adaptive_quantization(MpegEncContext *s, double q)
     }
 }
 
-void ff_get_2pass_fcode(MpegEncContext *s)
+void ff_get_2pass_fcode(MPVMainEncContext *s)
 {
     RateControlContext *rcc = &s->rc_context;
     RateControlEntry *rce   = &rcc->entry[s->picture_number];
@@ -865,7 +865,7 @@ void ff_get_2pass_fcode(MpegEncContext *s)
 
 // FIXME rd or at least approx for dquant
 
-float ff_rate_estimate_qscale(MpegEncContext *s, int dry_run)
+float ff_rate_estimate_qscale(MPVMainEncContext *s, int dry_run)
 {
     float q;
     int qmin, qmax;
diff --git a/libavcodec/ratecontrol.h b/libavcodec/ratecontrol.h
index 2a7aaec644..99715ebdfb 100644
--- a/libavcodec/ratecontrol.h
+++ b/libavcodec/ratecontrol.h
@@ -86,14 +86,16 @@ typedef struct RateControlContext{
     AVExpr * rc_eq_eval;
 }RateControlContext;
 
-struct MpegEncContext;
+#define MPVMainEncContext MPVContext
+struct MPVMainEncContext;
 
 /* rate control */
-int ff_rate_control_init(struct MpegEncContext *s);
-float ff_rate_estimate_qscale(struct MpegEncContext *s, int dry_run);
-void ff_write_pass1_stats(struct MpegEncContext *s);
-void ff_rate_control_uninit(struct MpegEncContext *s);
-int ff_vbv_update(struct MpegEncContext *s, int frame_size);
-void ff_get_2pass_fcode(struct MpegEncContext *s);
+int ff_rate_control_init(struct MPVMainEncContext *s);
+float ff_rate_estimate_qscale(struct MPVMainEncContext *s, int dry_run);
+void ff_write_pass1_stats(struct MPVMainEncContext *s);
+void ff_rate_control_uninit(struct MPVMainEncContext *s);
+int ff_vbv_update(struct MPVMainEncContext *s, int frame_size);
+void ff_get_2pass_fcode(struct MPVMainEncContext *s);
+#undef MPVMainEncContext
 
 #endif /* AVCODEC_RATECONTROL_H */
diff --git a/libavcodec/rv10.c b/libavcodec/rv10.c
index 4dfaa3460d..185aacb5c7 100644
--- a/libavcodec/rv10.c
+++ b/libavcodec/rv10.c
@@ -51,7 +51,7 @@
 #define DC_VLC_BITS        9
 
 typedef struct RVDecContext {
-    MpegEncContext m;
+    MPVMainDecContext m;
     int sub_id;
     int orig_width, orig_height;
 } RVDecContext;
@@ -79,7 +79,7 @@ static const uint16_t rv_chrom_len_count[15] = {
 
 static VLC rv_dc_lum, rv_dc_chrom;
 
-int ff_rv_decode_dc(MpegEncContext *s, int n)
+int ff_rv_decode_dc(MPVDecContext *s, int n)
 {
     int code;
 
@@ -96,7 +96,7 @@ int ff_rv_decode_dc(MpegEncContext *s, int n)
 }
 
 /* read RV 1.0 compatible frame header */
-static int rv10_decode_picture_header(MpegEncContext *s)
+static int rv10_decode_picture_header(MPVDecContext *s)
 {
     int mb_count, pb_frame, marker, mb_xy;
 
@@ -156,7 +156,7 @@ static int rv10_decode_picture_header(MpegEncContext *s)
 
 static int rv20_decode_picture_header(RVDecContext *rv, int whole_size)
 {
-    MpegEncContext *s = &rv->m;
+    MPVMainDecContext *const s = &rv->m;
     int seq, mb_pos, i, ret;
     int rpr_max;
 
@@ -366,7 +366,7 @@ static av_cold int rv10_decode_init(AVCodecContext *avctx)
 {
     static AVOnce init_static_once = AV_ONCE_INIT;
     RVDecContext *rv = avctx->priv_data;
-    MpegEncContext *s = &rv->m;
+    MPVMainDecContext *const s = &rv->m;
     int major_ver, minor_ver, micro_ver, ret;
 
     if (avctx->extradata_size < 8) {
@@ -432,7 +432,7 @@ static av_cold int rv10_decode_init(AVCodecContext *avctx)
 
 static av_cold int rv10_decode_end(AVCodecContext *avctx)
 {
-    MpegEncContext *s = avctx->priv_data;
+    MPVMainDecContext *const s = avctx->priv_data;
 
     ff_mpv_common_end(s);
     return 0;
@@ -442,7 +442,7 @@ static int rv10_decode_packet(AVCodecContext *avctx, const uint8_t *buf,
                               int buf_size, int buf_size2, int whole_size)
 {
     RVDecContext *rv = avctx->priv_data;
-    MpegEncContext *s = &rv->m;
+    MPVDecContext *const s = &rv->m;
     int mb_count, mb_pos, left, start_mb_x, active_bits_size, ret;
 
     active_bits_size = buf_size * 8;
@@ -596,7 +596,7 @@ static int rv10_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
 {
     const uint8_t *buf = avpkt->data;
     int buf_size       = avpkt->size;
-    MpegEncContext *s = avctx->priv_data;
+    MPVMainDecContext *const s = avctx->priv_data;
     AVFrame *pict = data;
     int i, ret;
     int slice_count;
diff --git a/libavcodec/rv10.h b/libavcodec/rv10.h
index 364270e76a..bbb0b97c7c 100644
--- a/libavcodec/rv10.h
+++ b/libavcodec/rv10.h
@@ -24,10 +24,11 @@
 #include <stdint.h>
 
 #include "mpegvideo.h"
+#include "mpegvideoenc.h"
 
-int ff_rv_decode_dc(MpegEncContext *s, int n);
+int ff_rv_decode_dc(MPVDecContext *s, int n);
 
-int ff_rv10_encode_picture_header(MpegEncContext *s, int picture_number);
-void ff_rv20_encode_picture_header(MpegEncContext *s, int picture_number);
+int ff_rv10_encode_picture_header(MPVMainEncContext *s, int picture_number);
+void ff_rv20_encode_picture_header(MPVMainEncContext *s, int picture_number);
 
 #endif /* AVCODEC_RV10_H */
diff --git a/libavcodec/rv10enc.c b/libavcodec/rv10enc.c
index 0c74da1b3c..25f3179196 100644
--- a/libavcodec/rv10enc.c
+++ b/libavcodec/rv10enc.c
@@ -30,7 +30,7 @@
 #include "put_bits.h"
 #include "rv10.h"
 
-int ff_rv10_encode_picture_header(MpegEncContext *s, int picture_number)
+int ff_rv10_encode_picture_header(MPVMainEncContext *s, int picture_number)
 {
     int full_frame= 0;
 
@@ -70,7 +70,7 @@ const AVCodec ff_rv10_encoder = {
     .type           = AVMEDIA_TYPE_VIDEO,
     .id             = AV_CODEC_ID_RV10,
     .priv_class     = &ff_mpv_enc_class,
-    .priv_data_size = sizeof(MpegEncContext),
+    .priv_data_size = sizeof(MPVMainEncContext),
     .init           = ff_mpv_encode_init,
     .encode2        = ff_mpv_encode_picture,
     .close          = ff_mpv_encode_end,
diff --git a/libavcodec/rv20enc.c b/libavcodec/rv20enc.c
index 9f935d61e2..22bcad9837 100644
--- a/libavcodec/rv20enc.c
+++ b/libavcodec/rv20enc.c
@@ -33,7 +33,8 @@
 #include "put_bits.h"
 #include "rv10.h"
 
-void ff_rv20_encode_picture_header(MpegEncContext *s, int picture_number){
+void ff_rv20_encode_picture_header(MPVMainEncContext *s, int picture_number)
+{
     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);
@@ -67,7 +68,7 @@ const AVCodec ff_rv20_encoder = {
     .type           = AVMEDIA_TYPE_VIDEO,
     .id             = AV_CODEC_ID_RV20,
     .priv_class     = &ff_mpv_enc_class,
-    .priv_data_size = sizeof(MpegEncContext),
+    .priv_data_size = sizeof(MPVMainEncContext),
     .init           = ff_mpv_encode_init,
     .encode2        = ff_mpv_encode_picture,
     .close          = ff_mpv_encode_end,
diff --git a/libavcodec/rv30.c b/libavcodec/rv30.c
index d11b8430e7..5c828741aa 100644
--- a/libavcodec/rv30.c
+++ b/libavcodec/rv30.c
@@ -116,7 +116,7 @@ static int rv30_decode_mb_info(RV34DecContext *r)
 {
     static const int rv30_p_types[6] = { RV34_MB_SKIP, RV34_MB_P_16x16, RV34_MB_P_8x8, -1, RV34_MB_TYPE_INTRA, RV34_MB_TYPE_INTRA16x16 };
     static const int rv30_b_types[6] = { RV34_MB_SKIP, RV34_MB_B_DIRECT, RV34_MB_B_FORWARD, RV34_MB_B_BACKWARD, RV34_MB_TYPE_INTRA, RV34_MB_TYPE_INTRA16x16 };
-    MpegEncContext *s = &r->s;
+    MPVDecContext *const s = &r->s;
     GetBitContext *gb = &s->gb;
     unsigned code = get_interleaved_ue_golomb(gb);
 
@@ -151,7 +151,7 @@ static inline void rv30_weak_loop_filter(uint8_t *src, const int step,
 
 static void rv30_loop_filter(RV34DecContext *r, int row)
 {
-    MpegEncContext *s = &r->s;
+    MPVDecContext *const s = &r->s;
     int mb_pos, mb_x;
     int i, j, k;
     uint8_t *Y, *C;
diff --git a/libavcodec/rv34.c b/libavcodec/rv34.c
index e68072de06..8ef80d5b34 100644
--- a/libavcodec/rv34.c
+++ b/libavcodec/rv34.c
@@ -345,7 +345,7 @@ static inline RV34VLC* choose_vlc_set(int quant, int mod, int type)
  */
 static int rv34_decode_intra_mb_header(RV34DecContext *r, int8_t *intra_types)
 {
-    MpegEncContext *s = &r->s;
+    MPVDecContext *const s = &r->s;
     GetBitContext *gb = &s->gb;
     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
     int t;
@@ -380,7 +380,7 @@ static int rv34_decode_intra_mb_header(RV34DecContext *r, int8_t *intra_types)
  */
 static int rv34_decode_inter_mb_header(RV34DecContext *r, int8_t *intra_types)
 {
-    MpegEncContext *s = &r->s;
+    MPVDecContext *const s = &r->s;
     GetBitContext *gb = &s->gb;
     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
     int i, t;
@@ -458,7 +458,7 @@ static const uint8_t avail_indexes[4] = { 6, 7, 10, 11 };
  */
 static void rv34_pred_mv(RV34DecContext *r, int block_type, int subblock_no, int dmv_no)
 {
-    MpegEncContext *s = &r->s;
+    MPVDecContext *const s = &r->s;
     int mv_pos = s->mb_x * 2 + s->mb_y * 2 * s->b8_stride;
     int A[2] = {0}, B[2], C[2];
     int i, j;
@@ -542,7 +542,7 @@ static inline void rv34_pred_b_vector(int A[2], int B[2], int C[2],
  */
 static void rv34_pred_mv_b(RV34DecContext *r, int block_type, int dir)
 {
-    MpegEncContext *s = &r->s;
+    MPVDecContext *const s = &r->s;
     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
     int mv_pos = s->mb_x * 2 + s->mb_y * 2 * s->b8_stride;
     int A[2] = { 0 }, B[2] = { 0 }, C[2] = { 0 };
@@ -594,7 +594,7 @@ static void rv34_pred_mv_b(RV34DecContext *r, int block_type, int dir)
  */
 static void rv34_pred_mv_rv3(RV34DecContext *r, int block_type, int dir)
 {
-    MpegEncContext *s = &r->s;
+    MPVDecContext *const s = &r->s;
     int mv_pos = s->mb_x * 2 + s->mb_y * 2 * s->b8_stride;
     int A[2] = {0}, B[2], C[2];
     int i, j, k;
@@ -662,7 +662,7 @@ static inline void rv34_mc(RV34DecContext *r, const int block_type,
                           qpel_mc_func (*qpel_mc)[16],
                           h264_chroma_mc_func (*chroma_mc))
 {
-    MpegEncContext *s = &r->s;
+    MPVDecContext *const s = &r->s;
     uint8_t *Y, *U, *V, *srcY, *srcU, *srcV;
     int dxy, mx, my, umx, umy, lx, ly, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
     int mv_pos = s->mb_x * 2 + s->mb_y * 2 * s->b8_stride + mv_off;
@@ -850,7 +850,7 @@ static const int num_mvs[RV34_MB_TYPES] = { 0, 0, 1, 4, 1, 1, 0, 0, 2, 2, 2, 1 }
  */
 static int rv34_decode_mv(RV34DecContext *r, int block_type)
 {
-    MpegEncContext *s = &r->s;
+    MPVDecContext *const s = &r->s;
     GetBitContext *gb = &s->gb;
     int i, j, k, l;
     int mv_pos = s->mb_x * 2 + s->mb_y * 2 * s->b8_stride;
@@ -1009,7 +1009,7 @@ static inline void rv34_process_block(RV34DecContext *r,
                                       uint8_t *pdst, int stride,
                                       int fc, int sc, int q_dc, int q_ac)
 {
-    MpegEncContext *s = &r->s;
+    MPVDecContext *const s = &r->s;
     int16_t *ptr = s->block[0];
     int has_ac = rv34_decode_block(ptr, &s->gb, r->cur_vlcs,
                                    fc, sc, q_dc, q_ac, q_ac);
@@ -1024,7 +1024,7 @@ static inline void rv34_process_block(RV34DecContext *r,
 static void rv34_output_i16x16(RV34DecContext *r, int8_t *intra_types, int cbp)
 {
     LOCAL_ALIGNED_16(int16_t, block16, [16]);
-    MpegEncContext *s    = &r->s;
+    MPVDecContext *const s    = &r->s;
     GetBitContext  *gb   = &s->gb;
     int             q_dc = rv34_qscale_tab[ r->luma_dc_quant_i[s->qscale] ],
                     q_ac = rv34_qscale_tab[s->qscale];
@@ -1086,7 +1086,7 @@ static void rv34_output_i16x16(RV34DecContext *r, int8_t *intra_types, int cbp)
 
 static void rv34_output_intra(RV34DecContext *r, int8_t *intra_types, int cbp)
 {
-    MpegEncContext *s   = &r->s;
+    MPVDecContext *const s   = &r->s;
     uint8_t        *dst = s->dest[0];
     int      avail[6*8] = {0};
     int i, j, k;
@@ -1162,7 +1162,7 @@ static int is_mv_diff_gt_3(int16_t (*motion_val)[2], int step)
 
 static int rv34_set_deblock_coef(RV34DecContext *r)
 {
-    MpegEncContext *s = &r->s;
+    MPVDecContext *const s = &r->s;
     int hmvmask = 0, vmvmask = 0, i, j;
     int midx = s->mb_x * 2 + s->mb_y * 2 * s->b8_stride;
     int16_t (*motion_val)[2] = &s->current_picture_ptr->motion_val[0][midx];
@@ -1192,7 +1192,7 @@ static int rv34_set_deblock_coef(RV34DecContext *r)
 
 static int rv34_decode_inter_macroblock(RV34DecContext *r, int8_t *intra_types)
 {
-    MpegEncContext *s   = &r->s;
+    MPVDecContext *const s   = &r->s;
     GetBitContext  *gb  = &s->gb;
     uint8_t        *dst = s->dest[0];
     int16_t        *ptr = s->block[0];
@@ -1300,7 +1300,7 @@ static int rv34_decode_inter_macroblock(RV34DecContext *r, int8_t *intra_types)
 
 static int rv34_decode_intra_macroblock(RV34DecContext *r, int8_t *intra_types)
 {
-    MpegEncContext *s = &r->s;
+    MPVDecContext *const s = &r->s;
     int cbp, dist;
     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
 
@@ -1338,7 +1338,7 @@ static int rv34_decode_intra_macroblock(RV34DecContext *r, int8_t *intra_types)
     return 0;
 }
 
-static int check_slice_end(RV34DecContext *r, MpegEncContext *s)
+static int check_slice_end(RV34DecContext *r, MPVDecContext *s)
 {
     int bits;
     if(s->mb_y >= s->mb_height)
@@ -1403,7 +1403,7 @@ static int rv34_decoder_realloc(RV34DecContext *r)
 
 static int rv34_decode_slice(RV34DecContext *r, int end, const uint8_t* buf, int buf_size)
 {
-    MpegEncContext *s = &r->s;
+    MPVDecContext *const s = &r->s;
     GetBitContext *gb = &s->gb;
     int mb_pos, slice_type;
     int res;
@@ -1487,7 +1487,7 @@ av_cold int ff_rv34_decode_init(AVCodecContext *avctx)
 {
     static AVOnce init_static_once = AV_ONCE_INIT;
     RV34DecContext *r = avctx->priv_data;
-    MpegEncContext *s = &r->s;
+    MPVMainDecContext *const s = &r->s;
     int ret;
 
     ff_mpv_decode_init(s, avctx);
@@ -1516,7 +1516,7 @@ av_cold int ff_rv34_decode_init(AVCodecContext *avctx)
 int ff_rv34_decode_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
 {
     RV34DecContext *r = dst->priv_data, *r1 = src->priv_data;
-    MpegEncContext * const s = &r->s, * const s1 = &r1->s;
+    MPVMainDecContext *const s = &r->s, *const s1 = &r1->s;
     int err;
 
     if (dst == src || !s1->context_initialized)
@@ -1557,7 +1557,7 @@ static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n, in
 static int finish_frame(AVCodecContext *avctx, AVFrame *pict)
 {
     RV34DecContext *r = avctx->priv_data;
-    MpegEncContext *s = &r->s;
+    MPVMainDecContext *const s = &r->s;
     int got_picture = 0, ret;
 
     ff_er_frame_end(&s->er);
@@ -1601,7 +1601,7 @@ int ff_rv34_decode_frame(AVCodecContext *avctx,
     const uint8_t *buf = avpkt->data;
     int buf_size = avpkt->size;
     RV34DecContext *r = avctx->priv_data;
-    MpegEncContext *s = &r->s;
+    MPVMainDecContext *const s = &r->s;
     AVFrame *pict = data;
     SliceInfo si;
     int i, ret;
diff --git a/libavcodec/rv34.h b/libavcodec/rv34.h
index 53b29dc245..32ec738597 100644
--- a/libavcodec/rv34.h
+++ b/libavcodec/rv34.h
@@ -84,7 +84,7 @@ typedef struct SliceInfo{
 
 /** decoder context */
 typedef struct RV34DecContext{
-    MpegEncContext s;
+    MPVMainDecContext s;
     RV34DSPContext rdsp;
     int8_t *intra_types_hist;///< old block types, used for prediction
     int8_t *intra_types;     ///< block types
diff --git a/libavcodec/rv40.c b/libavcodec/rv40.c
index 0b3f733bc6..56ad4f45e7 100644
--- a/libavcodec/rv40.c
+++ b/libavcodec/rv40.c
@@ -168,7 +168,7 @@ static int rv40_parse_slice_header(RV34DecContext *r, GetBitContext *gb, SliceIn
  */
 static int rv40_decode_intra_types(RV34DecContext *r, GetBitContext *gb, int8_t *dst)
 {
-    MpegEncContext *s = &r->s;
+    MPVDecContext *const s = &r->s;
     int i, j, k, v;
     int A, B, C;
     int pattern;
@@ -230,7 +230,7 @@ static int rv40_decode_intra_types(RV34DecContext *r, GetBitContext *gb, int8_t
  */
 static int rv40_decode_mb_info(RV34DecContext *r)
 {
-    MpegEncContext *s = &r->s;
+    MPVDecContext *const s = &r->s;
     GetBitContext *gb = &s->gb;
     int q, i;
     int prev_type = 0;
@@ -340,7 +340,7 @@ static void rv40_adaptive_loop_filter(RV34DSPContext *rdsp,
  */
 static void rv40_loop_filter(RV34DecContext *r, int row)
 {
-    MpegEncContext *s = &r->s;
+    MPVDecContext *const s = &r->s;
     int mb_pos, mb_x;
     int i, j, k;
     uint8_t *Y, *C;
diff --git a/libavcodec/snow.h b/libavcodec/snow.h
index f5beca66e9..2e09025277 100644
--- a/libavcodec/snow.h
+++ b/libavcodec/snow.h
@@ -32,7 +32,7 @@
 #include "rangecoder.h"
 #include "mathops.h"
 
-#include "mpegvideo.h"
+#include "mpegvideoenc.h"
 #include "h264qpel.h"
 
 #define SNOW_MAX_PLANES 4
@@ -182,7 +182,7 @@ typedef struct SnowContext{
     int iterative_dia_size;
     int scenechange_threshold;
 
-    MpegEncContext m; // needed for motion estimation, should not be used for anything else, the idea is to eventually make the motion estimation independent of MpegEncContext, so this will be removed then (FIXME/XXX)
+    MPVMainEncContext m; // needed for motion estimation, should not be used for anything else, the idea is to eventually make the motion estimation independent of mpegvideo, so this will be removed then (FIXME/XXX)
 
     uint8_t *scratchbuf;
     uint8_t *emu_edge_buffer;
diff --git a/libavcodec/snow_dwt.c b/libavcodec/snow_dwt.c
index c093ebff07..8d717b6bf8 100644
--- a/libavcodec/snow_dwt.c
+++ b/libavcodec/snow_dwt.c
@@ -25,6 +25,8 @@
 #include "me_cmp.h"
 #include "snow_dwt.h"
 
+#define MPVEncContext MPVContext
+
 int ff_slice_buffer_init(slice_buffer *buf, int line_count,
                          int max_allocated_lines, int line_width,
                          IDWTELEM *base_buffer)
@@ -740,7 +742,7 @@ void ff_spatial_idwt(IDWTELEM *buffer, IDWTELEM *temp, int width, int height,
                               decomposition_count, y);
 }
 
-static inline int w_c(struct MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, ptrdiff_t line_size,
+static inline int w_c(struct MPVEncContext *v, uint8_t *pix1, uint8_t *pix2, ptrdiff_t line_size,
                       int w, int h, int type)
 {
     int s, i, j;
@@ -809,32 +811,32 @@ static inline int w_c(struct MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, pt
     return s >> 9;
 }
 
-static int w53_8_c(struct MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, ptrdiff_t line_size, int h)
+static int w53_8_c(struct MPVEncContext *v, uint8_t *pix1, uint8_t *pix2, ptrdiff_t line_size, int h)
 {
     return w_c(v, pix1, pix2, line_size, 8, h, 1);
 }
 
-static int w97_8_c(struct MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, ptrdiff_t line_size, int h)
+static int w97_8_c(struct MPVEncContext *v, uint8_t *pix1, uint8_t *pix2, ptrdiff_t line_size, int h)
 {
     return w_c(v, pix1, pix2, line_size, 8, h, 0);
 }
 
-static int w53_16_c(struct MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, ptrdiff_t line_size, int h)
+static int w53_16_c(struct MPVEncContext *v, uint8_t *pix1, uint8_t *pix2, ptrdiff_t line_size, int h)
 {
     return w_c(v, pix1, pix2, line_size, 16, h, 1);
 }
 
-static int w97_16_c(struct MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, ptrdiff_t line_size, int h)
+static int w97_16_c(struct MPVEncContext *v, uint8_t *pix1, uint8_t *pix2, ptrdiff_t line_size, int h)
 {
     return w_c(v, pix1, pix2, line_size, 16, h, 0);
 }
 
-int ff_w53_32_c(struct MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, ptrdiff_t line_size, int h)
+int ff_w53_32_c(struct MPVEncContext *v, uint8_t *pix1, uint8_t *pix2, ptrdiff_t line_size, int h)
 {
     return w_c(v, pix1, pix2, line_size, 32, h, 1);
 }
 
-int ff_w97_32_c(struct MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, ptrdiff_t line_size, int h)
+int ff_w97_32_c(struct MPVEncContext *v, uint8_t *pix1, uint8_t *pix2, ptrdiff_t line_size, int h)
 {
     return w_c(v, pix1, pix2, line_size, 32, h, 0);
 }
diff --git a/libavcodec/snow_dwt.h b/libavcodec/snow_dwt.h
index 390bc57130..ef6690b0ca 100644
--- a/libavcodec/snow_dwt.h
+++ b/libavcodec/snow_dwt.h
@@ -24,7 +24,8 @@
 #include <stddef.h>
 #include <stdint.h>
 
-struct MpegEncContext;
+#define MPVEncContext MPVContext
+struct MPVEncContext;
 
 typedef int DWTELEM;
 typedef short IDWTELEM;
@@ -104,8 +105,8 @@ void ff_snow_inner_add_yblock(const uint8_t *obmc, const int obmc_stride,
                               int src_y, int src_stride, slice_buffer *sb,
                               int add, uint8_t *dst8);
 
-int ff_w53_32_c(struct MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, ptrdiff_t line_size, int h);
-int ff_w97_32_c(struct MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, ptrdiff_t line_size, int h);
+int ff_w53_32_c(struct MPVContext *v, uint8_t *pix1, uint8_t *pix2, ptrdiff_t line_size, int h);
+int ff_w97_32_c(struct MPVContext *v, uint8_t *pix1, uint8_t *pix2, ptrdiff_t line_size, int h);
 
 void ff_spatial_dwt(int *buffer, int *temp, int width, int height, int stride,
                     int type, int decomposition_count);
@@ -123,4 +124,6 @@ void ff_spatial_idwt(IDWTELEM *buffer, IDWTELEM *temp, int width, int height,
 void ff_dwt_init(SnowDWTContext *c);
 void ff_dwt_init_x86(SnowDWTContext *c);
 
+#undef MPVEncContext
+
 #endif /* AVCODEC_DWT_H */
diff --git a/libavcodec/speedhqenc.c b/libavcodec/speedhqenc.c
index ba3b1d9393..fb4d426b46 100644
--- a/libavcodec/speedhqenc.c
+++ b/libavcodec/speedhqenc.c
@@ -56,7 +56,7 @@ static uint32_t speedhq_chr_dc_uni[512];
 static uint8_t uni_speedhq_ac_vlc_len[64 * 64 * 2];
 
 typedef struct SpeedHQEncContext {
-    MpegEncContext m;
+    MPVMainEncContext m;
 
     int slice_start;
 } SpeedHQEncContext;
@@ -90,7 +90,7 @@ 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(MpegEncContext *s)
+av_cold int ff_speedhq_encode_init(MPVMainEncContext *s)
 {
     static AVOnce init_static_once = AV_ONCE_INIT;
 
@@ -128,7 +128,7 @@ av_cold int ff_speedhq_encode_init(MpegEncContext *s)
     return 0;
 }
 
-void ff_speedhq_encode_picture_header(MpegEncContext *s)
+void ff_speedhq_encode_picture_header(MPVMainEncContext *s)
 {
     SpeedHQEncContext *ctx = (SpeedHQEncContext*)s;
 
@@ -140,7 +140,7 @@ void ff_speedhq_encode_picture_header(MpegEncContext *s)
     put_bits_le(&s->pb, 24, 0);
 }
 
-void ff_speedhq_end_slice(MpegEncContext *s)
+void ff_speedhq_end_slice(MPVEncContext *s)
 {
     SpeedHQEncContext *ctx = (SpeedHQEncContext*)s;
     int slice_len;
@@ -188,7 +188,7 @@ static inline void encode_dc(PutBitContext *pb, int diff, int component)
     }
 }
 
-static void encode_block(MpegEncContext *s, int16_t *block, int n)
+static void encode_block(MPVEncContext *s, int16_t *block, int n)
 {
     int alevel, level, last_non_zero, dc, i, j, run, last_index, sign;
     int code;
@@ -237,7 +237,7 @@ static void encode_block(MpegEncContext *s, int16_t *block, int n)
     put_bits_le(&s->pb, 4, 6);
 }
 
-void ff_speedhq_encode_mb(MpegEncContext *s, int16_t block[12][64])
+void ff_speedhq_encode_mb(MPVEncContext *s, int16_t block[12][64])
 {
     int i;
     for(i=0;i<6;i++) {
diff --git a/libavcodec/speedhqenc.h b/libavcodec/speedhqenc.h
index 5100bb2d34..5ca8868f28 100644
--- a/libavcodec/speedhqenc.h
+++ b/libavcodec/speedhqenc.h
@@ -33,15 +33,15 @@
 
 #include "mjpeg.h"
 #include "mjpegenc_common.h"
-#include "mpegvideo.h"
+#include "mpegvideoenc.h"
 #include "put_bits.h"
 
-int  ff_speedhq_encode_init(MpegEncContext *s);
-void ff_speedhq_encode_close(MpegEncContext *s);
-void ff_speedhq_encode_mb(MpegEncContext *s, int16_t block[12][64]);
+int  ff_speedhq_encode_init(MPVMainEncContext *s);
+void ff_speedhq_encode_close(MPVMainEncContext *s);
+void ff_speedhq_encode_mb(MPVEncContext *s, int16_t block[12][64]);
 
-void ff_speedhq_encode_picture_header(MpegEncContext *s);
-void ff_speedhq_end_slice(MpegEncContext *s);
+void ff_speedhq_encode_picture_header(MPVMainEncContext *s);
+void ff_speedhq_end_slice(MPVEncContext *s);
 
 int ff_speedhq_mb_y_order_to_mb(int mb_y_order, int mb_height, int *first_in_slice);
 
diff --git a/libavcodec/svq1enc.c b/libavcodec/svq1enc.c
index 9cef3d8ef6..7af82bb3ac 100644
--- a/libavcodec/svq1enc.c
+++ b/libavcodec/svq1enc.c
@@ -237,7 +237,8 @@ static int encode_block(SVQ1EncContext *s, uint8_t *src, uint8_t *ref,
     return best_score;
 }
 
-static void init_block_index(MpegEncContext *s){
+static void init_block_index(MPVEncContext *s)
+{
     s->block_index[0]= s->b8_stride*(s->mb_y*2    )     + s->mb_x*2;
     s->block_index[1]= s->b8_stride*(s->mb_y*2    ) + 1 + s->mb_x*2;
     s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1)     + s->mb_x*2;
diff --git a/libavcodec/svq1enc.h b/libavcodec/svq1enc.h
index bb6af082d5..ee4a0b673c 100644
--- a/libavcodec/svq1enc.h
+++ b/libavcodec/svq1enc.h
@@ -29,14 +29,14 @@
 #include "avcodec.h"
 #include "hpeldsp.h"
 #include "me_cmp.h"
-#include "mpegvideo.h"
+#include "mpegvideoenc.h"
 #include "put_bits.h"
 
 typedef struct SVQ1EncContext {
     /* FIXME: Needed for motion estimation, should not be used for anything
      * else, the idea is to make the motion estimation eventually independent
-     * of MpegEncContext, so this will be removed then. */
-    MpegEncContext m;
+     * of MPVMainEncContext, so this will be removed then. */
+    MPVMainEncContext m;
     AVCodecContext *avctx;
     MECmpContext mecc;
     HpelDSPContext hdsp;
diff --git a/libavcodec/vaapi_mpeg2.c b/libavcodec/vaapi_mpeg2.c
index 26e0cd827c..057afdd878 100644
--- a/libavcodec/vaapi_mpeg2.c
+++ b/libavcodec/vaapi_mpeg2.c
@@ -27,21 +27,21 @@
 #include "vaapi_decode.h"
 
 /** Reconstruct bitstream f_code */
-static inline int mpeg2_get_f_code(const MpegEncContext *s)
+static inline int mpeg2_get_f_code(const MPVDecContext *s)
 {
     return (s->mpeg_f_code[0][0] << 12) | (s->mpeg_f_code[0][1] << 8) |
            (s->mpeg_f_code[1][0] <<  4) |  s->mpeg_f_code[1][1];
 }
 
 /** Determine frame start: first field for field picture or frame picture */
-static inline int mpeg2_get_is_frame_start(const MpegEncContext *s)
+static inline int mpeg2_get_is_frame_start(const MPVDecContext *s)
 {
     return s->first_field || s->picture_structure == PICT_FRAME;
 }
 
 static int vaapi_mpeg2_start_frame(AVCodecContext *avctx, av_unused const uint8_t *buffer, av_unused uint32_t size)
 {
-    const MpegEncContext *s = avctx->priv_data;
+    const MPVDecContext *const s = avctx->priv_data;
     VAAPIDecodePicture *pic = s->current_picture_ptr->hwaccel_picture_private;
     VAPictureParameterBufferMPEG2 pic_param;
     VAIQMatrixBufferMPEG2 iq_matrix;
@@ -114,7 +114,7 @@ fail:
 
 static int vaapi_mpeg2_end_frame(AVCodecContext *avctx)
 {
-    MpegEncContext     *s   = avctx->priv_data;
+    MPVDecContext  *const s = avctx->priv_data;
     VAAPIDecodePicture *pic = s->current_picture_ptr->hwaccel_picture_private;
     int ret;
 
@@ -130,7 +130,7 @@ fail:
 
 static int vaapi_mpeg2_decode_slice(AVCodecContext *avctx, const uint8_t *buffer, uint32_t size)
 {
-    const MpegEncContext *s = avctx->priv_data;
+    const MPVDecContext *const s = avctx->priv_data;
     VAAPIDecodePicture *pic = s->current_picture_ptr->hwaccel_picture_private;
     VASliceParameterBufferMPEG2 slice_param;
     GetBitContext gb;
diff --git a/libavcodec/vaapi_mpeg4.c b/libavcodec/vaapi_mpeg4.c
index 71e155154c..090902e29d 100644
--- a/libavcodec/vaapi_mpeg4.c
+++ b/libavcodec/vaapi_mpeg4.c
@@ -46,7 +46,7 @@ static int mpeg4_get_intra_dc_vlc_thr(Mpeg4DecContext *s)
 static int vaapi_mpeg4_start_frame(AVCodecContext *avctx, av_unused const uint8_t *buffer, av_unused uint32_t size)
 {
     Mpeg4DecContext *ctx = avctx->priv_data;
-    MpegEncContext *s = &ctx->m;
+    MPVDecContext *const s = &ctx->m;
     VAAPIDecodePicture *pic = s->current_picture_ptr->hwaccel_picture_private;
     VAPictureParameterBufferMPEG4 pic_param;
     int i, err;
@@ -136,7 +136,7 @@ fail:
 
 static int vaapi_mpeg4_end_frame(AVCodecContext *avctx)
 {
-    MpegEncContext *s = avctx->priv_data;
+    MPVDecContext *const s = avctx->priv_data;
     VAAPIDecodePicture *pic = s->current_picture_ptr->hwaccel_picture_private;
     int ret;
 
@@ -152,7 +152,7 @@ fail:
 
 static int vaapi_mpeg4_decode_slice(AVCodecContext *avctx, const uint8_t *buffer, uint32_t size)
 {
-    MpegEncContext *s = avctx->priv_data;
+    MPVDecContext *const s = avctx->priv_data;
     VAAPIDecodePicture *pic = s->current_picture_ptr->hwaccel_picture_private;
     VASliceParameterBufferMPEG4 slice_param;
     int err;
diff --git a/libavcodec/vaapi_vc1.c b/libavcodec/vaapi_vc1.c
index 4e9607d9be..3d0903333a 100644
--- a/libavcodec/vaapi_vc1.c
+++ b/libavcodec/vaapi_vc1.c
@@ -114,7 +114,7 @@ static inline int vc1_has_FORWARDMB_bitplane(const VC1Context *v)
 /** Reconstruct bitstream PTYPE (7.1.1.4, index into Table-35) */
 static int vc1_get_PTYPE(const VC1Context *v)
 {
-    const MpegEncContext *s = &v->s;
+    const MPVDecContext *const s = &v->s;
     switch (s->pict_type) {
     case AV_PICTURE_TYPE_I: return 0;
     case AV_PICTURE_TYPE_P: return v->p_frame_skipped ? 4 : 1;
@@ -126,7 +126,7 @@ static int vc1_get_PTYPE(const VC1Context *v)
 /** Reconstruct bitstream FPTYPE (9.1.1.42, index into Table-105) */
 static int vc1_get_FPTYPE(const VC1Context *v)
 {
-    const MpegEncContext *s = &v->s;
+    const MPVDecContext *const s = &v->s;
     switch (s->pict_type) {
     case AV_PICTURE_TYPE_I: return 0;
     case AV_PICTURE_TYPE_P: return 3;
@@ -250,7 +250,7 @@ static inline void vc1_pack_bitplanes(uint8_t *bitplane, int n, const uint8_t *f
 static int vaapi_vc1_start_frame(AVCodecContext *avctx, av_unused const uint8_t *buffer, av_unused uint32_t size)
 {
     const VC1Context *v = avctx->priv_data;
-    const MpegEncContext *s = &v->s;
+    const MPVDecContext *const s = &v->s;
     VAAPIDecodePicture *pic = s->current_picture_ptr->hwaccel_picture_private;
     VAPictureParameterBufferVC1 pic_param;
     int err;
@@ -447,7 +447,7 @@ fail:
 static int vaapi_vc1_end_frame(AVCodecContext *avctx)
 {
     VC1Context *v = avctx->priv_data;
-    MpegEncContext *s = &v->s;
+    MPVDecContext *const s = &v->s;
     VAAPIDecodePicture *pic = s->current_picture_ptr->hwaccel_picture_private;
     int ret;
 
@@ -464,7 +464,7 @@ fail:
 static int vaapi_vc1_decode_slice(AVCodecContext *avctx, const uint8_t *buffer, uint32_t size)
 {
     const VC1Context *v = avctx->priv_data;
-    const MpegEncContext *s = &v->s;
+    const MPVDecContext *const s = &v->s;
     VAAPIDecodePicture *pic = s->current_picture_ptr->hwaccel_picture_private;
     VASliceParameterBufferVC1 slice_param;
     int mb_height;
diff --git a/libavcodec/vc1.h b/libavcodec/vc1.h
index 9b25f0872f..25a043af56 100644
--- a/libavcodec/vc1.h
+++ b/libavcodec/vc1.h
@@ -171,7 +171,7 @@ enum Imode {
  * Many members are only used for Advanced Profile
  */
 typedef struct VC1Context{
-    MpegEncContext s;
+    MPVMainDecContext s;
     IntraX8Context x8;
     H264ChromaContext h264chroma;
     VC1DSPContext vc1dsp;
diff --git a/libavcodec/vc1_block.c b/libavcodec/vc1_block.c
index c922efe4c8..61dc4a5a20 100644
--- a/libavcodec/vc1_block.c
+++ b/libavcodec/vc1_block.c
@@ -58,7 +58,7 @@ static const int block_map[6] = {0, 2, 1, 3, 4, 5};
 
 static inline void init_block_index(VC1Context *v)
 {
-    MpegEncContext *s = &v->s;
+    MPVDecContext *const s = &v->s;
     ff_init_block_index(s);
     if (v->field_mode && !(v->second_field ^ v->tff)) {
         s->dest[0] += s->current_picture_ptr->f->linesize[0];
@@ -71,7 +71,7 @@ static inline void init_block_index(VC1Context *v)
 
 static void vc1_put_blocks_clamped(VC1Context *v, int put_signed)
 {
-    MpegEncContext *s = &v->s;
+    MPVDecContext *const s = &v->s;
     uint8_t *dest;
     int block_count = CONFIG_GRAY && (s->avctx->flags & AV_CODEC_FLAG_GRAY) ? 4 : 6;
     int fieldtx = 0;
@@ -329,14 +329,14 @@ static inline void vc1_b_mc(VC1Context *v, int dmv_x[2], int dmv_y[2],
 
 /** Get predicted DC value for I-frames only
  * prediction dir: left=0, top=1
- * @param s MpegEncContext
+ * @param s MPVDecContext
  * @param overlap flag indicating that overlap filtering is used
  * @param pq integer part of picture quantizer
  * @param[in] n block index in the current MB
  * @param dc_val_ptr Pointer to DC predictor
  * @param dir_ptr Prediction direction for use in AC prediction
  */
-static inline int vc1_i_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
+static inline int vc1_i_pred_dc(MPVDecContext *s, int overlap, int pq, int n,
                                 int16_t **dc_val_ptr, int *dir_ptr)
 {
     int a, b, c, wrap, pred, scale;
@@ -392,7 +392,7 @@ static inline int vc1_i_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
 
 /** Get predicted DC value
  * prediction dir: left=0, top=1
- * @param s MpegEncContext
+ * @param s MPVDecContext
  * @param overlap flag indicating that overlap filtering is used
  * @param pq integer part of picture quantizer
  * @param[in] n block index in the current MB
@@ -401,7 +401,7 @@ static inline int vc1_i_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
  * @param dc_val_ptr Pointer to DC predictor
  * @param dir_ptr Prediction direction for use in AC prediction
  */
-static inline int ff_vc1_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
+static inline int ff_vc1_pred_dc(MPVDecContext *s, int overlap, int pq, int n,
                               int a_avail, int c_avail,
                               int16_t **dc_val_ptr, int *dir_ptr)
 {
@@ -472,7 +472,7 @@ static inline int ff_vc1_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
  * @{
  */
 
-static inline int vc1_coded_block_pred(MpegEncContext * s, int n,
+static inline int vc1_coded_block_pred(MPVDecContext * s, int n,
                                        uint8_t **coded_block_ptr)
 {
     int xy, wrap, pred, a, b, c;
@@ -578,8 +578,8 @@ static int vc1_decode_ac_coeff(VC1Context *v, int *last, int *skip,
 static int vc1_decode_i_block(VC1Context *v, int16_t block[64], int n,
                               int coded, int codingset)
 {
+    MPVDecContext *const s = &v->s;
     GetBitContext *gb = &v->s.gb;
-    MpegEncContext *s = &v->s;
     int dc_pred_dir = 0; /* Direction of the DC prediction used */
     int i;
     int16_t *dc_val;
@@ -716,8 +716,8 @@ static int vc1_decode_i_block(VC1Context *v, int16_t block[64], int n,
 static int vc1_decode_i_block_adv(VC1Context *v, int16_t block[64], int n,
                                   int coded, int codingset, int mquant)
 {
+    MPVDecContext *const s = &v->s;
     GetBitContext *gb = &v->s.gb;
-    MpegEncContext *s = &v->s;
     int dc_pred_dir = 0; /* Direction of the DC prediction used */
     int i;
     int16_t *dc_val = NULL;
@@ -907,8 +907,8 @@ static int vc1_decode_i_block_adv(VC1Context *v, int16_t block[64], int n,
 static int vc1_decode_intra_block(VC1Context *v, int16_t block[64], int n,
                                   int coded, int mquant, int codingset)
 {
+    MPVDecContext *const s = &v->s;
     GetBitContext *gb = &v->s.gb;
-    MpegEncContext *s = &v->s;
     int dc_pred_dir = 0; /* Direction of the DC prediction used */
     int i;
     int16_t *dc_val = NULL;
@@ -1116,7 +1116,7 @@ static int vc1_decode_p_block(VC1Context *v, int16_t block[64], int n,
                               uint8_t *dst, int linesize, int skip_block,
                               int *ttmb_out)
 {
-    MpegEncContext *s = &v->s;
+    MPVDecContext *const s = &v->s;
     GetBitContext *gb = &s->gb;
     int i, j;
     int subblkpat = 0;
@@ -1285,7 +1285,7 @@ static const uint8_t size_table[6] = { 0, 2, 3, 4,  5,  8 };
  */
 static int vc1_decode_p_mb(VC1Context *v)
 {
-    MpegEncContext *s = &v->s;
+    MPVDecContext *const s = &v->s;
     GetBitContext *gb = &s->gb;
     int i, j;
     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
@@ -1517,7 +1517,7 @@ end:
 
 static int vc1_decode_p_mb_intfr(VC1Context *v)
 {
-    MpegEncContext *s = &v->s;
+    MPVDecContext *const s = &v->s;
     GetBitContext *gb = &s->gb;
     int i;
     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
@@ -1727,7 +1727,7 @@ static int vc1_decode_p_mb_intfr(VC1Context *v)
 
 static int vc1_decode_p_mb_intfi(VC1Context *v)
 {
-    MpegEncContext *s = &v->s;
+    MPVDecContext *const s = &v->s;
     GetBitContext *gb = &s->gb;
     int i;
     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
@@ -1851,7 +1851,7 @@ static int vc1_decode_p_mb_intfi(VC1Context *v)
  */
 static int vc1_decode_b_mb(VC1Context *v)
 {
-    MpegEncContext *s = &v->s;
+    MPVDecContext *const s = &v->s;
     GetBitContext *gb = &s->gb;
     int i, j;
     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
@@ -2009,7 +2009,7 @@ static int vc1_decode_b_mb(VC1Context *v)
  */
 static int vc1_decode_b_mb_intfi(VC1Context *v)
 {
-    MpegEncContext *s = &v->s;
+    MPVDecContext *const s = &v->s;
     GetBitContext *gb = &s->gb;
     int i, j;
     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
@@ -2176,7 +2176,7 @@ static int vc1_decode_b_mb_intfi(VC1Context *v)
  */
 static int vc1_decode_b_mb_intfr(VC1Context *v)
 {
-    MpegEncContext *s = &v->s;
+    MPVDecContext *const s = &v->s;
     GetBitContext *gb = &s->gb;
     int i, j;
     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
@@ -2526,8 +2526,8 @@ static int vc1_decode_b_mb_intfr(VC1Context *v)
  */
 static void vc1_decode_i_blocks(VC1Context *v)
 {
+    MPVDecContext *const s = &v->s;
     int k, j;
-    MpegEncContext *s = &v->s;
     int cbp, val;
     uint8_t *coded_val;
     int mb_pos;
@@ -2651,8 +2651,8 @@ static void vc1_decode_i_blocks(VC1Context *v)
  */
 static int vc1_decode_i_blocks_adv(VC1Context *v)
 {
+    MPVDecContext *const s = &v->s;
     int k;
-    MpegEncContext *s = &v->s;
     int cbp, val;
     uint8_t *coded_val;
     int mb_pos;
@@ -2794,7 +2794,7 @@ static int vc1_decode_i_blocks_adv(VC1Context *v)
 
 static void vc1_decode_p_blocks(VC1Context *v)
 {
-    MpegEncContext *s = &v->s;
+    MPVDecContext *const s = &v->s;
     int apply_loop_filter;
 
     /* select coding mode used for VLC tables selection */
@@ -2886,7 +2886,7 @@ static void vc1_decode_p_blocks(VC1Context *v)
 
 static void vc1_decode_b_blocks(VC1Context *v)
 {
-    MpegEncContext *s = &v->s;
+    MPVDecContext *const s = &v->s;
 
     /* select coding mode used for VLC tables selection */
     switch (v->c_ac_table_index) {
@@ -2970,7 +2970,7 @@ static void vc1_decode_b_blocks(VC1Context *v)
 
 static void vc1_decode_skip_blocks(VC1Context *v)
 {
-    MpegEncContext *s = &v->s;
+    MPVDecContext *const s = &v->s;
 
     if (!v->s.last_picture.f->data[0])
         return;
diff --git a/libavcodec/vc1_loopfilter.c b/libavcodec/vc1_loopfilter.c
index 0f990cccef..e5819b1042 100644
--- a/libavcodec/vc1_loopfilter.c
+++ b/libavcodec/vc1_loopfilter.c
@@ -104,7 +104,7 @@ static av_always_inline void vc1_v_overlap_filter(VC1Context *v, int16_t (*top_b
 
 void ff_vc1_i_overlap_filter(VC1Context *v)
 {
-    MpegEncContext *s = &v->s;
+    MPVDecContext *const s = &v->s;
     int16_t (*topleft_blk)[64], (*top_blk)[64], (*left_blk)[64], (*cur_blk)[64];
     int block_count = CONFIG_GRAY && (s->avctx->flags & AV_CODEC_FLAG_GRAY) ? 4 : 6;
     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
@@ -160,7 +160,7 @@ void ff_vc1_i_overlap_filter(VC1Context *v)
 
 void ff_vc1_p_overlap_filter(VC1Context *v)
 {
-    MpegEncContext *s = &v->s;
+    MPVDecContext *const s = &v->s;
     int16_t (*topleft_blk)[64], (*top_blk)[64], (*left_blk)[64], (*cur_blk)[64];
     int block_count = CONFIG_GRAY && (s->avctx->flags & AV_CODEC_FLAG_GRAY) ? 4 : 6;
     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
@@ -206,7 +206,7 @@ void ff_vc1_p_overlap_filter(VC1Context *v)
 static av_always_inline void vc1_i_h_loop_filter(VC1Context *v, uint8_t *dest,
                                                  uint32_t flags, int block_num)
 {
-    MpegEncContext *s  = &v->s;
+    MPVDecContext *const s  = &v->s;
     int pq = v->pq;
     uint8_t *dst;
 
@@ -239,7 +239,7 @@ static av_always_inline void vc1_i_v_loop_filter(VC1Context *v, uint8_t *dest,
                                                  uint32_t flags, uint8_t fieldtx,
                                                  int block_num)
 {
-    MpegEncContext *s  = &v->s;
+    MPVDecContext *const s  = &v->s;
     int pq = v->pq;
     uint8_t *dst;
 
@@ -270,7 +270,7 @@ static av_always_inline void vc1_i_v_loop_filter(VC1Context *v, uint8_t *dest,
 
 void ff_vc1_i_loop_filter(VC1Context *v)
 {
-    MpegEncContext *s = &v->s;
+    MPVDecContext *const s = &v->s;
     int block_count = CONFIG_GRAY && (s->avctx->flags & AV_CODEC_FLAG_GRAY) ? 4 : 6;
     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
     uint8_t *dest, fieldtx;
@@ -364,7 +364,7 @@ static av_always_inline void vc1_p_h_loop_filter(VC1Context *v, uint8_t *dest, u
                                                  uint8_t *is_intra, int16_t (*mv)[2], uint8_t *mv_f,
                                                  int *ttblk, uint32_t flags, int block_num)
 {
-    MpegEncContext *s  = &v->s;
+    MPVDecContext *const s  = &v->s;
     int pq = v->pq;
     uint32_t left_cbp = cbp[0] >> (block_num * 4), right_cbp;
     uint8_t left_is_intra, right_is_intra;
@@ -417,7 +417,7 @@ static av_always_inline void vc1_p_v_loop_filter(VC1Context *v, uint8_t *dest, u
                                                  uint8_t *is_intra, int16_t (*mv)[2], uint8_t *mv_f,
                                                  int *ttblk, uint32_t flags, int block_num)
 {
-    MpegEncContext *s  = &v->s;
+    MPVDecContext *const s  = &v->s;
     int pq = v->pq;
     uint32_t top_cbp = cbp[0] >> (block_num * 4), bottom_cbp;
     uint8_t top_is_intra, bottom_is_intra;
@@ -469,7 +469,7 @@ static av_always_inline void vc1_p_v_loop_filter(VC1Context *v, uint8_t *dest, u
 
 void ff_vc1_p_loop_filter(VC1Context *v)
 {
-    MpegEncContext *s = &v->s;
+    MPVDecContext *const s = &v->s;
     int block_count = CONFIG_GRAY && (s->avctx->flags & AV_CODEC_FLAG_GRAY) ? 4 : 6;
     uint8_t *dest;
     uint32_t *cbp;
@@ -802,7 +802,7 @@ void ff_vc1_p_loop_filter(VC1Context *v)
 static av_always_inline void vc1_p_h_intfr_loop_filter(VC1Context *v, uint8_t *dest, int *ttblk,
                                                        uint32_t flags, uint8_t fieldtx, int block_num)
 {
-    MpegEncContext *s  = &v->s;
+    MPVDecContext *const s  = &v->s;
     int pq = v->pq;
     int tt;
     int linesize  = block_num > 3 ? s->uvlinesize : s->linesize;
@@ -852,7 +852,7 @@ static av_always_inline void vc1_p_h_intfr_loop_filter(VC1Context *v, uint8_t *d
 static av_always_inline void vc1_p_v_intfr_loop_filter(VC1Context *v, uint8_t *dest, int *ttblk,
                                                        uint32_t flags, uint8_t fieldtx, int block_num)
 {
-    MpegEncContext *s  = &v->s;
+    MPVDecContext *const s  = &v->s;
     int pq = v->pq;
     int tt;
     int linesize  = block_num > 3 ? s->uvlinesize : s->linesize;
@@ -908,7 +908,7 @@ static av_always_inline void vc1_p_v_intfr_loop_filter(VC1Context *v, uint8_t *d
 
 void ff_vc1_p_intfr_loop_filter(VC1Context *v)
 {
-    MpegEncContext *s = &v->s;
+    MPVDecContext *const s = &v->s;
     int block_count = CONFIG_GRAY && (s->avctx->flags & AV_CODEC_FLAG_GRAY) ? 4 : 6;
     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
     uint8_t *dest;
@@ -1112,7 +1112,7 @@ void ff_vc1_p_intfr_loop_filter(VC1Context *v)
 static av_always_inline void vc1_b_h_intfi_loop_filter(VC1Context *v, uint8_t *dest, uint32_t *cbp,
                                                        int *ttblk, uint32_t flags, int block_num)
 {
-    MpegEncContext *s  = &v->s;
+    MPVDecContext *const s  = &v->s;
     int pq = v->pq;
     uint8_t *dst;
     uint32_t block_cbp = cbp[0] >> (block_num * 4);
@@ -1144,7 +1144,7 @@ static av_always_inline void vc1_b_h_intfi_loop_filter(VC1Context *v, uint8_t *d
 static av_always_inline void vc1_b_v_intfi_loop_filter(VC1Context *v, uint8_t *dest, uint32_t *cbp,
                                                        int *ttblk, uint32_t flags, int block_num)
 {
-    MpegEncContext *s  = &v->s;
+    MPVDecContext *const s  = &v->s;
     int pq = v->pq;
     uint8_t *dst;
     uint32_t block_cbp = cbp[0] >> (block_num * 4);
@@ -1171,7 +1171,7 @@ static av_always_inline void vc1_b_v_intfi_loop_filter(VC1Context *v, uint8_t *d
 
 void ff_vc1_b_intfi_loop_filter(VC1Context *v)
 {
-    MpegEncContext *s = &v->s;
+    MPVDecContext *const s = &v->s;
     int block_count = CONFIG_GRAY && (s->avctx->flags & AV_CODEC_FLAG_GRAY) ? 4 : 6;
     uint8_t *dest;
     uint32_t *cbp;
diff --git a/libavcodec/vc1_mc.c b/libavcodec/vc1_mc.c
index 1b8d8799b3..e9beb96e6d 100644
--- a/libavcodec/vc1_mc.c
+++ b/libavcodec/vc1_mc.c
@@ -107,7 +107,7 @@ static const uint8_t popcount4[16] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3,
 
 static av_always_inline int get_luma_mv(VC1Context *v, int dir, int16_t *tx, int16_t *ty)
 {
-    MpegEncContext *s = &v->s;
+    MPVDecContext *const s = &v->s;
     int idx = v->mv_f[dir][s->block_index[0] + v->blocks_off] |
              (v->mv_f[dir][s->block_index[1] + v->blocks_off] << 1) |
              (v->mv_f[dir][s->block_index[2] + v->blocks_off] << 2) |
@@ -139,7 +139,7 @@ static av_always_inline int get_luma_mv(VC1Context *v, int dir, int16_t *tx, int
 
 static av_always_inline int get_chroma_mv(VC1Context *v, int dir, int16_t *tx, int16_t *ty)
 {
-    MpegEncContext *s = &v->s;
+    MPVDecContext *const s = &v->s;
     int idx = !v->mb_type[0][s->block_index[0]] |
              (!v->mb_type[0][s->block_index[1]] << 1) |
              (!v->mb_type[0][s->block_index[2]] << 2) |
@@ -171,7 +171,7 @@ static av_always_inline int get_chroma_mv(VC1Context *v, int dir, int16_t *tx, i
  */
 void ff_vc1_mc_1mv(VC1Context *v, int dir)
 {
-    MpegEncContext *s = &v->s;
+    MPVDecContext *const s = &v->s;
     H264ChromaContext *h264chroma = &v->h264chroma;
     uint8_t *srcY, *srcU, *srcV;
     int dxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
@@ -451,7 +451,7 @@ void ff_vc1_mc_1mv(VC1Context *v, int dir)
  */
 void ff_vc1_mc_4mv_luma(VC1Context *v, int n, int dir, int avg)
 {
-    MpegEncContext *s = &v->s;
+    MPVDecContext *const s = &v->s;
     uint8_t *srcY;
     int dxy, mx, my, src_x, src_y;
     int off;
@@ -633,7 +633,7 @@ void ff_vc1_mc_4mv_luma(VC1Context *v, int n, int dir, int avg)
  */
 void ff_vc1_mc_4mv_chroma(VC1Context *v, int dir)
 {
-    MpegEncContext *s = &v->s;
+    MPVDecContext *const s = &v->s;
     H264ChromaContext *h264chroma = &v->h264chroma;
     uint8_t *srcU, *srcV;
     int uvmx, uvmy, uvsrc_x, uvsrc_y;
@@ -838,7 +838,7 @@ void ff_vc1_mc_4mv_chroma(VC1Context *v, int dir)
  */
 void ff_vc1_mc_4mv_chroma4(VC1Context *v, int dir, int dir2, int avg)
 {
-    MpegEncContext *s = &v->s;
+    MPVDecContext *const s = &v->s;
     H264ChromaContext *h264chroma = &v->h264chroma;
     uint8_t *srcU, *srcV;
     int uvsrc_x, uvsrc_y;
@@ -1003,7 +1003,7 @@ void ff_vc1_mc_4mv_chroma4(VC1Context *v, int dir, int dir2, int avg)
  */
 void ff_vc1_interp_mc(VC1Context *v)
 {
-    MpegEncContext *s = &v->s;
+    MPVDecContext *const s = &v->s;
     H264ChromaContext *h264chroma = &v->h264chroma;
     uint8_t *srcY, *srcU, *srcV;
     int dxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
diff --git a/libavcodec/vc1_pred.c b/libavcodec/vc1_pred.c
index ad2caf6db2..812118c7eb 100644
--- a/libavcodec/vc1_pred.c
+++ b/libavcodec/vc1_pred.c
@@ -213,7 +213,7 @@ void ff_vc1_pred_mv(VC1Context *v, int n, int dmv_x, int dmv_y,
                     int mv1, int r_x, int r_y, uint8_t* is_intra,
                     int pred_flag, int dir)
 {
-    MpegEncContext *s = &v->s;
+    MPVDecContext *const s = &v->s;
     int xy, wrap, off = 0;
     int16_t *A, *B, *C;
     int px, py;
@@ -470,7 +470,7 @@ void ff_vc1_pred_mv(VC1Context *v, int n, int dmv_x, int dmv_y,
 void ff_vc1_pred_mv_intfr(VC1Context *v, int n, int dmv_x, int dmv_y,
                           int mvn, int r_x, int r_y, int dir)
 {
-    MpegEncContext *s = &v->s;
+    MPVDecContext *const s = &v->s;
     int xy, wrap, off = 0;
     int A[2], B[2], C[2];
     int px = 0, py = 0;
@@ -691,7 +691,7 @@ void ff_vc1_pred_mv_intfr(VC1Context *v, int n, int dmv_x, int dmv_y,
 void ff_vc1_pred_b_mv(VC1Context *v, int dmv_x[2], int dmv_y[2],
                       int direct, int mvtype)
 {
-    MpegEncContext *s = &v->s;
+    MPVDecContext *const s = &v->s;
     int xy, wrap, off = 0;
     int16_t *A, *B, *C;
     int px, py;
@@ -892,7 +892,7 @@ void ff_vc1_pred_b_mv_intfi(VC1Context *v, int n, int *dmv_x, int *dmv_y,
                             int mv1, int *pred_flag)
 {
     int dir = (v->bmvtype == BMV_TYPE_BACKWARD) ? 1 : 0;
-    MpegEncContext *s = &v->s;
+    MPVDecContext *const s = &v->s;
     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
 
     if (v->bmvtype == BMV_TYPE_DIRECT) {
diff --git a/libavcodec/vc1dec.c b/libavcodec/vc1dec.c
index 7ed5133cfa..78a3422d18 100644
--- a/libavcodec/vc1dec.c
+++ b/libavcodec/vc1dec.c
@@ -179,7 +179,7 @@ static void vc1_draw_sprites(VC1Context *v, SpriteData* sd)
     uint8_t* src_h[2][2];
     int xoff[2], xadv[2], yoff[2], yadv[2], alpha;
     int ysub[2];
-    MpegEncContext *s = &v->s;
+    MPVDecContext *const s = &v->s;
 
     for (i = 0; i <= v->two_sprites; i++) {
         xoff[i] = av_clip(sd->coefs[i][2], 0, v->sprite_width-1 << 16);
@@ -271,8 +271,8 @@ static void vc1_draw_sprites(VC1Context *v, SpriteData* sd)
 
 static int vc1_decode_sprites(VC1Context *v, GetBitContext* gb)
 {
+    MPVDecContext *const s = &v->s;
     int ret;
-    MpegEncContext *s     = &v->s;
     AVCodecContext *avctx = s->avctx;
     SpriteData sd;
 
@@ -304,7 +304,7 @@ static int vc1_decode_sprites(VC1Context *v, GetBitContext* gb)
 static void vc1_sprite_flush(AVCodecContext *avctx)
 {
     VC1Context *v     = avctx->priv_data;
-    MpegEncContext *s = &v->s;
+    MPVDecContext *const s = &v->s;
     AVFrame *f = s->current_picture.f;
     int plane, i;
 
@@ -323,7 +323,7 @@ static void vc1_sprite_flush(AVCodecContext *avctx)
 
 av_cold int ff_vc1_decode_init_alloc_tables(VC1Context *v)
 {
-    MpegEncContext *s = &v->s;
+    MPVMainDecContext *const s = &v->s;
     int i, ret = AVERROR(ENOMEM);
     int mb_height = FFALIGN(s->mb_height, 2);
 
@@ -422,7 +422,7 @@ av_cold void ff_vc1_init_transposed_scantables(VC1Context *v)
 static av_cold int vc1_decode_init(AVCodecContext *avctx)
 {
     VC1Context *v = avctx->priv_data;
-    MpegEncContext *s = &v->s;
+    MPVMainDecContext *const s = &v->s;
     GetBitContext gb;
     int ret;
 
@@ -584,7 +584,6 @@ static av_cold int vc1_decode_init(AVCodecContext *avctx)
 }
 
 /** Close a VC1/WMV3 decoder
- * @warning Initial try at using MpegEncContext stuff
  */
 av_cold int ff_vc1_decode_end(AVCodecContext *avctx)
 {
@@ -625,7 +624,7 @@ static int vc1_decode_frame(AVCodecContext *avctx, void *data,
     const uint8_t *buf = avpkt->data;
     int buf_size = avpkt->size, n_slices = 0, i, ret;
     VC1Context *v = avctx->priv_data;
-    MpegEncContext *s = &v->s;
+    MPVMainDecContext *const s = &v->s;
     AVFrame *pict = data;
     uint8_t *buf2 = NULL;
     const uint8_t *buf_start = buf, *buf_start_second_field = NULL;
diff --git a/libavcodec/vdpau.c b/libavcodec/vdpau.c
index f96ac15e2a..95cd5c3bcd 100644
--- a/libavcodec/vdpau.c
+++ b/libavcodec/vdpau.c
@@ -366,7 +366,7 @@ int ff_vdpau_common_end_frame(AVCodecContext *avctx, AVFrame *frame,
     CONFIG_VC1_VDPAU_HWACCEL   || CONFIG_WMV3_VDPAU_HWACCEL
 int ff_vdpau_mpeg_end_frame(AVCodecContext *avctx)
 {
-    MpegEncContext *s = avctx->priv_data;
+    MPVDecContext *const s = avctx->priv_data;
     Picture *pic = s->current_picture_ptr;
     struct vdpau_picture_context *pic_ctx = pic->hwaccel_picture_private;
     int val;
diff --git a/libavcodec/vdpau_mpeg12.c b/libavcodec/vdpau_mpeg12.c
index 72220ffb4e..eb1a364470 100644
--- a/libavcodec/vdpau_mpeg12.c
+++ b/libavcodec/vdpau_mpeg12.c
@@ -32,7 +32,7 @@
 static int vdpau_mpeg_start_frame(AVCodecContext *avctx,
                                   const uint8_t *buffer, uint32_t size)
 {
-    MpegEncContext * const s = avctx->priv_data;
+    MPVDecContext *const s = avctx->priv_data;
     Picture *pic             = s->current_picture_ptr;
     struct vdpau_picture_context *pic_ctx = pic->hwaccel_picture_private;
     VdpPictureInfoMPEG1Or2 *info = &pic_ctx->info.mpeg;
@@ -83,7 +83,7 @@ static int vdpau_mpeg_start_frame(AVCodecContext *avctx,
 static int vdpau_mpeg_decode_slice(AVCodecContext *avctx,
                                    const uint8_t *buffer, uint32_t size)
 {
-    MpegEncContext * const s = avctx->priv_data;
+    MPVDecContext *const s = avctx->priv_data;
     Picture *pic             = s->current_picture_ptr;
     struct vdpau_picture_context *pic_ctx = pic->hwaccel_picture_private;
     int val;
diff --git a/libavcodec/vdpau_mpeg4.c b/libavcodec/vdpau_mpeg4.c
index 93b25beb1f..51676fe065 100644
--- a/libavcodec/vdpau_mpeg4.c
+++ b/libavcodec/vdpau_mpeg4.c
@@ -33,7 +33,7 @@ static int vdpau_mpeg4_start_frame(AVCodecContext *avctx,
                                    const uint8_t *buffer, uint32_t size)
 {
     Mpeg4DecContext *ctx = avctx->priv_data;
-    MpegEncContext * const s = &ctx->m;
+    MPVDecContext *const s = &ctx->m;
     Picture *pic             = s->current_picture_ptr;
     struct vdpau_picture_context *pic_ctx = pic->hwaccel_picture_private;
     VdpPictureInfoMPEG4Part2 *info = &pic_ctx->info.mpeg4;
diff --git a/libavcodec/vdpau_vc1.c b/libavcodec/vdpau_vc1.c
index 96c91b58be..e3aa36fbdd 100644
--- a/libavcodec/vdpau_vc1.c
+++ b/libavcodec/vdpau_vc1.c
@@ -33,7 +33,7 @@ static int vdpau_vc1_start_frame(AVCodecContext *avctx,
                                  const uint8_t *buffer, uint32_t size)
 {
     VC1Context * const v  = avctx->priv_data;
-    MpegEncContext * const s = &v->s;
+    MPVDecContext *const s = &v->s;
     Picture *pic          = s->current_picture_ptr;
     struct vdpau_picture_context *pic_ctx = pic->hwaccel_picture_private;
     VdpPictureInfoVC1 *info = &pic_ctx->info.vc1;
@@ -101,7 +101,7 @@ static int vdpau_vc1_decode_slice(AVCodecContext *avctx,
                                   const uint8_t *buffer, uint32_t size)
 {
     VC1Context * const v  = avctx->priv_data;
-    MpegEncContext * const s = &v->s;
+    MPVDecContext *const s = &v->s;
     Picture *pic          = s->current_picture_ptr;
     struct vdpau_picture_context *pic_ctx = pic->hwaccel_picture_private;
     int val;
diff --git a/libavcodec/videotoolbox.c b/libavcodec/videotoolbox.c
index 51d4eacfd8..f6d2805dba 100644
--- a/libavcodec/videotoolbox.c
+++ b/libavcodec/videotoolbox.c
@@ -1091,7 +1091,7 @@ static int videotoolbox_mpeg_decode_slice(AVCodecContext *avctx,
 
 static int videotoolbox_mpeg_end_frame(AVCodecContext *avctx)
 {
-    MpegEncContext *s = avctx->priv_data;
+    MPVDecContext *const s = avctx->priv_data;
     AVFrame *frame = s->current_picture_ptr->f;
 
     return ff_videotoolbox_common_end_frame(avctx, frame);
diff --git a/libavcodec/wmv2.c b/libavcodec/wmv2.c
index 8d1d117dea..29ed71f8aa 100644
--- a/libavcodec/wmv2.c
+++ b/libavcodec/wmv2.c
@@ -25,7 +25,7 @@
 #include "wmv2.h"
 
 
-av_cold void ff_wmv2_common_init(MpegEncContext *s)
+av_cold void ff_wmv2_common_init(MPVMainContext *s)
 {
     WMV2Context *const w = s->private_ctx;
 
@@ -47,7 +47,7 @@ av_cold void ff_wmv2_common_init(MpegEncContext *s)
     s->idsp.idct     = NULL;
 }
 
-void ff_mspel_motion(MpegEncContext *s, uint8_t *dest_y,
+void ff_mspel_motion(MPVContext *s, uint8_t *dest_y,
                      uint8_t *dest_cb, uint8_t *dest_cr,
                      uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
                      int motion_x, int motion_y, int h)
diff --git a/libavcodec/wmv2.h b/libavcodec/wmv2.h
index 4001093881..07b22644fc 100644
--- a/libavcodec/wmv2.h
+++ b/libavcodec/wmv2.h
@@ -22,6 +22,7 @@
 #define AVCODEC_WMV2_H
 
 #include "mpegvideo.h"
+#include "mpegvideoenc.h"
 #include "wmv2dsp.h"
 
 #define SKIP_TYPE_NONE 0
@@ -35,24 +36,24 @@ typedef struct WMV2Context {
     int hshift;
 } WMV2Context;
 
-void ff_wmv2_common_init(MpegEncContext *s);
+void ff_wmv2_common_init(MPVMainContext *s);
 
-int ff_wmv2_decode_mb(MpegEncContext *s, int16_t block[6][64]);
-int ff_wmv2_encode_picture_header(MpegEncContext * s, int picture_number);
-void ff_wmv2_encode_mb(MpegEncContext * s, int16_t block[6][64],
+int ff_wmv2_decode_mb(MPVDecContext *s, int16_t block[6][64]);
+int ff_wmv2_encode_picture_header(MPVMainEncContext * s, int picture_number);
+void ff_wmv2_encode_mb(MPVEncContext * s, int16_t block[6][64],
                        int motion_x, int motion_y);
-int ff_wmv2_decode_picture_header(MpegEncContext * s);
-int ff_wmv2_decode_secondary_picture_header(MpegEncContext * s);
-void ff_wmv2_add_mb(MpegEncContext *s, int16_t block[6][64],
+int ff_wmv2_decode_picture_header(MPVMainDecContext * s);
+int ff_wmv2_decode_secondary_picture_header(MPVMainDecContext * s);
+void ff_wmv2_add_mb(MPVContext *s, int16_t block[6][64],
                     uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr);
 
-void ff_mspel_motion(MpegEncContext *s,
+void ff_mspel_motion(MPVContext *s,
                      uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
                      uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
                      int motion_x, int motion_y, int h);
 
 
-static av_always_inline int wmv2_get_cbp_table_index(MpegEncContext *s, int cbp_index)
+static av_always_inline int wmv2_get_cbp_table_index(MPVContext *s, int cbp_index)
 {
     static const uint8_t map[3][3] = {
         { 0, 2, 1 },
diff --git a/libavcodec/wmv2dec.c b/libavcodec/wmv2dec.c
index f9d91f9571..00cb1cf6fc 100644
--- a/libavcodec/wmv2dec.c
+++ b/libavcodec/wmv2dec.c
@@ -34,7 +34,7 @@
 #include "wmv2data.h"
 
 typedef struct WMV2DecContext {
-    MpegEncContext s;
+    MPVMainDecContext s;
     WMV2Context common;
     IntraX8Context x8;
     int j_type_bit;
@@ -57,7 +57,7 @@ typedef struct WMV2DecContext {
 static void wmv2_add_block(WMV2DecContext *w, int16_t *block1,
                            uint8_t *dst, int stride, int n)
 {
-    MpegEncContext *const s = &w->s;
+    MPVDecContext *const s = &w->s;
 
     if (s->block_last_index[n] >= 0) {
         switch (w->abt_type_table[n]) {
@@ -80,7 +80,7 @@ static void wmv2_add_block(WMV2DecContext *w, int16_t *block1,
     }
 }
 
-void ff_wmv2_add_mb(MpegEncContext *s, int16_t block1[6][64],
+void ff_wmv2_add_mb(MPVDecContext *s, int16_t block1[6][64],
                     uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr)
 {
     WMV2DecContext *const w = (WMV2DecContext *) s;
@@ -101,7 +101,7 @@ static int parse_mb_skip(WMV2DecContext *w)
 {
     int mb_x, mb_y;
     int coded_mb_count = 0;
-    MpegEncContext *const s = &w->s;
+    MPVDecContext *const s = &w->s;
     uint32_t *const mb_type = s->current_picture_ptr->mb_type;
 
     w->skip_type = get_bits(&s->gb, 2);
@@ -164,7 +164,7 @@ static int parse_mb_skip(WMV2DecContext *w)
 
 static int decode_ext_header(WMV2DecContext *w)
 {
-    MpegEncContext *const s = &w->s;
+    MPVDecContext *const s = &w->s;
     GetBitContext gb;
     int fps;
     int code;
@@ -200,7 +200,7 @@ static int decode_ext_header(WMV2DecContext *w)
     return 0;
 }
 
-int ff_wmv2_decode_picture_header(MpegEncContext *s)
+int ff_wmv2_decode_picture_header(MPVMainDecContext *s)
 {
     WMV2DecContext *const w = (WMV2DecContext *) s;
     int code;
@@ -235,7 +235,7 @@ int ff_wmv2_decode_picture_header(MpegEncContext *s)
     return 0;
 }
 
-int ff_wmv2_decode_secondary_picture_header(MpegEncContext *s)
+int ff_wmv2_decode_secondary_picture_header(MPVMainDecContext *s)
 {
     WMV2DecContext *const w = (WMV2DecContext *) s;
 
@@ -347,7 +347,7 @@ int ff_wmv2_decode_secondary_picture_header(MpegEncContext *s)
 
 static inline void wmv2_decode_motion(WMV2DecContext *w, int *mx_ptr, int *my_ptr)
 {
-    MpegEncContext *const s = &w->s;
+    MPVDecContext *const s = &w->s;
 
     ff_msmpeg4_decode_motion(s, mx_ptr, my_ptr);
 
@@ -359,7 +359,7 @@ static inline void wmv2_decode_motion(WMV2DecContext *w, int *mx_ptr, int *my_pt
 
 static int16_t *wmv2_pred_motion(WMV2DecContext *w, int *px, int *py)
 {
-    MpegEncContext *const s = &w->s;
+    MPVDecContext *const s = &w->s;
     int xy, wrap, diff, type;
     int16_t *A, *B, *C, *mot_val;
 
@@ -405,7 +405,7 @@ static int16_t *wmv2_pred_motion(WMV2DecContext *w, int *px, int *py)
 static inline int wmv2_decode_inter_block(WMV2DecContext *w, int16_t *block,
                                           int n, int cbp)
 {
-    MpegEncContext *const s = &w->s;
+    MPVDecContext *const s = &w->s;
     static const int sub_cbp_table[3] = { 2, 3, 1 };
     int sub_cbp, ret;
 
@@ -442,7 +442,7 @@ static inline int wmv2_decode_inter_block(WMV2DecContext *w, int16_t *block,
     }
 }
 
-int ff_wmv2_decode_mb(MpegEncContext *s, int16_t block[6][64])
+int ff_wmv2_decode_mb(MPVDecContext *s, int16_t block[6][64])
 {
     /* The following is only allowed because this encoder
      * does not use slice threading. */
@@ -562,7 +562,7 @@ int ff_wmv2_decode_mb(MpegEncContext *s, int16_t block[6][64])
 static av_cold int wmv2_decode_init(AVCodecContext *avctx)
 {
     WMV2DecContext *const w = avctx->priv_data;
-    MpegEncContext *const s = &w->s;
+    MPVMainDecContext *const s = &w->s;
     int ret;
 
     s->private_ctx = &w->common;
diff --git a/libavcodec/wmv2enc.c b/libavcodec/wmv2enc.c
index d8481301e1..14f817f2d6 100644
--- a/libavcodec/wmv2enc.c
+++ b/libavcodec/wmv2enc.c
@@ -43,7 +43,7 @@ typedef struct WMV2EncContext {
 
 static int encode_ext_header(WMV2EncContext *w)
 {
-    MpegEncContext *const s = &w->msmpeg4.s;
+    MPVMainEncContext *const s = &w->msmpeg4.s;
     PutBitContext pb;
     int code;
 
@@ -70,7 +70,7 @@ static int encode_ext_header(WMV2EncContext *w)
 static av_cold int wmv2_encode_init(AVCodecContext *avctx)
 {
     WMV2EncContext *const w = avctx->priv_data;
-    MpegEncContext *const s = &w->msmpeg4.s;
+    MPVMainEncContext *const s = &w->msmpeg4.s;
 
     s->private_ctx = &w->common;
     if (ff_mpv_encode_init(avctx) < 0)
@@ -88,7 +88,7 @@ static av_cold int wmv2_encode_init(AVCodecContext *avctx)
     return 0;
 }
 
-int ff_wmv2_encode_picture_header(MpegEncContext *s, int picture_number)
+int ff_wmv2_encode_picture_header(MPVMainEncContext *s, int picture_number)
 {
     WMV2EncContext *const w = (WMV2EncContext *) s;
 
@@ -161,7 +161,7 @@ int ff_wmv2_encode_picture_header(MpegEncContext *s, int picture_number)
 /* Nearly identical to wmv1 but that is just because we do not use the
  * useless M$ crap features. It is duplicated here in case someone wants
  * to add support for these crap features. */
-void ff_wmv2_encode_mb(MpegEncContext *s, int16_t block[6][64],
+void ff_wmv2_encode_mb(MPVEncContext *s, int16_t block[6][64],
                        int motion_x, int motion_y)
 {
     WMV2EncContext *const w = (WMV2EncContext *) s;
diff --git a/libavcodec/x86/me_cmp.asm b/libavcodec/x86/me_cmp.asm
index ad06d485ab..08ffc10f79 100644
--- a/libavcodec/x86/me_cmp.asm
+++ b/libavcodec/x86/me_cmp.asm
@@ -214,7 +214,7 @@ hadamard8x8_diff %+ SUFFIX:
 hadamard8_16_wrapper %1, 3
 %elif cpuflag(mmx)
 ALIGN 16
-; int ff_hadamard8_diff_ ## cpu(MpegEncContext *s, uint8_t *src1,
+; int ff_hadamard8_diff_ ## cpu(MPVEncContext *s, uint8_t *src1,
 ;                               uint8_t *src2, ptrdiff_t stride, int h)
 ; r0 = void *s = unused, int h = unused (always 8)
 ; note how r1, r2 and r3 are not clobbered in this function, so 16x16
@@ -279,7 +279,7 @@ INIT_XMM ssse3
 %define ABS_SUM_8x8 ABS_SUM_8x8_64
 HADAMARD8_DIFF 9
 
-; int ff_sse*_*(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
+; int ff_sse*_*(MPVEncContext *v, uint8_t *pix1, uint8_t *pix2,
 ;               ptrdiff_t line_size, int h)
 
 %macro SUM_SQUARED_ERRORS 1
@@ -471,7 +471,7 @@ HF_NOISE 8
 HF_NOISE 16
 
 ;---------------------------------------------------------------------------------------
-;int ff_sad_<opt>(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, ptrdiff_t stride, int h);
+;int ff_sad_<opt>(MPVEncContext *v, uint8_t *pix1, uint8_t *pix2, ptrdiff_t stride, int h);
 ;---------------------------------------------------------------------------------------
 ;%1 = 8/16
 %macro SAD 1
@@ -526,7 +526,7 @@ INIT_XMM sse2
 SAD 16
 
 ;------------------------------------------------------------------------------------------
-;int ff_sad_x2_<opt>(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, ptrdiff_t stride, int h);
+;int ff_sad_x2_<opt>(MPVEncContext *v, uint8_t *pix1, uint8_t *pix2, ptrdiff_t stride, int h);
 ;------------------------------------------------------------------------------------------
 ;%1 = 8/16
 %macro SAD_X2 1
@@ -603,7 +603,7 @@ INIT_XMM sse2
 SAD_X2 16
 
 ;------------------------------------------------------------------------------------------
-;int ff_sad_y2_<opt>(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, ptrdiff_t stride, int h);
+;int ff_sad_y2_<opt>(MPVEncContext *v, uint8_t *pix1, uint8_t *pix2, ptrdiff_t stride, int h);
 ;------------------------------------------------------------------------------------------
 ;%1 = 8/16
 %macro SAD_Y2 1
@@ -673,7 +673,7 @@ INIT_XMM sse2
 SAD_Y2 16
 
 ;-------------------------------------------------------------------------------------------
-;int ff_sad_approx_xy2_<opt>(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, ptrdiff_t stride, int h);
+;int ff_sad_approx_xy2_<opt>(MPVEncContext *v, uint8_t *pix1, uint8_t *pix2, ptrdiff_t stride, int h);
 ;-------------------------------------------------------------------------------------------
 ;%1 = 8/16
 %macro SAD_APPROX_XY2 1
@@ -774,7 +774,7 @@ INIT_XMM sse2
 SAD_APPROX_XY2 16
 
 ;--------------------------------------------------------------------
-;int ff_vsad_intra(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
+;int ff_vsad_intra(MPVEncContext *v, uint8_t *pix1, uint8_t *pix2,
 ;                  ptrdiff_t line_size, int h);
 ;--------------------------------------------------------------------
 ; %1 = 8/16
@@ -835,7 +835,7 @@ INIT_XMM sse2
 VSAD_INTRA 16
 
 ;---------------------------------------------------------------------
-;int ff_vsad_approx(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
+;int ff_vsad_approx(MPVEncContext *v, uint8_t *pix1, uint8_t *pix2,
 ;                   ptrdiff_t line_size, int h);
 ;---------------------------------------------------------------------
 ; %1 = 8/16
diff --git a/libavcodec/x86/me_cmp_init.c b/libavcodec/x86/me_cmp_init.c
index 9af911bb88..f8709d5f57 100644
--- a/libavcodec/x86/me_cmp_init.c
+++ b/libavcodec/x86/me_cmp_init.c
@@ -28,61 +28,61 @@
 #include "libavutil/x86/asm.h"
 #include "libavutil/x86/cpu.h"
 #include "libavcodec/me_cmp.h"
-#include "libavcodec/mpegvideo.h"
+#include "libavcodec/mpegvideoenc.h"
 
 int ff_sum_abs_dctelem_mmx(int16_t *block);
 int ff_sum_abs_dctelem_mmxext(int16_t *block);
 int ff_sum_abs_dctelem_sse2(int16_t *block);
 int ff_sum_abs_dctelem_ssse3(int16_t *block);
-int ff_sse8_mmx(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
+int ff_sse8_mmx(MPVEncContext *v, uint8_t *pix1, uint8_t *pix2,
                 ptrdiff_t stride, int h);
-int ff_sse16_mmx(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
+int ff_sse16_mmx(MPVEncContext *v, uint8_t *pix1, uint8_t *pix2,
                  ptrdiff_t stride, int h);
-int ff_sse16_sse2(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
+int ff_sse16_sse2(MPVEncContext *v, uint8_t *pix1, uint8_t *pix2,
                   ptrdiff_t stride, int h);
 int ff_hf_noise8_mmx(uint8_t *pix1, ptrdiff_t stride, int h);
 int ff_hf_noise16_mmx(uint8_t *pix1, ptrdiff_t stride, int h);
-int ff_sad8_mmxext(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
+int ff_sad8_mmxext(MPVEncContext *v, uint8_t *pix1, uint8_t *pix2,
                    ptrdiff_t stride, int h);
-int ff_sad16_mmxext(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
+int ff_sad16_mmxext(MPVEncContext *v, uint8_t *pix1, uint8_t *pix2,
                     ptrdiff_t stride, int h);
-int ff_sad16_sse2(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
+int ff_sad16_sse2(MPVEncContext *v, uint8_t *pix1, uint8_t *pix2,
                   ptrdiff_t stride, int h);
-int ff_sad8_x2_mmxext(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
+int ff_sad8_x2_mmxext(MPVEncContext *v, uint8_t *pix1, uint8_t *pix2,
                       ptrdiff_t stride, int h);
-int ff_sad16_x2_mmxext(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
+int ff_sad16_x2_mmxext(MPVEncContext *v, uint8_t *pix1, uint8_t *pix2,
                        ptrdiff_t stride, int h);
-int ff_sad16_x2_sse2(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
+int ff_sad16_x2_sse2(MPVEncContext *v, uint8_t *pix1, uint8_t *pix2,
                      ptrdiff_t stride, int h);
-int ff_sad8_y2_mmxext(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
+int ff_sad8_y2_mmxext(MPVEncContext *v, uint8_t *pix1, uint8_t *pix2,
                       ptrdiff_t stride, int h);
-int ff_sad16_y2_mmxext(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
+int ff_sad16_y2_mmxext(MPVEncContext *v, uint8_t *pix1, uint8_t *pix2,
                        ptrdiff_t stride, int h);
-int ff_sad16_y2_sse2(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
+int ff_sad16_y2_sse2(MPVEncContext *v, uint8_t *pix1, uint8_t *pix2,
                      ptrdiff_t stride, int h);
-int ff_sad8_approx_xy2_mmxext(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
+int ff_sad8_approx_xy2_mmxext(MPVEncContext *v, uint8_t *pix1, uint8_t *pix2,
                               ptrdiff_t stride, int h);
-int ff_sad16_approx_xy2_mmxext(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
+int ff_sad16_approx_xy2_mmxext(MPVEncContext *v, uint8_t *pix1, uint8_t *pix2,
                                ptrdiff_t stride, int h);
-int ff_sad16_approx_xy2_sse2(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
+int ff_sad16_approx_xy2_sse2(MPVEncContext *v, uint8_t *pix1, uint8_t *pix2,
                              ptrdiff_t stride, int h);
-int ff_vsad_intra8_mmxext(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
+int ff_vsad_intra8_mmxext(MPVEncContext *v, uint8_t *pix1, uint8_t *pix2,
                           ptrdiff_t stride, int h);
-int ff_vsad_intra16_mmxext(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
+int ff_vsad_intra16_mmxext(MPVEncContext *v, uint8_t *pix1, uint8_t *pix2,
                            ptrdiff_t stride, int h);
-int ff_vsad_intra16_sse2(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
+int ff_vsad_intra16_sse2(MPVEncContext *v, uint8_t *pix1, uint8_t *pix2,
                          ptrdiff_t stride, int h);
-int ff_vsad8_approx_mmxext(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
+int ff_vsad8_approx_mmxext(MPVEncContext *v, uint8_t *pix1, uint8_t *pix2,
                     ptrdiff_t stride, int h);
-int ff_vsad16_approx_mmxext(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
+int ff_vsad16_approx_mmxext(MPVEncContext *v, uint8_t *pix1, uint8_t *pix2,
                      ptrdiff_t stride, int h);
-int ff_vsad16_approx_sse2(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
+int ff_vsad16_approx_sse2(MPVEncContext *v, uint8_t *pix1, uint8_t *pix2,
                    ptrdiff_t stride, int h);
 
 #define hadamard_func(cpu)                                                    \
-    int ff_hadamard8_diff_ ## cpu(MpegEncContext *s, uint8_t *src1,           \
+    int ff_hadamard8_diff_ ## cpu(MPVEncContext *s, uint8_t *src1,           \
                                   uint8_t *src2, ptrdiff_t stride, int h);    \
-    int ff_hadamard8_diff16_ ## cpu(MpegEncContext *s, uint8_t *src1,         \
+    int ff_hadamard8_diff16_ ## cpu(MPVEncContext *s, uint8_t *src1,         \
                                     uint8_t *src2, ptrdiff_t stride, int h);
 
 hadamard_func(mmx)
@@ -91,7 +91,7 @@ hadamard_func(sse2)
 hadamard_func(ssse3)
 
 #if HAVE_X86ASM
-static int nsse16_mmx(MpegEncContext *c, uint8_t *pix1, uint8_t *pix2,
+static int nsse16_mmx(MPVEncContext *c, uint8_t *pix1, uint8_t *pix2,
                       ptrdiff_t stride, int h)
 {
     int score1, score2;
@@ -109,7 +109,7 @@ static int nsse16_mmx(MpegEncContext *c, uint8_t *pix1, uint8_t *pix2,
         return score1 + FFABS(score2) * 8;
 }
 
-static int nsse8_mmx(MpegEncContext *c, uint8_t *pix1, uint8_t *pix2,
+static int nsse8_mmx(MPVEncContext *c, uint8_t *pix1, uint8_t *pix2,
                      ptrdiff_t stride, int h)
 {
     int score1 = ff_sse8_mmx(c, pix1, pix2, stride, h);
@@ -126,7 +126,7 @@ static int nsse8_mmx(MpegEncContext *c, uint8_t *pix1, uint8_t *pix2,
 
 #if HAVE_INLINE_ASM
 
-static int vsad_intra16_mmx(MpegEncContext *v, uint8_t *pix, uint8_t *dummy,
+static int vsad_intra16_mmx(MPVEncContext *v, uint8_t *pix, uint8_t *dummy,
                             ptrdiff_t stride, int h)
 {
     int tmp;
@@ -190,7 +190,7 @@ static int vsad_intra16_mmx(MpegEncContext *v, uint8_t *pix, uint8_t *dummy,
 }
 #undef SUM
 
-static int vsad16_mmx(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
+static int vsad16_mmx(MPVEncContext *v, uint8_t *pix1, uint8_t *pix2,
                       ptrdiff_t stride, int h)
 {
     int tmp;
@@ -434,7 +434,7 @@ static inline void sad8_y2a_mmx(uint8_t *blk1, uint8_t *blk2,
 }
 
 #define PIX_SAD(suf)                                                    \
-static int sad8_ ## suf(MpegEncContext *v, uint8_t *blk2,               \
+static int sad8_ ## suf(MPVEncContext *v, uint8_t *blk2,                \
                         uint8_t *blk1, ptrdiff_t stride, int h)         \
 {                                                                       \
     av_assert2(h == 8);                                                     \
@@ -448,7 +448,7 @@ static int sad8_ ## suf(MpegEncContext *v, uint8_t *blk2,               \
     return sum_ ## suf();                                               \
 }                                                                       \
                                                                         \
-static int sad8_x2_ ## suf(MpegEncContext *v, uint8_t *blk2,            \
+static int sad8_x2_ ## suf(MPVEncContext *v, uint8_t *blk2,             \
                            uint8_t *blk1, ptrdiff_t stride, int h)      \
 {                                                                       \
     av_assert2(h == 8);                                                     \
@@ -463,7 +463,7 @@ static int sad8_x2_ ## suf(MpegEncContext *v, uint8_t *blk2,            \
     return sum_ ## suf();                                               \
 }                                                                       \
                                                                         \
-static int sad8_y2_ ## suf(MpegEncContext *v, uint8_t *blk2,            \
+static int sad8_y2_ ## suf(MPVEncContext *v, uint8_t *blk2,             \
                            uint8_t *blk1, ptrdiff_t stride, int h)      \
 {                                                                       \
     av_assert2(h == 8);                                                     \
@@ -478,7 +478,7 @@ static int sad8_y2_ ## suf(MpegEncContext *v, uint8_t *blk2,            \
     return sum_ ## suf();                                               \
 }                                                                       \
                                                                         \
-static int sad8_xy2_ ## suf(MpegEncContext *v, uint8_t *blk2,           \
+static int sad8_xy2_ ## suf(MPVEncContext *v, uint8_t *blk2,            \
                             uint8_t *blk1, ptrdiff_t stride, int h)     \
 {                                                                       \
     av_assert2(h == 8);                                                     \
@@ -492,7 +492,7 @@ static int sad8_xy2_ ## suf(MpegEncContext *v, uint8_t *blk2,           \
     return sum_ ## suf();                                               \
 }                                                                       \
                                                                         \
-static int sad16_ ## suf(MpegEncContext *v, uint8_t *blk2,              \
+static int sad16_ ## suf(MPVEncContext *v, uint8_t *blk2,               \
                          uint8_t *blk1, ptrdiff_t stride, int h)        \
 {                                                                       \
     __asm__ volatile (                                                  \
@@ -506,7 +506,7 @@ static int sad16_ ## suf(MpegEncContext *v, uint8_t *blk2,              \
     return sum_ ## suf();                                               \
 }                                                                       \
                                                                         \
-static int sad16_x2_ ## suf(MpegEncContext *v, uint8_t *blk2,           \
+static int sad16_x2_ ## suf(MPVEncContext *v, uint8_t *blk2,            \
                             uint8_t *blk1, ptrdiff_t stride, int h)     \
 {                                                                       \
     __asm__ volatile (                                                  \
@@ -521,7 +521,7 @@ static int sad16_x2_ ## suf(MpegEncContext *v, uint8_t *blk2,           \
     return sum_ ## suf();                                               \
 }                                                                       \
                                                                         \
-static int sad16_y2_ ## suf(MpegEncContext *v, uint8_t *blk2,           \
+static int sad16_y2_ ## suf(MPVEncContext *v, uint8_t *blk2,            \
                             uint8_t *blk1, ptrdiff_t stride, int h)     \
 {                                                                       \
     __asm__ volatile (                                                  \
@@ -536,7 +536,7 @@ static int sad16_y2_ ## suf(MpegEncContext *v, uint8_t *blk2,           \
     return sum_ ## suf();                                               \
 }                                                                       \
                                                                         \
-static int sad16_xy2_ ## suf(MpegEncContext *v, uint8_t *blk2,          \
+static int sad16_xy2_ ## suf(MPVEncContext *v, uint8_t *blk2,           \
                              uint8_t *blk1, ptrdiff_t stride, int h)    \
 {                                                                       \
     __asm__ volatile (                                                  \
diff --git a/libavcodec/x86/mpegvideo.c b/libavcodec/x86/mpegvideo.c
index 73967cafda..bfd464704b 100644
--- a/libavcodec/x86/mpegvideo.c
+++ b/libavcodec/x86/mpegvideo.c
@@ -29,7 +29,7 @@
 
 #if HAVE_MMX_INLINE
 
-static void dct_unquantize_h263_intra_mmx(MpegEncContext *s,
+static void dct_unquantize_h263_intra_mmx(MPVContext *s,
                                   int16_t *block, int n, int qscale)
 {
     x86_reg level, qmul, qadd, nCoeffs;
@@ -104,7 +104,7 @@ __asm__ volatile(
 }
 
 
-static void dct_unquantize_h263_inter_mmx(MpegEncContext *s,
+static void dct_unquantize_h263_inter_mmx(MPVContext *s,
                                   int16_t *block, int n, int qscale)
 {
     x86_reg qmul, qadd, nCoeffs;
@@ -165,7 +165,7 @@ __asm__ volatile(
         );
 }
 
-static void dct_unquantize_mpeg1_intra_mmx(MpegEncContext *s,
+static void dct_unquantize_mpeg1_intra_mmx(MPVContext *s,
                                      int16_t *block, int n, int qscale)
 {
     x86_reg nCoeffs;
@@ -234,7 +234,7 @@ __asm__ volatile(
     block[0]= block0;
 }
 
-static void dct_unquantize_mpeg1_inter_mmx(MpegEncContext *s,
+static void dct_unquantize_mpeg1_inter_mmx(MPVContext *s,
                                      int16_t *block, int n, int qscale)
 {
     x86_reg nCoeffs;
@@ -300,7 +300,7 @@ __asm__ volatile(
         );
 }
 
-static void dct_unquantize_mpeg2_intra_mmx(MpegEncContext *s,
+static void dct_unquantize_mpeg2_intra_mmx(MPVContext *s,
                                      int16_t *block, int n, int qscale)
 {
     x86_reg nCoeffs;
@@ -369,7 +369,7 @@ __asm__ volatile(
         //Note, we do not do mismatch control for intra as errors cannot accumulate
 }
 
-static void dct_unquantize_mpeg2_inter_mmx(MpegEncContext *s,
+static void dct_unquantize_mpeg2_inter_mmx(MPVContext *s,
                                      int16_t *block, int n, int qscale)
 {
     x86_reg nCoeffs;
@@ -451,7 +451,7 @@ __asm__ volatile(
 
 #endif /* HAVE_MMX_INLINE */
 
-av_cold void ff_mpv_common_init_x86(MpegEncContext *s)
+av_cold void ff_mpv_common_init_x86(MPVMainContext *s)
 {
 #if HAVE_MMX_INLINE
     int cpu_flags = av_get_cpu_flags();
diff --git a/libavcodec/x86/mpegvideoenc.c b/libavcodec/x86/mpegvideoenc.c
index 3691cce26c..7c0cf27e30 100644
--- a/libavcodec/x86/mpegvideoenc.c
+++ b/libavcodec/x86/mpegvideoenc.c
@@ -97,7 +97,8 @@ DECLARE_ALIGNED(16, static const uint16_t, inv_zigzag_direct16)[64] = {
 
 #if HAVE_INLINE_ASM
 #if HAVE_MMX_INLINE
-static void  denoise_dct_mmx(MpegEncContext *s, int16_t *block){
+static void  denoise_dct_mmx(MPVEncContext *s, int16_t *block)
+{
     const int intra= s->mb_intra;
     int *sum= s->dct_error_sum[intra];
     uint16_t *offset= s->dct_offset[intra];
@@ -153,7 +154,8 @@ static void  denoise_dct_mmx(MpegEncContext *s, int16_t *block){
 #endif /* HAVE_MMX_INLINE */
 
 #if HAVE_SSE2_INLINE
-static void  denoise_dct_sse2(MpegEncContext *s, int16_t *block){
+static void  denoise_dct_sse2(MPVEncContext *s, int16_t *block)
+{
     const int intra= s->mb_intra;
     int *sum= s->dct_error_sum[intra];
     uint16_t *offset= s->dct_offset[intra];
@@ -211,7 +213,7 @@ static void  denoise_dct_sse2(MpegEncContext *s, int16_t *block){
 #endif /* HAVE_SSE2_INLINE */
 #endif /* HAVE_INLINE_ASM */
 
-av_cold void ff_dct_encode_init_x86(MpegEncContext *s)
+av_cold void ff_dct_encode_init_x86(MPVEncContext *s)
 {
     const int dct_algo = s->avctx->dct_algo;
 
diff --git a/libavcodec/x86/mpegvideoenc_template.c b/libavcodec/x86/mpegvideoenc_template.c
index 30c06a6b2c..19a0d3ac7e 100644
--- a/libavcodec/x86/mpegvideoenc_template.c
+++ b/libavcodec/x86/mpegvideoenc_template.c
@@ -100,7 +100,7 @@
             "psubw "a", "b"             \n\t" // out=((ABS(block[i])*qmat[0] - bias[0]*qmat[0])>>16)*sign(block[i])
 #endif
 
-static int RENAME(dct_quantize)(MpegEncContext *s,
+static int RENAME(dct_quantize)(MPVEncContext *s,
                             int16_t *block, int n,
                             int qscale, int *overflow)
 {
diff --git a/libavcodec/xvmc_internal.h b/libavcodec/xvmc_internal.h
index d365ef0266..ec9efdc471 100644
--- a/libavcodec/xvmc_internal.h
+++ b/libavcodec/xvmc_internal.h
@@ -21,11 +21,9 @@
 #ifndef AVCODEC_XVMC_INTERNAL_H
 #define AVCODEC_XVMC_INTERNAL_H
 
-#include "avcodec.h"
 #include "mpegvideo.h"
-#include "version.h"
 
-void ff_xvmc_init_block(MpegEncContext *s);
-void ff_xvmc_pack_pblocks(MpegEncContext *s, int cbp);
+void ff_xvmc_init_block(MPVDecContext *s);
+void ff_xvmc_pack_pblocks(MPVDecContext *s, int cbp);
 
 #endif /* AVCODEC_XVMC_INTERNAL_H */
-- 
2.32.0

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

Re: [FFmpeg-devel] [PATCH 16/41] avcodec/mpegvideo: Use typedefs for MPV(Main)?(Dec|Enc)?Context

[Michael Niedermayer]

[-- Attachment #1.1: Type: text/plain, Size: 5856 bytes --]

On Sun, Jan 30, 2022 at 07:27:24AM +0100, Andreas Rheinhardt wrote:
> This is in preparation for actually adding such contexts
> and e.g. moving fields only used by the main thread to
> the corresponding "Main" context.
> 
> Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>

This breaks build on mingw64

src/libavcodec/dxva2_mpeg2.c:42:50: warning: ‘struct MPVDecContext’ declared inside parameter list will not be visible outside of this definition or declaration
                                     const struct MPVDecContext *s,
                                                  ^~~~~~~~~~~~~
src/libavcodec/dxva2_mpeg2.c: In function ‘fill_picture_parameters’:
src/libavcodec/dxva2_mpeg2.c:45:39: error: dereferencing pointer to incomplete type ‘const struct MPVDecContext’
     const Picture *current_picture = s->current_picture_ptr;
                                       ^~
src/libavcodec/dxva2_mpeg2.c: At top level:
src/libavcodec/dxva2_mpeg2.c:108:53: warning: ‘struct MPVDecContext’ declared inside parameter list will not be visible outside of this definition or declaration
                                        const struct MPVDecContext *s,
                                                     ^~~~~~~~~~~~~
src/libavcodec/dxva2_mpeg2.c: In function ‘fill_quantization_matrices’:
src/libavcodec/dxva2_mpeg2.c:115:18: error: dereferencing pointer to incomplete type ‘const struct MPVDecContext’
         int n = s->idsp.idct_permutation[ff_zigzag_direct[i]];
                  ^~
src/libavcodec/dxva2_mpeg2.c:115:13: warning: variable ‘n’ set but not used [-Wunused-but-set-variable]
         int n = s->idsp.idct_permutation[ff_zigzag_direct[i]];
             ^
src/libavcodec/dxva2_mpeg2.c: At top level:
src/libavcodec/dxva2_mpeg2.c:124:37: warning: ‘struct MPVDecContext’ declared inside parameter list will not be visible outside of this definition or declaration
                        const struct MPVDecContext *s,
                                     ^~~~~~~~~~~~~
src/libavcodec/dxva2_mpeg2.c: In function ‘fill_slice’:
src/libavcodec/dxva2_mpeg2.c:129:21: error: dereferencing pointer to incomplete type ‘const struct MPVDecContext’
     int is_field = s->picture_structure != PICT_FRAME;
                     ^~
src/libavcodec/dxva2_mpeg2.c: In function ‘commit_bitstream_and_slice_buffer’:
src/libavcodec/dxva2_mpeg2.c:157:10: error: dereferencing pointer to incomplete type ‘const struct MPVDecContext’
         s->current_picture_ptr->hwaccel_picture_private;
          ^~
src/libavcodec/dxva2_mpeg2.c: In function ‘dxva2_mpeg2_start_frame’:
src/libavcodec/dxva2_mpeg2.c:260:10: error: dereferencing pointer to incomplete type ‘const struct MPVDecContext’
         s->current_picture_ptr->hwaccel_picture_private;
          ^~
src/libavcodec/dxva2_mpeg2.c:266:41: warning: passing argument 3 of ‘fill_picture_parameters’ from incompatible pointer type [-Wincompatible-pointer-types]
     fill_picture_parameters(avctx, ctx, s, &ctx_pic->pp);
                                         ^
src/libavcodec/dxva2_mpeg2.c:40:13: note: expected ‘const struct MPVDecContext *’ but argument is of type ‘const struct MPVDecContext * const’
 static void fill_picture_parameters(AVCodecContext *avctx,
             ^~~~~~~~~~~~~~~~~~~~~~~
src/libavcodec/dxva2_mpeg2.c:267:44: warning: passing argument 3 of ‘fill_quantization_matrices’ from incompatible pointer type [-Wincompatible-pointer-types]
     fill_quantization_matrices(avctx, ctx, s, &ctx_pic->qm);
                                            ^
src/libavcodec/dxva2_mpeg2.c:106:13: note: expected ‘const struct MPVDecContext *’ but argument is of type ‘const struct MPVDecContext * const’
 static void fill_quantization_matrices(AVCodecContext *avctx,
             ^~~~~~~~~~~~~~~~~~~~~~~~~~
src/libavcodec/dxva2_mpeg2.c: In function ‘dxva2_mpeg2_decode_slice’:
src/libavcodec/dxva2_mpeg2.c:280:10: error: dereferencing pointer to incomplete type ‘const struct MPVDecContext’
         s->current_picture_ptr->hwaccel_picture_private;
          ^~
src/libavcodec/dxva2_mpeg2.c:293:23: warning: passing argument 2 of ‘fill_slice’ from incompatible pointer type [-Wincompatible-pointer-types]
     fill_slice(avctx, s, &ctx_pic->slice[ctx_pic->slice_count++], position,
                       ^
src/libavcodec/dxva2_mpeg2.c:123:13: note: expected ‘const struct MPVDecContext *’ but argument is of type ‘const struct MPVDecContext * const’
 static void fill_slice(AVCodecContext *avctx,
             ^~~~~~~~~~
src/libavcodec/dxva2_mpeg2.c: In function ‘dxva2_mpeg2_end_frame’:
src/libavcodec/dxva2_mpeg2.c:302:10: error: dereferencing pointer to incomplete type ‘struct MPVDecContext’
         s->current_picture_ptr->hwaccel_picture_private;
          ^~
src/libavcodec/dxva2_mpeg2.c:312:33: warning: passing argument 1 of ‘ff_mpeg_draw_horiz_band’ from incompatible pointer type [-Wincompatible-pointer-types]
         ff_mpeg_draw_horiz_band(s, 0, avctx->height);
                                 ^
In file included from src/libavcodec/dxva2_mpeg2.c:27:0:
src/libavcodec/mpegvideo.h:606:6: note: expected ‘MPVContext * {aka struct MPVContext *}’ but argument is of type ‘struct MPVDecContext * const’
 void ff_mpeg_draw_horiz_band(MPVContext *s, int y, int h);
      ^~~~~~~~~~~~~~~~~~~~~~~
src/ffbuild/common.mak:78: recipe for target 'libavcodec/dxva2_mpeg2.o' failed
make: *** [libavcodec/dxva2_mpeg2.o] Error 1
make: *** Waiting for unfinished jobs....

[...]
-- 
Michael     GnuPG fingerprint: 9FF2128B147EF6730BADF133611EC787040B0FAB

If you think the mosad wants you dead since a long time then you are either
wrong or dead since a long time.

[-- Attachment #1.2: signature.asc --]
[-- Type: application/pgp-signature, Size: 195 bytes --]

[-- Attachment #2: Type: text/plain, Size: 251 bytes --]

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

Re: [FFmpeg-devel] [PATCH 16/41] avcodec/mpegvideo: Use typedefs for MPV(Main)?(Dec|Enc)?Context

[Andreas Rheinhardt]

Michael Niedermayer:
> On Sun, Jan 30, 2022 at 07:27:24AM +0100, Andreas Rheinhardt wrote:
>> This is in preparation for actually adding such contexts
>> and e.g. moving fields only used by the main thread to
>> the corresponding "Main" context.
>>
>> Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
> 
> This breaks build on mingw64
> 
> src/libavcodec/dxva2_mpeg2.c:42:50: warning: ‘struct MPVDecContext’ declared inside parameter list will not be visible outside of this definition or declaration
>                                      const struct MPVDecContext *s,
>                                                   ^~~~~~~~~~~~~
> src/libavcodec/dxva2_mpeg2.c: In function ‘fill_picture_parameters’:
> src/libavcodec/dxva2_mpeg2.c:45:39: error: dereferencing pointer to incomplete type ‘const struct MPVDecContext’
>      const Picture *current_picture = s->current_picture_ptr;
>                                        ^~
> src/libavcodec/dxva2_mpeg2.c: At top level:
> src/libavcodec/dxva2_mpeg2.c:108:53: warning: ‘struct MPVDecContext’ declared inside parameter list will not be visible outside of this definition or declaration
>                                         const struct MPVDecContext *s,
>                                                      ^~~~~~~~~~~~~
> src/libavcodec/dxva2_mpeg2.c: In function ‘fill_quantization_matrices’:
> src/libavcodec/dxva2_mpeg2.c:115:18: error: dereferencing pointer to incomplete type ‘const struct MPVDecContext’
>          int n = s->idsp.idct_permutation[ff_zigzag_direct[i]];
>                   ^~
> src/libavcodec/dxva2_mpeg2.c:115:13: warning: variable ‘n’ set but not used [-Wunused-but-set-variable]
>          int n = s->idsp.idct_permutation[ff_zigzag_direct[i]];
>              ^
> src/libavcodec/dxva2_mpeg2.c: At top level:
> src/libavcodec/dxva2_mpeg2.c:124:37: warning: ‘struct MPVDecContext’ declared inside parameter list will not be visible outside of this definition or declaration
>                         const struct MPVDecContext *s,
>                                      ^~~~~~~~~~~~~
> src/libavcodec/dxva2_mpeg2.c: In function ‘fill_slice’:
> src/libavcodec/dxva2_mpeg2.c:129:21: error: dereferencing pointer to incomplete type ‘const struct MPVDecContext’
>      int is_field = s->picture_structure != PICT_FRAME;
>                      ^~
> src/libavcodec/dxva2_mpeg2.c: In function ‘commit_bitstream_and_slice_buffer’:
> src/libavcodec/dxva2_mpeg2.c:157:10: error: dereferencing pointer to incomplete type ‘const struct MPVDecContext’
>          s->current_picture_ptr->hwaccel_picture_private;
>           ^~
> src/libavcodec/dxva2_mpeg2.c: In function ‘dxva2_mpeg2_start_frame’:
> src/libavcodec/dxva2_mpeg2.c:260:10: error: dereferencing pointer to incomplete type ‘const struct MPVDecContext’
>          s->current_picture_ptr->hwaccel_picture_private;
>           ^~
> src/libavcodec/dxva2_mpeg2.c:266:41: warning: passing argument 3 of ‘fill_picture_parameters’ from incompatible pointer type [-Wincompatible-pointer-types]
>      fill_picture_parameters(avctx, ctx, s, &ctx_pic->pp);
>                                          ^
> src/libavcodec/dxva2_mpeg2.c:40:13: note: expected ‘const struct MPVDecContext *’ but argument is of type ‘const struct MPVDecContext * const’
>  static void fill_picture_parameters(AVCodecContext *avctx,
>              ^~~~~~~~~~~~~~~~~~~~~~~
> src/libavcodec/dxva2_mpeg2.c:267:44: warning: passing argument 3 of ‘fill_quantization_matrices’ from incompatible pointer type [-Wincompatible-pointer-types]
>      fill_quantization_matrices(avctx, ctx, s, &ctx_pic->qm);
>                                             ^
> src/libavcodec/dxva2_mpeg2.c:106:13: note: expected ‘const struct MPVDecContext *’ but argument is of type ‘const struct MPVDecContext * const’
>  static void fill_quantization_matrices(AVCodecContext *avctx,
>              ^~~~~~~~~~~~~~~~~~~~~~~~~~
> src/libavcodec/dxva2_mpeg2.c: In function ‘dxva2_mpeg2_decode_slice’:
> src/libavcodec/dxva2_mpeg2.c:280:10: error: dereferencing pointer to incomplete type ‘const struct MPVDecContext’
>          s->current_picture_ptr->hwaccel_picture_private;
>           ^~
> src/libavcodec/dxva2_mpeg2.c:293:23: warning: passing argument 2 of ‘fill_slice’ from incompatible pointer type [-Wincompatible-pointer-types]
>      fill_slice(avctx, s, &ctx_pic->slice[ctx_pic->slice_count++], position,
>                        ^
> src/libavcodec/dxva2_mpeg2.c:123:13: note: expected ‘const struct MPVDecContext *’ but argument is of type ‘const struct MPVDecContext * const’
>  static void fill_slice(AVCodecContext *avctx,
>              ^~~~~~~~~~
> src/libavcodec/dxva2_mpeg2.c: In function ‘dxva2_mpeg2_end_frame’:
> src/libavcodec/dxva2_mpeg2.c:302:10: error: dereferencing pointer to incomplete type ‘struct MPVDecContext’
>          s->current_picture_ptr->hwaccel_picture_private;
>           ^~
> src/libavcodec/dxva2_mpeg2.c:312:33: warning: passing argument 1 of ‘ff_mpeg_draw_horiz_band’ from incompatible pointer type [-Wincompatible-pointer-types]
>          ff_mpeg_draw_horiz_band(s, 0, avctx->height);
>                                  ^
> In file included from src/libavcodec/dxva2_mpeg2.c:27:0:
> src/libavcodec/mpegvideo.h:606:6: note: expected ‘MPVContext * {aka struct MPVContext *}’ but argument is of type ‘struct MPVDecContext * const’
>  void ff_mpeg_draw_horiz_band(MPVContext *s, int y, int h);
>       ^~~~~~~~~~~~~~~~~~~~~~~
> src/ffbuild/common.mak:78: recipe for target 'libavcodec/dxva2_mpeg2.o' failed
> make: *** [libavcodec/dxva2_mpeg2.o] Error 1
> make: *** Waiting for unfinished jobs....
> 
> [...]
> 

Thanks, fixed in https://github.com/mkver/FFmpeg/commits/mpegvideo (as
well as the commit message of #2 and the missing documentation for the
typedefs and some smaller stuff, too). I don't think it is worth
resending it now.
I am btw very interested into whether I should split all relevant
headers into decoder- and encoder-only parts; I only did it for those
for which there is enough stuff for the new headers and for example not
for flv.h, but splitting all headers would have the advantage that e.g.
the decoders never have the encoder headers included.

- Andreas
_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

Re: [FFmpeg-devel] [PATCH 16/41] avcodec/mpegvideo: Use typedefs for MPV(Main)?(Dec|Enc)?Context

[Michael Niedermayer]

[-- Attachment #1.1: Type: text/plain, Size: 7153 bytes --]

On Mon, Jan 31, 2022 at 12:05:11AM +0100, Andreas Rheinhardt wrote:
> Michael Niedermayer:
> > On Sun, Jan 30, 2022 at 07:27:24AM +0100, Andreas Rheinhardt wrote:
> >> This is in preparation for actually adding such contexts
> >> and e.g. moving fields only used by the main thread to
> >> the corresponding "Main" context.
> >>
> >> Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
> > 
> > This breaks build on mingw64
> > 
> > src/libavcodec/dxva2_mpeg2.c:42:50: warning: ‘struct MPVDecContext’ declared inside parameter list will not be visible outside of this definition or declaration
> >                                      const struct MPVDecContext *s,
> >                                                   ^~~~~~~~~~~~~
> > src/libavcodec/dxva2_mpeg2.c: In function ‘fill_picture_parameters’:
> > src/libavcodec/dxva2_mpeg2.c:45:39: error: dereferencing pointer to incomplete type ‘const struct MPVDecContext’
> >      const Picture *current_picture = s->current_picture_ptr;
> >                                        ^~
> > src/libavcodec/dxva2_mpeg2.c: At top level:
> > src/libavcodec/dxva2_mpeg2.c:108:53: warning: ‘struct MPVDecContext’ declared inside parameter list will not be visible outside of this definition or declaration
> >                                         const struct MPVDecContext *s,
> >                                                      ^~~~~~~~~~~~~
> > src/libavcodec/dxva2_mpeg2.c: In function ‘fill_quantization_matrices’:
> > src/libavcodec/dxva2_mpeg2.c:115:18: error: dereferencing pointer to incomplete type ‘const struct MPVDecContext’
> >          int n = s->idsp.idct_permutation[ff_zigzag_direct[i]];
> >                   ^~
> > src/libavcodec/dxva2_mpeg2.c:115:13: warning: variable ‘n’ set but not used [-Wunused-but-set-variable]
> >          int n = s->idsp.idct_permutation[ff_zigzag_direct[i]];
> >              ^
> > src/libavcodec/dxva2_mpeg2.c: At top level:
> > src/libavcodec/dxva2_mpeg2.c:124:37: warning: ‘struct MPVDecContext’ declared inside parameter list will not be visible outside of this definition or declaration
> >                         const struct MPVDecContext *s,
> >                                      ^~~~~~~~~~~~~
> > src/libavcodec/dxva2_mpeg2.c: In function ‘fill_slice’:
> > src/libavcodec/dxva2_mpeg2.c:129:21: error: dereferencing pointer to incomplete type ‘const struct MPVDecContext’
> >      int is_field = s->picture_structure != PICT_FRAME;
> >                      ^~
> > src/libavcodec/dxva2_mpeg2.c: In function ‘commit_bitstream_and_slice_buffer’:
> > src/libavcodec/dxva2_mpeg2.c:157:10: error: dereferencing pointer to incomplete type ‘const struct MPVDecContext’
> >          s->current_picture_ptr->hwaccel_picture_private;
> >           ^~
> > src/libavcodec/dxva2_mpeg2.c: In function ‘dxva2_mpeg2_start_frame’:
> > src/libavcodec/dxva2_mpeg2.c:260:10: error: dereferencing pointer to incomplete type ‘const struct MPVDecContext’
> >          s->current_picture_ptr->hwaccel_picture_private;
> >           ^~
> > src/libavcodec/dxva2_mpeg2.c:266:41: warning: passing argument 3 of ‘fill_picture_parameters’ from incompatible pointer type [-Wincompatible-pointer-types]
> >      fill_picture_parameters(avctx, ctx, s, &ctx_pic->pp);
> >                                          ^
> > src/libavcodec/dxva2_mpeg2.c:40:13: note: expected ‘const struct MPVDecContext *’ but argument is of type ‘const struct MPVDecContext * const’
> >  static void fill_picture_parameters(AVCodecContext *avctx,
> >              ^~~~~~~~~~~~~~~~~~~~~~~
> > src/libavcodec/dxva2_mpeg2.c:267:44: warning: passing argument 3 of ‘fill_quantization_matrices’ from incompatible pointer type [-Wincompatible-pointer-types]
> >      fill_quantization_matrices(avctx, ctx, s, &ctx_pic->qm);
> >                                             ^
> > src/libavcodec/dxva2_mpeg2.c:106:13: note: expected ‘const struct MPVDecContext *’ but argument is of type ‘const struct MPVDecContext * const’
> >  static void fill_quantization_matrices(AVCodecContext *avctx,
> >              ^~~~~~~~~~~~~~~~~~~~~~~~~~
> > src/libavcodec/dxva2_mpeg2.c: In function ‘dxva2_mpeg2_decode_slice’:
> > src/libavcodec/dxva2_mpeg2.c:280:10: error: dereferencing pointer to incomplete type ‘const struct MPVDecContext’
> >          s->current_picture_ptr->hwaccel_picture_private;
> >           ^~
> > src/libavcodec/dxva2_mpeg2.c:293:23: warning: passing argument 2 of ‘fill_slice’ from incompatible pointer type [-Wincompatible-pointer-types]
> >      fill_slice(avctx, s, &ctx_pic->slice[ctx_pic->slice_count++], position,
> >                        ^
> > src/libavcodec/dxva2_mpeg2.c:123:13: note: expected ‘const struct MPVDecContext *’ but argument is of type ‘const struct MPVDecContext * const’
> >  static void fill_slice(AVCodecContext *avctx,
> >              ^~~~~~~~~~
> > src/libavcodec/dxva2_mpeg2.c: In function ‘dxva2_mpeg2_end_frame’:
> > src/libavcodec/dxva2_mpeg2.c:302:10: error: dereferencing pointer to incomplete type ‘struct MPVDecContext’
> >          s->current_picture_ptr->hwaccel_picture_private;
> >           ^~
> > src/libavcodec/dxva2_mpeg2.c:312:33: warning: passing argument 1 of ‘ff_mpeg_draw_horiz_band’ from incompatible pointer type [-Wincompatible-pointer-types]
> >          ff_mpeg_draw_horiz_band(s, 0, avctx->height);
> >                                  ^
> > In file included from src/libavcodec/dxva2_mpeg2.c:27:0:
> > src/libavcodec/mpegvideo.h:606:6: note: expected ‘MPVContext * {aka struct MPVContext *}’ but argument is of type ‘struct MPVDecContext * const’
> >  void ff_mpeg_draw_horiz_band(MPVContext *s, int y, int h);
> >       ^~~~~~~~~~~~~~~~~~~~~~~
> > src/ffbuild/common.mak:78: recipe for target 'libavcodec/dxva2_mpeg2.o' failed
> > make: *** [libavcodec/dxva2_mpeg2.o] Error 1
> > make: *** Waiting for unfinished jobs....
> > 
> > [...]
> > 
> 
> Thanks, fixed in https://github.com/mkver/FFmpeg/commits/mpegvideo (as
> well as the commit message of #2 and the missing documentation for the
> typedefs and some smaller stuff, too). I don't think it is worth
> resending it now.
> I am btw very interested into whether I should split all relevant
> headers into decoder- and encoder-only parts; I only did it for those
> for which there is enough stuff for the new headers and for example not
> for flv.h, but splitting all headers would have the advantage that e.g.
> the decoders never have the encoder headers included.

I think things like libavcodec/flv.h are better split
OTOH anything that just isnt currently used because for example we do
not have an encoder implemented should be left in a common file 

thx

[...]
-- 
Michael     GnuPG fingerprint: 9FF2128B147EF6730BADF133611EC787040B0FAB

The real ebay dictionary, page 2
"100% positive feedback" - "All either got their money back or didnt complain"
"Best seller ever, very honest" - "Seller refunded buyer after failed scam"

[-- Attachment #1.2: signature.asc --]
[-- Type: application/pgp-signature, Size: 195 bytes --]

[-- Attachment #2: Type: text/plain, Size: 251 bytes --]

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

Re: [FFmpeg-devel] [PATCH 16/41] avcodec/mpegvideo: Use typedefs for MPV(Main)?(Dec|Enc)?Context

[Michael Niedermayer]

[-- Attachment #1.1: Type: text/plain, Size: 725 bytes --]

On Sun, Jan 30, 2022 at 07:27:24AM +0100, Andreas Rheinhardt wrote:
> This is in preparation for actually adding such contexts
> and e.g. moving fields only used by the main thread to
> the corresponding "Main" context.
[...]

> +} MPVContext;
>  
> +typedef MPVContext MPVDecContext;
> +typedef MPVContext MPVMainContext;
> +typedef MPVContext MPVMainDecContext;

Missing documentation, what these represent, specifically the "Main"

thx

[...]
-- 
Michael     GnuPG fingerprint: 9FF2128B147EF6730BADF133611EC787040B0FAB

Whats the most studid thing your enemy could do ? Blow himself up
Whats the most studid thing you could do ? Give up your rights and
freedom because your enemy blew himself up.


[-- Attachment #1.2: signature.asc --]
[-- Type: application/pgp-signature, Size: 195 bytes --]

[-- Attachment #2: Type: text/plain, Size: 251 bytes --]

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

[FFmpeg-devel] [PATCH 17/41] avcodec/mpegvideo_enc: Don't find encoder by ID

[Andreas Rheinhardt]

mpegvideo-based encoders supporting bframes implement this
by opening encoders of their own to test how long the chains
of bframes are supposed to be. The needed AVCodec was obtained
via avcodec_find_encoder(). This is complicated, as the current
encoder can be directly obtained. And it also is not guaranteed
that one actually gets the current encoder or not another encoder
for the same codec ID (the latter does not seem to be the case now).

Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
---
 libavcodec/mpegvideo_enc.c | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/libavcodec/mpegvideo_enc.c b/libavcodec/mpegvideo_enc.c
index 02efc9c2e9..f21febd4db 100644
--- a/libavcodec/mpegvideo_enc.c
+++ b/libavcodec/mpegvideo_enc.c
@@ -1216,7 +1216,6 @@ static int encode_frame(AVCodecContext *c, AVFrame *frame, AVPacket *pkt)
 
 static int estimate_best_b_count(MPVMainEncContext *s)
 {
-    const AVCodec *codec = avcodec_find_encoder(s->avctx->codec_id);
     AVPacket *pkt;
     const int scale = s->brd_scale;
     int width  = s->width  >> scale;
@@ -1300,7 +1299,7 @@ static int estimate_best_b_count(MPVMainEncContext *s)
         c->time_base    = s->avctx->time_base;
         c->max_b_frames = s->max_b_frames;
 
-        ret = avcodec_open2(c, codec, NULL);
+        ret = avcodec_open2(c, s->avctx->codec, NULL);
         if (ret < 0)
             goto fail;
 
-- 
2.32.0

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

[FFmpeg-devel] [PATCH 18/41] avcodec/mpegvideoenc: Add proper MPVMainEncContext

[Andreas Rheinhardt]

This is in preparation for moving fields only used by
the main encoder thread from MPVContext to MPVMainEncContext.

Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
---
 libavcodec/dnxhdenc.c      | 302 +++++++++++++++++++------------------
 libavcodec/flvenc.c        |   3 +-
 libavcodec/h261enc.c       |  15 +-
 libavcodec/ituh263enc.c    |  13 +-
 libavcodec/mjpegenc.c      |  24 +--
 libavcodec/mpeg12enc.c     |  23 +--
 libavcodec/mpeg4videoenc.c |  35 +++--
 libavcodec/mpegvideo_enc.c | 135 +++++++++--------
 libavcodec/mpegvideoenc.h  |   7 +-
 libavcodec/msmpeg4enc.c    |  12 +-
 libavcodec/ratecontrol.c   |  59 +++++---
 libavcodec/ratecontrol.h   |   2 -
 libavcodec/rv10enc.c       |   3 +-
 libavcodec/rv20enc.c       |   3 +-
 libavcodec/snow.c          |  11 +-
 libavcodec/snowenc.c       | 170 +++++++++++----------
 libavcodec/speedhqenc.c    |   8 +-
 libavcodec/svq1enc.c       | 159 +++++++++----------
 libavcodec/wmv2enc.c       |  12 +-
 19 files changed, 539 insertions(+), 457 deletions(-)

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 1de9e4da55..1d3d76747a 100644
--- a/libavcodec/flvenc.c
+++ b/libavcodec/flvenc.c
@@ -24,8 +24,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 a2e4c55c93..e4429fa89c 100644
--- a/libavcodec/h261enc.c
+++ b/libavcodec/h261enc.c
@@ -59,9 +59,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);
@@ -174,9 +175,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;
 
@@ -325,7 +325,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;
@@ -380,9 +380,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 97f3ad95f2..4af7ccb527 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 481ee884e9..23772c4c1f 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 4d01a9215a..78c802d897 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 cd7ce1f382..fcd436082f 100644
--- a/libavcodec/mpeg4videoenc.c
+++ b/libavcodec/mpeg4videoenc.c
@@ -215,12 +215,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;
@@ -875,8 +876,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 {
@@ -885,8 +887,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;
 
@@ -915,8 +918,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;
 
@@ -959,10 +963,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) {
@@ -1060,20 +1065,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;
@@ -1283,7 +1289,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)) {
@@ -1314,8 +1321,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);
@@ -1375,7 +1382,7 @@ 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 },
diff --git a/libavcodec/mpegvideo_enc.c b/libavcodec/mpegvideo_enc.c
index f21febd4db..a42cc0fa51 100644
--- a/libavcodec/mpegvideo_enc.c
+++ b/libavcodec/mpegvideo_enc.c
@@ -235,8 +235,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;
 
@@ -276,11 +277,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);
 
@@ -312,11 +315,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:
@@ -665,7 +669,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;
@@ -676,7 +680,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;
@@ -849,14 +853,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 */
@@ -895,7 +899,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) {
@@ -927,12 +931,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]);
@@ -970,7 +975,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;
@@ -993,7 +998,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,
@@ -1001,8 +1006,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;
@@ -1152,8 +1159,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;
@@ -1214,8 +1222,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;
@@ -1360,8 +1369,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++)
@@ -1373,11 +1383,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;
             }
@@ -1437,7 +1447,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;
             }
@@ -1537,8 +1547,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) {
@@ -1574,8 +1585,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++) {
@@ -1595,8 +1607,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 */
@@ -1660,7 +1673,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;
@@ -1669,7 +1682,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;
 
@@ -1677,10 +1691,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;
     }
 
@@ -1711,11 +1725,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;
@@ -1724,7 +1738,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);
@@ -1772,7 +1786,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];
@@ -1790,7 +1804,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) {
@@ -3429,14 +3443,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)
@@ -3447,16 +3462,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];
@@ -3468,8 +3483,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;
 
@@ -3483,8 +3499,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;
@@ -3498,9 +3515,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;
 
@@ -3515,9 +3532,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];
@@ -3635,7 +3652,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 &&
@@ -3709,41 +3726,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 94ebe0237f..8369254bff 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;
 
 /* mpegvideo_enc common options */
 #define FF_MPV_FLAG_SKIP_RD      0x0001
@@ -61,7 +63,8 @@ typedef MPVContext MPVMainEncContext;
 { "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" }
 
 #ifndef FF_MPV_OFFSET
-#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)
 #endif
 #define FF_MPV_OPT_FLAGS (AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM)
 #define FF_MPV_COMMON_OPTS \
diff --git a/libavcodec/msmpeg4enc.c b/libavcodec/msmpeg4enc.c
index 0c4d777cc2..9ab7f9e146 100644
--- a/libavcodec/msmpeg4enc.c
+++ b/libavcodec/msmpeg4enc.c
@@ -136,11 +136,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;
@@ -152,7 +153,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;
@@ -216,9 +217,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 99715ebdfb..16956be04f 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 *s);
 void ff_rate_control_uninit(struct MPVMainEncContext *s);
 int ff_vbv_update(struct MPVMainEncContext *s, int frame_size);
 void ff_get_2pass_fcode(struct MPVMainEncContext *s);
-#undef MPVMainEncContext
 
 #endif /* AVCODEC_RATECONTROL_H */
diff --git a/libavcodec/rv10enc.c b/libavcodec/rv10enc.c
index 25f3179196..5be04353c1 100644
--- a/libavcodec/rv10enc.c
+++ b/libavcodec/rv10enc.c
@@ -30,8 +30,9 @@
 #include "put_bits.h"
 #include "rv10.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 22bcad9837..1a41071ddd 100644
--- a/libavcodec/rv20enc.c
+++ b/libavcodec/rv20enc.c
@@ -33,8 +33,9 @@
 #include "put_bits.h"
 #include "rv10.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 fb4d426b46..e511e8bc47 100644
--- a/libavcodec/speedhqenc.c
+++ b/libavcodec/speedhqenc.c
@@ -90,8 +90,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;
 
     av_assert0(s->slice_context_count == 1);
@@ -128,9 +129,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 14f817f2d6..ab55af33c3 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)
-- 
2.32.0

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

[FFmpeg-devel] [PATCH 19/41] avcodec/mpegvideoenc: Move tmp bframes to MPVMainEncContext

[Andreas Rheinhardt]

Also move b_frame_strategy and b_sensitivity; they are all
only used by an encoder's main thread.

Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
---
 libavcodec/mpegvideo.h     |  5 ----
 libavcodec/mpegvideo_enc.c | 55 +++++++++++++++++++-------------------
 libavcodec/mpegvideoenc.h  | 13 ++++++---
 3 files changed, 36 insertions(+), 37 deletions(-)

diff --git a/libavcodec/mpegvideo.h b/libavcodec/mpegvideo.h
index 1bad288ea5..e83061fa92 100644
--- a/libavcodec/mpegvideo.h
+++ b/libavcodec/mpegvideo.h
@@ -530,11 +530,6 @@ typedef struct MPVContext {
 
     int error_rate;
 
-    /* temporary frames used by b_frame_strategy = 2 */
-    AVFrame *tmp_frames[MAX_B_FRAMES + 2];
-    int b_frame_strategy;
-    int b_sensitivity;
-
     /* frame skip options for encoding */
     int frame_skip_threshold;
     int frame_skip_factor;
diff --git a/libavcodec/mpegvideo_enc.c b/libavcodec/mpegvideo_enc.c
index a42cc0fa51..bbff65ef41 100644
--- a/libavcodec/mpegvideo_enc.c
+++ b/libavcodec/mpegvideo_enc.c
@@ -610,10 +610,10 @@ av_cold int ff_mpv_encode_init(AVCodecContext *avctx)
         return AVERROR(EINVAL);
     }
 
-    if (s->b_frame_strategy && (avctx->flags & AV_CODEC_FLAG_PASS2)) {
+    if (m->b_frame_strategy && (avctx->flags & AV_CODEC_FLAG_PASS2)) {
         av_log(avctx, AV_LOG_INFO,
                "notice: b_frame_strategy only affects the first pass\n");
-        s->b_frame_strategy = 0;
+        m->b_frame_strategy = 0;
     }
 
     i = av_gcd(avctx->time_base.den, avctx->time_base.num);
@@ -902,17 +902,17 @@ av_cold int ff_mpv_encode_init(AVCodecContext *avctx)
     if ((ret = ff_rate_control_init(m)) < 0)
         return ret;
 
-    if (s->b_frame_strategy == 2) {
+    if (m->b_frame_strategy == 2) {
         for (i = 0; i < s->max_b_frames + 2; i++) {
-            s->tmp_frames[i] = av_frame_alloc();
-            if (!s->tmp_frames[i])
+            m->tmp_frames[i] = av_frame_alloc();
+            if (!m->tmp_frames[i])
                 return AVERROR(ENOMEM);
 
-            s->tmp_frames[i]->format = AV_PIX_FMT_YUV420P;
-            s->tmp_frames[i]->width  = s->width  >> s->brd_scale;
-            s->tmp_frames[i]->height = s->height >> s->brd_scale;
+            m->tmp_frames[i]->format = AV_PIX_FMT_YUV420P;
+            m->tmp_frames[i]->width  = s->width  >> s->brd_scale;
+            m->tmp_frames[i]->height = s->height >> s->brd_scale;
 
-            ret = av_frame_get_buffer(s->tmp_frames[i], 0);
+            ret = av_frame_get_buffer(m->tmp_frames[i], 0);
             if (ret < 0)
                 return ret;
         }
@@ -933,14 +933,13 @@ av_cold int ff_mpv_encode_end(AVCodecContext *avctx)
 {
     MPVMainEncContext *const m = avctx->priv_data;
     MPVMainContext  *const s = &m->common;
-    int i;
 
     ff_rate_control_uninit(m);
 
     ff_mpv_common_end(&m->common);
 
-    for (i = 0; i < FF_ARRAY_ELEMS(s->tmp_frames); i++)
-        av_frame_free(&s->tmp_frames[i]);
+    for (int i = 0; i < FF_ARRAY_ELEMS(m->tmp_frames); i++)
+        av_frame_free(&m->tmp_frames[i]);
 
     ff_mpv_picture_free(avctx, &s->new_picture);
 
@@ -1265,18 +1264,18 @@ static int estimate_best_b_count(MPVMainEncContext *m)
                 data[2] += INPLACE_OFFSET;
             }
 
-            s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[0],
-                                       s->tmp_frames[i]->linesize[0],
+            s->mpvencdsp.shrink[scale](m->tmp_frames[i]->data[0],
+                                       m->tmp_frames[i]->linesize[0],
                                        data[0],
                                        pre_input.f->linesize[0],
                                        width, height);
-            s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[1],
-                                       s->tmp_frames[i]->linesize[1],
+            s->mpvencdsp.shrink[scale](m->tmp_frames[i]->data[1],
+                                       m->tmp_frames[i]->linesize[1],
                                        data[1],
                                        pre_input.f->linesize[1],
                                        width >> 1, height >> 1);
-            s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[2],
-                                       s->tmp_frames[i]->linesize[2],
+            s->mpvencdsp.shrink[scale](m->tmp_frames[i]->data[2],
+                                       m->tmp_frames[i]->linesize[2],
                                        data[2],
                                        pre_input.f->linesize[2],
                                        width >> 1, height >> 1);
@@ -1313,10 +1312,10 @@ static int estimate_best_b_count(MPVMainEncContext *m)
             goto fail;
 
 
-        s->tmp_frames[0]->pict_type = AV_PICTURE_TYPE_I;
-        s->tmp_frames[0]->quality   = 1 * FF_QP2LAMBDA;
+        m->tmp_frames[0]->pict_type = AV_PICTURE_TYPE_I;
+        m->tmp_frames[0]->quality   = 1 * FF_QP2LAMBDA;
 
-        out_size = encode_frame(c, s->tmp_frames[0], pkt);
+        out_size = encode_frame(c, m->tmp_frames[0], pkt);
         if (out_size < 0) {
             ret = out_size;
             goto fail;
@@ -1327,11 +1326,11 @@ static int estimate_best_b_count(MPVMainEncContext *m)
         for (i = 0; i < s->max_b_frames + 1; i++) {
             int is_p = i % (j + 1) == j || i == s->max_b_frames;
 
-            s->tmp_frames[i + 1]->pict_type = is_p ?
+            m->tmp_frames[i + 1]->pict_type = is_p ?
                                      AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_B;
-            s->tmp_frames[i + 1]->quality   = is_p ? p_lambda : b_lambda;
+            m->tmp_frames[i + 1]->quality   = is_p ? p_lambda : b_lambda;
 
-            out_size = encode_frame(c, s->tmp_frames[i + 1], pkt);
+            out_size = encode_frame(c, m->tmp_frames[i + 1], pkt);
             if (out_size < 0) {
                 ret = out_size;
                 goto fail;
@@ -1418,11 +1417,11 @@ static int select_input_picture(MPVMainEncContext *m)
                 }
             }
 
-            if (s->b_frame_strategy == 0) {
+            if (m->b_frame_strategy == 0) {
                 b_frames = s->max_b_frames;
                 while (b_frames && !s->input_picture[b_frames])
                     b_frames--;
-            } else if (s->b_frame_strategy == 1) {
+            } else if (m->b_frame_strategy == 1) {
                 for (i = 1; i < s->max_b_frames + 1; i++) {
                     if (s->input_picture[i] &&
                         s->input_picture[i]->b_frame_score == 0) {
@@ -1436,7 +1435,7 @@ static int select_input_picture(MPVMainEncContext *m)
                 for (i = 0; i < s->max_b_frames + 1; i++) {
                     if (!s->input_picture[i] ||
                         s->input_picture[i]->b_frame_score - 1 >
-                            s->mb_num / s->b_sensitivity)
+                            s->mb_num / m->b_sensitivity)
                         break;
                 }
 
@@ -1446,7 +1445,7 @@ static int select_input_picture(MPVMainEncContext *m)
                 for (i = 0; i < b_frames + 1; i++) {
                     s->input_picture[i]->b_frame_score = 0;
                 }
-            } else if (s->b_frame_strategy == 2) {
+            } else if (m->b_frame_strategy == 2) {
                 b_frames = estimate_best_b_count(m);
                 if (b_frames < 0)
                     return b_frames;
diff --git a/libavcodec/mpegvideoenc.h b/libavcodec/mpegvideoenc.h
index 8369254bff..c1013316aa 100644
--- a/libavcodec/mpegvideoenc.h
+++ b/libavcodec/mpegvideoenc.h
@@ -35,6 +35,11 @@
 typedef MPVContext MPVEncContext;
 typedef struct MPVMainEncContext {
     MPVMainContext common;
+
+    /* temporary frames used by b_frame_strategy == 2 */
+    AVFrame *tmp_frames[MAX_B_FRAMES + 2];
+    int b_frame_strategy;
+    int b_sensitivity;
 } MPVMainEncContext;
 
 /* mpegvideo_enc common options */
@@ -115,8 +120,8 @@ FF_MPV_OPT_CMP_FUNC, \
 {"intra_penalty", "Penalty for intra blocks in block decision", FF_MPV_OFFSET(intra_penalty), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, INT_MAX/2, FF_MPV_OPT_FLAGS }, \
 
 #define FF_MPV_COMMON_BFRAME_OPTS \
-{"b_strategy", "Strategy to choose between I/P/B-frames",      FF_MPV_OFFSET(b_frame_strategy), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, 2, FF_MPV_OPT_FLAGS }, \
-{"b_sensitivity", "Adjust sensitivity of b_frame_strategy 1",  FF_MPV_OFFSET(b_sensitivity), AV_OPT_TYPE_INT, {.i64 = 40 }, 1, INT_MAX, FF_MPV_OPT_FLAGS }, \
+{"b_strategy", "Strategy to choose between I/P/B-frames",      FF_MPV_MAIN_OFFSET(b_frame_strategy), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, 2, FF_MPV_OPT_FLAGS }, \
+{"b_sensitivity", "Adjust sensitivity of b_frame_strategy 1",  FF_MPV_MAIN_OFFSET(b_sensitivity), AV_OPT_TYPE_INT, {.i64 = 40 }, 1, INT_MAX, FF_MPV_OPT_FLAGS }, \
 {"brd_scale", "Downscale frames for dynamic B-frame decision", FF_MPV_OFFSET(brd_scale), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, 3, FF_MPV_OPT_FLAGS },
 
 #if FF_API_MPEGVIDEO_OPTS
@@ -127,8 +132,8 @@ FF_MPV_OPT_CMP_FUNC, \
 #define FF_MPV_DEPRECATED_MATRIX_OPT \
    { "force_duplicated_matrix", "Deprecated, does nothing", FF_MPV_OFFSET(dummy), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, FF_MPV_OPT_FLAGS | AV_OPT_FLAG_DEPRECATED },
 #define FF_MPV_DEPRECATED_BFRAME_OPTS \
-   { "b_strategy",    "Deprecated, does nothing", FF_MPV_OFFSET(b_frame_strategy), AV_OPT_TYPE_INT, { .i64 =  0 }, 0, 2, FF_MPV_OPT_FLAGS | AV_OPT_FLAG_DEPRECATED }, \
-   { "b_sensitivity", "Deprecated, does nothing", FF_MPV_OFFSET(b_sensitivity),    AV_OPT_TYPE_INT, { .i64 = 40 }, 1, INT_MAX, FF_MPV_OPT_FLAGS | AV_OPT_FLAG_DEPRECATED }, \
+   { "b_strategy",    "Deprecated, does nothing", FF_MPV_MAIN_OFFSET(b_frame_strategy), AV_OPT_TYPE_INT, { .i64 =  0 }, 0, 2, FF_MPV_OPT_FLAGS | AV_OPT_FLAG_DEPRECATED }, \
+   { "b_sensitivity", "Deprecated, does nothing", FF_MPV_MAIN_OFFSET(b_sensitivity),    AV_OPT_TYPE_INT, { .i64 = 40 }, 1, INT_MAX, FF_MPV_OPT_FLAGS | AV_OPT_FLAG_DEPRECATED }, \
    { "brd_scale",     "Deprecated, does nothing", FF_MPV_OFFSET(brd_scale),        AV_OPT_TYPE_INT, { .i64 =  0 }, 0, 3, FF_MPV_OPT_FLAGS | AV_OPT_FLAG_DEPRECATED },
 #endif
 
-- 
2.32.0

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

[FFmpeg-devel] [PATCH 20/41] avcodec/mpegvideoenc: Move ratecontrol to MPVMainEncContext

[Andreas Rheinhardt]

Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
---
 libavcodec/mpegvideo.h     |  8 --------
 libavcodec/mpegvideo_enc.c | 38 +++++++++++++++++++-------------------
 libavcodec/mpegvideoenc.h  |  8 ++++++++
 libavcodec/ratecontrol.c   | 31 +++++++++++++++----------------
 libavcodec/snowenc.c       |  8 ++++----
 5 files changed, 46 insertions(+), 47 deletions(-)

diff --git a/libavcodec/mpegvideo.h b/libavcodec/mpegvideo.h
index e83061fa92..c9467f0752 100644
--- a/libavcodec/mpegvideo.h
+++ b/libavcodec/mpegvideo.h
@@ -47,7 +47,6 @@
 #include "mpegvideodata.h"
 #include "pixblockdsp.h"
 #include "put_bits.h"
-#include "ratecontrol.h"
 #if FF_API_FLAG_TRUNCATED
 #include "parser.h"
 #endif
@@ -316,13 +315,6 @@ typedef struct MPVContext {
     int dct_count[2];
     uint16_t (*dct_offset)[64];
 
-    /* bit rate control */
-    int64_t total_bits;
-    int frame_bits;                ///< bits used for the current frame
-    int stuffing_bits;             ///< bits used for stuffing
-    int next_lambda;               ///< next lambda used for retrying to encode a frame
-    RateControlContext rc_context; ///< contains stuff only accessed in ratecontrol.c
-
     /* statistics, used for 2-pass encoding */
     int mv_bits;
     int header_bits;
diff --git a/libavcodec/mpegvideo_enc.c b/libavcodec/mpegvideo_enc.c
index bbff65ef41..3eb8260b06 100644
--- a/libavcodec/mpegvideo_enc.c
+++ b/libavcodec/mpegvideo_enc.c
@@ -1405,15 +1405,15 @@ static int select_input_picture(MPVMainEncContext *m)
                 for (i = 0; i < s->max_b_frames + 1; i++) {
                     int pict_num = s->input_picture[0]->f->display_picture_number + i;
 
-                    if (pict_num >= s->rc_context.num_entries)
+                    if (pict_num >= m->rc_context.num_entries)
                         break;
                     if (!s->input_picture[i]) {
-                        s->rc_context.entry[pict_num - 1].new_pict_type = AV_PICTURE_TYPE_P;
+                        m->rc_context.entry[pict_num - 1].new_pict_type = AV_PICTURE_TYPE_P;
                         break;
                     }
 
                     s->input_picture[i]->f->pict_type =
-                        s->rc_context.entry[pict_num].new_pict_type;
+                        m->rc_context.entry[pict_num].new_pict_type;
                 }
             }
 
@@ -1743,14 +1743,14 @@ vbv_retry:
             ff_mjpeg_encode_picture_trailer(&s->pb, s->header_bits);
 
         if (avctx->rc_buffer_size) {
-            RateControlContext *rcc = &s->rc_context;
+            RateControlContext *rcc = &m->rc_context;
             int max_size = FFMAX(rcc->buffer_index * avctx->rc_max_available_vbv_use, rcc->buffer_index - 500);
             int hq = (avctx->mb_decision == FF_MB_DECISION_RD || avctx->trellis);
             int min_step = hq ? 1 : (1<<(FF_LAMBDA_SHIFT + 7))/139;
 
             if (put_bits_count(&s->pb) > max_size &&
                 s->lambda < s->lmax) {
-                s->next_lambda = FFMAX(s->lambda + min_step, s->lambda *
+                m->next_lambda = FFMAX(s->lambda + min_step, s->lambda *
                                        (s->qscale + 1) / s->qscale);
                 if (s->adaptive_quant) {
                     int i;
@@ -1801,10 +1801,10 @@ vbv_retry:
                                              s->misc_bits + s->i_tex_bits +
                                              s->p_tex_bits);
         flush_put_bits(&s->pb);
-        s->frame_bits  = put_bits_count(&s->pb);
+        m->frame_bits  = put_bits_count(&s->pb);
 
-        stuffing_count = ff_vbv_update(m, s->frame_bits);
-        s->stuffing_bits = 8*stuffing_count;
+        stuffing_count = ff_vbv_update(m, m->frame_bits);
+        m->stuffing_bits = 8 * stuffing_count;
         if (stuffing_count) {
             if (put_bytes_left(&s->pb, 0) < stuffing_count + 50) {
                 av_log(avctx, AV_LOG_ERROR, "stuffing too large\n");
@@ -1828,10 +1828,10 @@ vbv_retry:
             break;
             default:
                 av_log(avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
-                s->stuffing_bits = 0;
+                m->stuffing_bits = 0;
             }
             flush_put_bits(&s->pb);
-            s->frame_bits  = put_bits_count(&s->pb);
+            m->frame_bits  = put_bits_count(&s->pb);
         }
 
         /* update MPEG-1/2 vbv_delay for CBR */
@@ -1846,9 +1846,9 @@ vbv_retry:
             int vbv_delay, min_delay;
             double inbits  = avctx->rc_max_rate *
                              av_q2d(avctx->time_base);
-            int    minbits = s->frame_bits - 8 *
+            int    minbits = m->frame_bits - 8 *
                              (s->vbv_delay_pos - 1);
-            double bits    = s->rc_context.buffer_index + minbits - inbits;
+            double bits    = m->rc_context.buffer_index + minbits - inbits;
             uint8_t *const vbv_delay_ptr = s->pb.buf + s->vbv_delay_pos;
 
             if (bits < 0)
@@ -1883,7 +1883,7 @@ vbv_retry:
                 return ret;
             }
         }
-        s->total_bits     += s->frame_bits;
+        m->total_bits     += m->frame_bits;
 
         pkt->pts = s->current_picture.f->pts;
         if (!s->low_delay && s->pict_type != AV_PICTURE_TYPE_B) {
@@ -1899,7 +1899,7 @@ vbv_retry:
         if (s->mb_info)
             av_packet_shrink_side_data(pkt, AV_PKT_DATA_H263_MB_INFO, s->mb_info_size);
     } else {
-        s->frame_bits = 0;
+        m->frame_bits = 0;
     }
 
     /* release non-reference frames */
@@ -1908,9 +1908,9 @@ vbv_retry:
             ff_mpeg_unref_picture(avctx, &s->picture[i]);
     }
 
-    av_assert1((s->frame_bits & 7) == 0);
+    av_assert1((m->frame_bits & 7) == 0);
 
-    pkt->size = s->frame_bits / 8;
+    pkt->size = m->frame_bits / 8;
     *got_packet = !!pkt->size;
     return 0;
 }
@@ -3445,10 +3445,10 @@ static void merge_context_after_encode(MPVEncContext *dst, MPVEncContext *src)
 static int estimate_qp(MPVMainEncContext *m, int dry_run)
 {
     MPVEncContext *const s = &m->common;
-    if (s->next_lambda){
+    if (m->next_lambda) {
         s->current_picture_ptr->f->quality =
-        s->current_picture.f->quality = s->next_lambda;
-        if(!dry_run) s->next_lambda= 0;
+        s->current_picture.f->quality = m->next_lambda;
+        if (!dry_run) m->next_lambda= 0;
     } else if (!s->fixed_qscale) {
         int quality = ff_rate_estimate_qscale(m, dry_run);
         s->current_picture_ptr->f->quality =
diff --git a/libavcodec/mpegvideoenc.h b/libavcodec/mpegvideoenc.h
index c1013316aa..6a96909e17 100644
--- a/libavcodec/mpegvideoenc.h
+++ b/libavcodec/mpegvideoenc.h
@@ -31,11 +31,19 @@
 #include "libavutil/opt.h"
 #include "internal.h"
 #include "mpegvideo.h"
+#include "ratecontrol.h"
 
 typedef MPVContext MPVEncContext;
 typedef struct MPVMainEncContext {
     MPVMainContext common;
 
+    /* bit rate control */
+    int64_t total_bits;
+    int frame_bits;                ///< bits used for the current frame
+    int stuffing_bits;             ///< bits used for stuffing
+    int next_lambda;               ///< next lambda used for retrying to encode a frame
+    RateControlContext rc_context; ///< contains stuff only accessed in ratecontrol.c
+
     /* temporary frames used by b_frame_strategy == 2 */
     AVFrame *tmp_frames[MAX_B_FRAMES + 2];
     int b_frame_strategy;
diff --git a/libavcodec/ratecontrol.c b/libavcodec/ratecontrol.c
index 4c326741df..b0f319680b 100644
--- a/libavcodec/ratecontrol.c
+++ b/libavcodec/ratecontrol.c
@@ -81,7 +81,7 @@ static inline double bits2qp(RateControlEntry *rce, double bits)
 static double get_diff_limited_q(MPVMainEncContext *m, RateControlEntry *rce, double q)
 {
     MPVEncContext    *const s = &m->common;
-    RateControlContext *rcc   = &s->rc_context;
+    RateControlContext *rcc   = &m->rc_context;
     AVCodecContext *a         = s->avctx;
     const int pict_type       = rce->new_pict_type;
     const double last_p_q     = rcc->last_qscale_for[AV_PICTURE_TYPE_P];
@@ -150,7 +150,7 @@ static double modify_qscale(MPVMainEncContext *m, RateControlEntry *rce,
                             double q, int frame_num)
 {
     MPVEncContext   *const s = &m->common;
-    RateControlContext *rcc  = &s->rc_context;
+    RateControlContext *rcc  = &m->rc_context;
     const double buffer_size = s->avctx->rc_buffer_size;
     const double fps         = get_fps(s->avctx);
     const double min_rate    = s->avctx->rc_min_rate / fps;
@@ -242,7 +242,7 @@ static double get_qscale(MPVMainEncContext *m, RateControlEntry *rce,
                          double rate_factor, int frame_num)
 {
     MPVEncContext  *const s = &m->common;
-    RateControlContext *rcc = &s->rc_context;
+    RateControlContext *rcc = &m->rc_context;
     AVCodecContext *a       = s->avctx;
     const int pict_type     = rce->new_pict_type;
     const double mb_num     = s->mb_num;
@@ -315,7 +315,7 @@ static double get_qscale(MPVMainEncContext *m, RateControlEntry *rce,
 static int init_pass2(MPVMainEncContext *m)
 {
     MPVEncContext  *const s = &m->common;
-    RateControlContext *rcc = &s->rc_context;
+    RateControlContext *rcc = &m->rc_context;
     AVCodecContext *a       = s->avctx;
     int i, toobig;
     double fps             = get_fps(s->avctx);
@@ -477,7 +477,7 @@ static int init_pass2(MPVMainEncContext *m)
 av_cold int ff_rate_control_init(MPVMainEncContext *m)
 {
     MPVEncContext  *const s = &m->common;
-    RateControlContext *rcc = &s->rc_context;
+    RateControlContext *rcc = &m->rc_context;
     int i, res;
     static const char * const const_names[] = {
         "PI",
@@ -677,8 +677,7 @@ av_cold int ff_rate_control_init(MPVMainEncContext *m)
 
 av_cold void ff_rate_control_uninit(MPVMainEncContext *m)
 {
-    MPVEncContext  *const s = &m->common;
-    RateControlContext *rcc = &s->rc_context;
+    RateControlContext *rcc = &m->rc_context;
     emms_c();
 
     av_expr_free(rcc->rc_eq_eval);
@@ -688,7 +687,7 @@ av_cold void ff_rate_control_uninit(MPVMainEncContext *m)
 int ff_vbv_update(MPVMainEncContext *m, int frame_size)
 {
     MPVEncContext  *const s = &m->common;
-    RateControlContext *rcc = &s->rc_context;
+    RateControlContext *rcc = &m->rc_context;
     const double fps        = get_fps(s->avctx);
     const int buffer_size   = s->avctx->rc_buffer_size;
     const double min_rate   = s->avctx->rc_min_rate / fps;
@@ -866,7 +865,7 @@ static void adaptive_quantization(MPVMainEncContext *m, double q)
 void ff_get_2pass_fcode(MPVMainEncContext *m)
 {
     MPVEncContext  *const s = &m->common;
-    RateControlContext *rcc = &s->rc_context;
+    RateControlContext *rcc = &m->rc_context;
     RateControlEntry *rce   = &rcc->entry[s->picture_number];
 
     s->f_code = rce->f_code;
@@ -886,7 +885,7 @@ float ff_rate_estimate_qscale(MPVMainEncContext *m, int dry_run)
     double fps;
     int picture_number = s->picture_number;
     int64_t wanted_bits;
-    RateControlContext *rcc = &s->rc_context;
+    RateControlContext *rcc = &m->rc_context;
     AVCodecContext *a       = s->avctx;
     RateControlEntry local_rce, *rce;
     double bits;
@@ -904,11 +903,11 @@ float ff_rate_estimate_qscale(MPVMainEncContext *m, int dry_run)
         const int64_t last_var =
             s->last_pict_type == AV_PICTURE_TYPE_I ? rcc->last_mb_var_sum
                                                    : rcc->last_mc_mb_var_sum;
-        av_assert1(s->frame_bits >= s->stuffing_bits);
+        av_assert1(m->frame_bits >= m->stuffing_bits);
         update_predictor(&rcc->pred[s->last_pict_type],
                          rcc->last_qscale,
                          sqrt(last_var),
-                         s->frame_bits - s->stuffing_bits);
+                         m->frame_bits - m->stuffing_bits);
     }
 
     if (s->avctx->flags & AV_CODEC_FLAG_PASS2) {
@@ -937,7 +936,7 @@ float ff_rate_estimate_qscale(MPVMainEncContext *m, int dry_run)
             wanted_bits = (uint64_t)(s->bit_rate * (double)dts_pic->f->pts / fps);
     }
 
-    diff = s->total_bits - wanted_bits;
+    diff = m->total_bits - wanted_bits;
     br_compensation = (a->bit_rate_tolerance - diff) / a->bit_rate_tolerance;
     if (br_compensation <= 0.0)
         br_compensation = 0.001;
@@ -951,7 +950,7 @@ float ff_rate_estimate_qscale(MPVMainEncContext *m, int dry_run)
 
         q = rce->new_qscale / br_compensation;
         ff_dlog(s, "%f %f %f last:%d var:%"PRId64" type:%d//\n", q, rce->new_qscale,
-                br_compensation, s->frame_bits, var, pict_type);
+                br_compensation, m->frame_bits, var, pict_type);
     } else {
         rce->pict_type     =
         rce->new_pict_type = pict_type;
@@ -1014,8 +1013,8 @@ float ff_rate_estimate_qscale(MPVMainEncContext *m, int dry_run)
                "size:%d var:%"PRId64"/%"PRId64" br:%"PRId64" fps:%d\n",
                av_get_picture_type_char(pict_type),
                qmin, q, qmax, picture_number,
-               wanted_bits / 1000, s->total_bits / 1000,
-               br_compensation, short_term_q, s->frame_bits,
+               wanted_bits / 1000, m->total_bits / 1000,
+               br_compensation, short_term_q, m->frame_bits,
                pic->mb_var_sum, pic->mc_mb_var_sum,
                s->bit_rate / 1000, (int)fps);
     }
diff --git a/libavcodec/snowenc.c b/libavcodec/snowenc.c
index 028b6b91aa..ebed90c729 100644
--- a/libavcodec/snowenc.c
+++ b/libavcodec/snowenc.c
@@ -1597,7 +1597,7 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
 
     mpv->picture_number= avctx->frame_number;
     if(avctx->flags&AV_CODEC_FLAG_PASS2){
-        mpv->pict_type = pic->pict_type = mpv->rc_context.entry[avctx->frame_number].new_pict_type;
+        mpv->pict_type = pic->pict_type = s->m.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);
@@ -1847,12 +1847,12 @@ 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;
-    mpv->frame_bits = 8*(s->c.bytestream - s->c.bytestream_start);
-    mpv->p_tex_bits = mpv->frame_bits - mpv->misc_bits - mpv->mv_bits;
+    s->m.frame_bits = 8*(s->c.bytestream - s->c.bytestream_start);
+    mpv->p_tex_bits = s->m.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);
+    s->m.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;
-- 
2.32.0

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

[FFmpeg-devel] [PATCH 21/41] avcodec/mpegvideo: Move me_pre and me_penalty_compensation to enc-ctx

[Andreas Rheinhardt]

Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
---
 libavcodec/mpegvideo.h     | 2 --
 libavcodec/mpegvideo_enc.c | 8 ++++----
 libavcodec/mpegvideoenc.h  | 7 +++++--
 3 files changed, 9 insertions(+), 8 deletions(-)

diff --git a/libavcodec/mpegvideo.h b/libavcodec/mpegvideo.h
index c9467f0752..7089160765 100644
--- a/libavcodec/mpegvideo.h
+++ b/libavcodec/mpegvideo.h
@@ -239,8 +239,6 @@ typedef struct MPVContext {
     uint8_t (*p_field_select_table[2]);  ///< Only the first element is allocated
     uint8_t (*b_field_select_table[2][2]); ///< Only the first element is allocated
     int motion_est;                      ///< ME algorithm
-    int me_penalty_compensation;
-    int me_pre;                          ///< prepass for motion estimation
     int mv_dir;
 #define MV_DIR_FORWARD   1
 #define MV_DIR_BACKWARD  2
diff --git a/libavcodec/mpegvideo_enc.c b/libavcodec/mpegvideo_enc.c
index 3eb8260b06..4da765a617 100644
--- a/libavcodec/mpegvideo_enc.c
+++ b/libavcodec/mpegvideo_enc.c
@@ -3561,11 +3561,11 @@ static int encode_picture(MPVMainEncContext *m, int picture_number)
 
     /* Estimate motion for every MB */
     if(s->pict_type != AV_PICTURE_TYPE_I){
-        s->lambda  = (s->lambda  * s->me_penalty_compensation + 128) >> 8;
-        s->lambda2 = (s->lambda2 * (int64_t) s->me_penalty_compensation + 128) >> 8;
+        s->lambda  = (s->lambda  * m->me_penalty_compensation + 128) >> 8;
+        s->lambda2 = (s->lambda2 * (int64_t) m->me_penalty_compensation + 128) >> 8;
         if (s->pict_type != AV_PICTURE_TYPE_B) {
-            if ((s->me_pre && s->last_non_b_pict_type == AV_PICTURE_TYPE_I) ||
-                s->me_pre == 2) {
+            if ((m->me_pre && s->last_non_b_pict_type == AV_PICTURE_TYPE_I) ||
+                m->me_pre == 2) {
                 s->avctx->execute(s->avctx, pre_estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
             }
         }
diff --git a/libavcodec/mpegvideoenc.h b/libavcodec/mpegvideoenc.h
index 6a96909e17..d32e4372a7 100644
--- a/libavcodec/mpegvideoenc.h
+++ b/libavcodec/mpegvideoenc.h
@@ -37,6 +37,9 @@ typedef MPVContext MPVEncContext;
 typedef struct MPVMainEncContext {
     MPVMainContext common;
 
+    int me_penalty_compensation;
+    int me_pre;                          ///< prepass for motion estimation
+
     /* bit rate control */
     int64_t total_bits;
     int frame_bits;                ///< bits used for the current frame
@@ -123,8 +126,8 @@ FF_MPV_OPT_CMP_FUNC, \
 {"sc_threshold", "Scene change threshold",                          FF_MPV_OFFSET(scenechange_threshold), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS }, \
 {"noise_reduction", "Noise reduction",                              FF_MPV_OFFSET(noise_reduction), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS }, \
 {"ps", "RTP payload size in bytes",                             FF_MPV_OFFSET(rtp_payload_size), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS }, \
-{"mepc", "Motion estimation bitrate penalty compensation (1.0 = 256)", FF_MPV_OFFSET(me_penalty_compensation), AV_OPT_TYPE_INT, {.i64 = 256 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS }, \
-{"mepre", "pre motion estimation", FF_MPV_OFFSET(me_pre), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS }, \
+{"mepc", "Motion estimation bitrate penalty compensation (1.0 = 256)", FF_MPV_MAIN_OFFSET(me_penalty_compensation), AV_OPT_TYPE_INT, {.i64 = 256 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS }, \
+{"mepre", "pre motion estimation", FF_MPV_MAIN_OFFSET(me_pre), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS }, \
 {"intra_penalty", "Penalty for intra blocks in block decision", FF_MPV_OFFSET(intra_penalty), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, INT_MAX/2, FF_MPV_OPT_FLAGS }, \
 
 #define FF_MPV_COMMON_BFRAME_OPTS \
-- 
2.32.0

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

[FFmpeg-devel] [PATCH 22/41] avcodec/mpegvideo: Move gop_size to MPVMainEncContext

[Andreas Rheinhardt]

Only used by the main encoding thread.

Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
---
 libavcodec/mpegvideo.h     |  1 -
 libavcodec/mpegvideo_enc.c | 14 +++++++-------
 libavcodec/mpegvideoenc.h  |  2 ++
 libavcodec/ratecontrol.c   |  2 +-
 4 files changed, 10 insertions(+), 9 deletions(-)

diff --git a/libavcodec/mpegvideo.h b/libavcodec/mpegvideo.h
index 7089160765..c679b7e531 100644
--- a/libavcodec/mpegvideo.h
+++ b/libavcodec/mpegvideo.h
@@ -84,7 +84,6 @@ typedef struct MPVContext {
     void *private_ctx;
     /* the following parameters must be initialized before encoding */
     int width, height;///< picture size. must be a multiple of 16
-    int gop_size;
     int intra_only;   ///< if true, only intra pictures are generated
     int64_t bit_rate; ///< wanted bit rate
     enum OutputFormat out_format; ///< output format
diff --git a/libavcodec/mpegvideo_enc.c b/libavcodec/mpegvideo_enc.c
index 4da765a617..785aeb2aee 100644
--- a/libavcodec/mpegvideo_enc.c
+++ b/libavcodec/mpegvideo_enc.c
@@ -350,7 +350,7 @@ av_cold int ff_mpv_encode_init(AVCodecContext *avctx)
                avctx->gop_size, 600);
         avctx->gop_size = 600;
     }
-    s->gop_size     = avctx->gop_size;
+    m->gop_size     = avctx->gop_size;
     s->avctx        = avctx;
     if (avctx->max_b_frames > MAX_B_FRAMES) {
         av_log(avctx, AV_LOG_ERROR, "Too many B-frames requested, maximum "
@@ -392,9 +392,9 @@ av_cold int ff_mpv_encode_init(AVCodecContext *avctx)
     }
     s->user_specified_pts = AV_NOPTS_VALUE;
 
-    if (s->gop_size <= 1) {
+    if (m->gop_size <= 1) {
         s->intra_only = 1;
-        s->gop_size   = 12;
+        m->gop_size   = 12;
     } else {
         s->intra_only = 0;
     }
@@ -1380,7 +1380,7 @@ static int select_input_picture(MPVMainEncContext *m)
     /* set next picture type & ordering */
     if (!s->reordered_input_picture[0] && s->input_picture[0]) {
         if (s->frame_skip_threshold || s->frame_skip_factor) {
-            if (s->picture_in_gop_number < s->gop_size &&
+            if (s->picture_in_gop_number < m->gop_size &&
                 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
@@ -1464,10 +1464,10 @@ static int select_input_picture(MPVMainEncContext *m)
                        "warning, too many B-frames in a row\n");
             }
 
-            if (s->picture_in_gop_number + b_frames >= s->gop_size) {
+            if (s->picture_in_gop_number + b_frames >= m->gop_size) {
                 if ((s->mpv_flags & FF_MPV_FLAG_STRICT_GOP) &&
-                    s->gop_size > s->picture_in_gop_number) {
-                    b_frames = s->gop_size - s->picture_in_gop_number - 1;
+                    m->gop_size > s->picture_in_gop_number) {
+                    b_frames = m->gop_size - s->picture_in_gop_number - 1;
                 } else {
                     if (s->avctx->flags & AV_CODEC_FLAG_CLOSED_GOP)
                         b_frames = 0;
diff --git a/libavcodec/mpegvideoenc.h b/libavcodec/mpegvideoenc.h
index d32e4372a7..1c101d01ac 100644
--- a/libavcodec/mpegvideoenc.h
+++ b/libavcodec/mpegvideoenc.h
@@ -40,6 +40,8 @@ typedef struct MPVMainEncContext {
     int me_penalty_compensation;
     int me_pre;                          ///< prepass for motion estimation
 
+    int gop_size;
+
     /* bit rate control */
     int64_t total_bits;
     int frame_bits;                ///< bits used for the current frame
diff --git a/libavcodec/ratecontrol.c b/libavcodec/ratecontrol.c
index b0f319680b..4e7bbe49a7 100644
--- a/libavcodec/ratecontrol.c
+++ b/libavcodec/ratecontrol.c
@@ -632,7 +632,7 @@ av_cold int ff_rate_control_init(MPVMainEncContext *m)
                 double bits = s->rc_initial_cplx * (i / 10000.0 + 1.0) * s->mb_num;
                 RateControlEntry rce;
 
-                if (i % ((s->gop_size + 3) / 4) == 0)
+                if (i % ((m->gop_size + 3) / 4) == 0)
                     rce.pict_type = AV_PICTURE_TYPE_I;
                 else if (i % (s->max_b_frames + 1))
                     rce.pict_type = AV_PICTURE_TYPE_B;
-- 
2.32.0

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

[FFmpeg-devel] [PATCH 23/41] avcodec/mpegvideo_enc: Don't set picture_in_gop_number for slice threads

[Andreas Rheinhardt]

They don't ever read this value.

Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
---
 libavcodec/mpegvideo_enc.c | 1 -
 1 file changed, 1 deletion(-)

diff --git a/libavcodec/mpegvideo_enc.c b/libavcodec/mpegvideo_enc.c
index 785aeb2aee..5f3bc93da7 100644
--- a/libavcodec/mpegvideo_enc.c
+++ b/libavcodec/mpegvideo_enc.c
@@ -260,7 +260,6 @@ static void update_duplicate_context_after_me(MPVEncContext *dst,
     COPY(qscale);
     COPY(lambda);
     COPY(lambda2);
-    COPY(picture_in_gop_number);
     COPY(frame_pred_frame_dct); // FIXME don't set in encode_header
     COPY(progressive_frame);    // FIXME don't set in encode_header
     COPY(partitioned_frame);    // FIXME don't set in encode_header
-- 
2.32.0

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

[FFmpeg-devel] [PATCH 24/41] avcodec/mpegvideo: Move picture_in_gop_number to MPVMainEncContext

[Andreas Rheinhardt]

Only ever used by the main encoding thread.

Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
---
 libavcodec/mpegvideo.h     |  1 -
 libavcodec/mpegvideo_enc.c | 14 +++++++-------
 libavcodec/mpegvideoenc.h  |  1 +
 3 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/libavcodec/mpegvideo.h b/libavcodec/mpegvideo.h
index c679b7e531..cab3abcc77 100644
--- a/libavcodec/mpegvideo.h
+++ b/libavcodec/mpegvideo.h
@@ -110,7 +110,6 @@ typedef struct MPVContext {
     int input_picture_number;  ///< used to set pic->display_picture_number, should not be used for/by anything else
     int coded_picture_number;  ///< used to set pic->coded_picture_number, should not be used for/by anything else
     int picture_number;       //FIXME remove, unclear definition
-    int picture_in_gop_number; ///< 0-> first pic in gop, ...
     int mb_width, mb_height;   ///< number of MBs horizontally & vertically
     int mb_stride;             ///< mb_width+1 used for some arrays to allow simple addressing of left & top MBs without sig11
     int b8_stride;             ///< 2*mb_width+1 used for some 8x8 block arrays to allow simple addressing
diff --git a/libavcodec/mpegvideo_enc.c b/libavcodec/mpegvideo_enc.c
index 5f3bc93da7..9477a02ae1 100644
--- a/libavcodec/mpegvideo_enc.c
+++ b/libavcodec/mpegvideo_enc.c
@@ -290,7 +290,7 @@ static void mpv_encode_defaults(MPVMainEncContext *m)
     s->fcode_tab     = default_fcode_tab;
 
     s->input_picture_number  = 0;
-    s->picture_in_gop_number = 0;
+    m->picture_in_gop_number = 0;
 }
 
 av_cold int ff_dct_encode_init(MPVEncContext *s)
@@ -1379,7 +1379,7 @@ static int select_input_picture(MPVMainEncContext *m)
     /* set next picture type & ordering */
     if (!s->reordered_input_picture[0] && s->input_picture[0]) {
         if (s->frame_skip_threshold || s->frame_skip_factor) {
-            if (s->picture_in_gop_number < m->gop_size &&
+            if (m->picture_in_gop_number < m->gop_size &&
                 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
@@ -1463,10 +1463,10 @@ static int select_input_picture(MPVMainEncContext *m)
                        "warning, too many B-frames in a row\n");
             }
 
-            if (s->picture_in_gop_number + b_frames >= m->gop_size) {
+            if (m->picture_in_gop_number + b_frames >= m->gop_size) {
                 if ((s->mpv_flags & FF_MPV_FLAG_STRICT_GOP) &&
-                    m->gop_size > s->picture_in_gop_number) {
-                    b_frames = m->gop_size - s->picture_in_gop_number - 1;
+                    m->gop_size > m->picture_in_gop_number) {
+                    b_frames = m->gop_size - m->picture_in_gop_number - 1;
                 } else {
                     if (s->avctx->flags & AV_CODEC_FLAG_CLOSED_GOP)
                         b_frames = 0;
@@ -1687,7 +1687,7 @@ int ff_mpv_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
 
     s->vbv_ignore_qmax = 0;
 
-    s->picture_in_gop_number++;
+    m->picture_in_gop_number++;
 
     if (load_input_picture(m, pic_arg) < 0)
         return -1;
@@ -3717,7 +3717,7 @@ static int encode_picture(MPVMainEncContext *m, int picture_number)
     s->current_picture.f->pict_type = s->pict_type;
 
     if (s->current_picture.f->key_frame)
-        s->picture_in_gop_number=0;
+        m->picture_in_gop_number=0;
 
     s->mb_x = s->mb_y = 0;
     s->last_bits= put_bits_count(&s->pb);
diff --git a/libavcodec/mpegvideoenc.h b/libavcodec/mpegvideoenc.h
index 1c101d01ac..3deee6d5fb 100644
--- a/libavcodec/mpegvideoenc.h
+++ b/libavcodec/mpegvideoenc.h
@@ -41,6 +41,7 @@ typedef struct MPVMainEncContext {
     int me_pre;                          ///< prepass for motion estimation
 
     int gop_size;
+    int picture_in_gop_number;     ///< 0-> first pic in gop, ...
 
     /* bit rate control */
     int64_t total_bits;
-- 
2.32.0

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

[FFmpeg-devel] [PATCH 25/41] avcodec/mpegvideo: Move pts and dts fields to MPVMainEncContext

[Andreas Rheinhardt]

user_specified_pts, dts_delta and reordered_pts are only used
by the main thread.

Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
---
 libavcodec/mpegvideo.h     | 10 ----------
 libavcodec/mpegvideo_enc.c | 22 +++++++++++-----------
 libavcodec/mpegvideoenc.h  | 11 +++++++++++
 3 files changed, 22 insertions(+), 21 deletions(-)

diff --git a/libavcodec/mpegvideo.h b/libavcodec/mpegvideo.h
index cab3abcc77..a334acb3aa 100644
--- a/libavcodec/mpegvideo.h
+++ b/libavcodec/mpegvideo.h
@@ -121,16 +121,6 @@ typedef struct MPVContext {
     Picture **input_picture;   ///< next pictures on display order for encoding
     Picture **reordered_input_picture; ///< pointer to the next pictures in coded order for encoding
 
-    int64_t user_specified_pts; ///< last non-zero pts from AVFrame which was passed into avcodec_send_frame()
-    /**
-     * pts difference between the first and second input frame, used for
-     * calculating dts of the first frame when there's a delay */
-    int64_t dts_delta;
-    /**
-     * reordered pts to be used as dts for the next output frame when there's
-     * a delay */
-    int64_t reordered_pts;
-
     /** bit output */
     PutBitContext pb;
 
diff --git a/libavcodec/mpegvideo_enc.c b/libavcodec/mpegvideo_enc.c
index 9477a02ae1..9b05b44d36 100644
--- a/libavcodec/mpegvideo_enc.c
+++ b/libavcodec/mpegvideo_enc.c
@@ -389,7 +389,7 @@ av_cold int ff_mpv_encode_init(AVCodecContext *avctx)
         av_log(avctx, AV_LOG_ERROR, "intra dc precision too large\n");
         return AVERROR(EINVAL);
     }
-    s->user_specified_pts = AV_NOPTS_VALUE;
+    m->user_specified_pts = AV_NOPTS_VALUE;
 
     if (m->gop_size <= 1) {
         s->intra_only = 1;
@@ -1021,8 +1021,8 @@ static int load_input_picture(MPVMainEncContext *m, const AVFrame *pic_arg)
         display_picture_number = s->input_picture_number++;
 
         if (pts != AV_NOPTS_VALUE) {
-            if (s->user_specified_pts != AV_NOPTS_VALUE) {
-                int64_t last = s->user_specified_pts;
+            if (m->user_specified_pts != AV_NOPTS_VALUE) {
+                int64_t last = m->user_specified_pts;
 
                 if (pts <= last) {
                     av_log(s->avctx, AV_LOG_ERROR,
@@ -1032,13 +1032,13 @@ static int load_input_picture(MPVMainEncContext *m, const AVFrame *pic_arg)
                 }
 
                 if (!s->low_delay && display_picture_number == 1)
-                    s->dts_delta = pts - last;
+                    m->dts_delta = pts - last;
             }
-            s->user_specified_pts = pts;
+            m->user_specified_pts = pts;
         } else {
-            if (s->user_specified_pts != AV_NOPTS_VALUE) {
-                s->user_specified_pts =
-                pts = s->user_specified_pts + 1;
+            if (m->user_specified_pts != AV_NOPTS_VALUE) {
+                m->user_specified_pts =
+                pts = m->user_specified_pts + 1;
                 av_log(s->avctx, AV_LOG_INFO,
                        "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n",
                        pts);
@@ -1887,10 +1887,10 @@ vbv_retry:
         pkt->pts = s->current_picture.f->pts;
         if (!s->low_delay && s->pict_type != AV_PICTURE_TYPE_B) {
             if (!s->current_picture.f->coded_picture_number)
-                pkt->dts = pkt->pts - s->dts_delta;
+                pkt->dts = pkt->pts - m->dts_delta;
             else
-                pkt->dts = s->reordered_pts;
-            s->reordered_pts = pkt->pts;
+                pkt->dts = m->reordered_pts;
+            m->reordered_pts = pkt->pts;
         } else
             pkt->dts = pkt->pts;
         if (s->current_picture.f->key_frame)
diff --git a/libavcodec/mpegvideoenc.h b/libavcodec/mpegvideoenc.h
index 3deee6d5fb..227701b3e3 100644
--- a/libavcodec/mpegvideoenc.h
+++ b/libavcodec/mpegvideoenc.h
@@ -43,6 +43,17 @@ typedef struct MPVMainEncContext {
     int gop_size;
     int picture_in_gop_number;     ///< 0-> first pic in gop, ...
 
+    /** last non-zero pts from AVFrame which was passed into avcodec_send_frame() */
+    int64_t user_specified_pts;
+    /**
+     * pts difference between the first and second input frame, used for
+     * calculating dts of the first frame when there's a delay */
+    int64_t dts_delta;
+    /**
+     * reordered pts to be used as dts for the next output frame when there's
+     * a delay */
+    int64_t reordered_pts;
+
     /* bit rate control */
     int64_t total_bits;
     int frame_bits;                ///< bits used for the current frame
-- 
2.32.0

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

[FFmpeg-devel] [PATCH 26/41] avcodec/mpegvideo: Move input_picture list to MPVMainEncContext

[Andreas Rheinhardt]

Also avoid an allocation while doing so.

Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
---
 libavcodec/mpegvideo.h     |  1 -
 libavcodec/mpegvideo_enc.c | 60 ++++++++++++++++++--------------------
 libavcodec/mpegvideoenc.h  |  2 ++
 3 files changed, 31 insertions(+), 32 deletions(-)

diff --git a/libavcodec/mpegvideo.h b/libavcodec/mpegvideo.h
index a334acb3aa..98810ea231 100644
--- a/libavcodec/mpegvideo.h
+++ b/libavcodec/mpegvideo.h
@@ -118,7 +118,6 @@ typedef struct MPVContext {
     ptrdiff_t linesize;        ///< line size, in bytes, may be different from width
     ptrdiff_t uvlinesize;      ///< line size, for chroma in bytes, may be different from width
     Picture *picture;          ///< main picture buffer
-    Picture **input_picture;   ///< next pictures on display order for encoding
     Picture **reordered_input_picture; ///< pointer to the next pictures in coded order for encoding
 
     /** bit output */
diff --git a/libavcodec/mpegvideo_enc.c b/libavcodec/mpegvideo_enc.c
index 9b05b44d36..1cf194dcaf 100644
--- a/libavcodec/mpegvideo_enc.c
+++ b/libavcodec/mpegvideo_enc.c
@@ -825,7 +825,6 @@ av_cold int ff_mpv_encode_init(AVCodecContext *avctx)
         !FF_ALLOCZ_TYPED_ARRAY(s->q_intra_matrix16,        32) ||
         !FF_ALLOCZ_TYPED_ARRAY(s->q_chroma_intra_matrix16, 32) ||
         !FF_ALLOCZ_TYPED_ARRAY(s->q_inter_matrix16,        32) ||
-        !FF_ALLOCZ_TYPED_ARRAY(s->input_picture,           MAX_PICTURE_COUNT) ||
         !FF_ALLOCZ_TYPED_ARRAY(s->reordered_input_picture, MAX_PICTURE_COUNT))
         return AVERROR(ENOMEM);
 
@@ -952,7 +951,6 @@ av_cold int ff_mpv_encode_end(AVCodecContext *avctx)
     av_freep(&s->q_inter_matrix);
     av_freep(&s->q_intra_matrix16);
     av_freep(&s->q_inter_matrix16);
-    av_freep(&s->input_picture);
     av_freep(&s->reordered_input_picture);
     av_freep(&s->dct_offset);
 
@@ -1137,9 +1135,9 @@ static int load_input_picture(MPVMainEncContext *m, const AVFrame *pic_arg)
         pic->f->pts = pts; // we set this here to avoid modifying pic_arg
     } else {
         /* Flushing: When we have not received enough input frames,
-         * ensure s->input_picture[0] contains the first picture */
+         * ensure m->input_picture[0] contains the first picture */
         for (flush_offset = 0; flush_offset < encoding_delay + 1; flush_offset++)
-            if (s->input_picture[flush_offset])
+            if (m->input_picture[flush_offset])
                 break;
 
         if (flush_offset <= 1)
@@ -1150,9 +1148,9 @@ static int load_input_picture(MPVMainEncContext *m, const AVFrame *pic_arg)
 
     /* shift buffer entries */
     for (i = flush_offset; i < MAX_PICTURE_COUNT /*s->encoding_delay + 1*/; i++)
-        s->input_picture[i - flush_offset] = s->input_picture[i];
+        m->input_picture[i - flush_offset] = m->input_picture[i];
 
-    s->input_picture[encoding_delay] = (Picture*) pic;
+    m->input_picture[encoding_delay] = (Picture*) pic;
 
     return 0;
 }
@@ -1249,11 +1247,11 @@ static int estimate_best_b_count(MPVMainEncContext *m)
                FF_LAMBDA_SHIFT;
 
     for (i = 0; i < s->max_b_frames + 2; i++) {
-        Picture pre_input, *pre_input_ptr = i ? s->input_picture[i - 1] :
+        Picture pre_input, *pre_input_ptr = i ? m->input_picture[i - 1] :
                                                 s->next_picture_ptr;
         uint8_t *data[4];
 
-        if (pre_input_ptr && (!i || s->input_picture[i - 1])) {
+        if (pre_input_ptr && (!i || m->input_picture[i - 1])) {
             pre_input = *pre_input_ptr;
             memcpy(data, pre_input_ptr->f->data, sizeof(data));
 
@@ -1285,7 +1283,7 @@ static int estimate_best_b_count(MPVMainEncContext *m)
         AVCodecContext *c;
         int64_t rd = 0;
 
-        if (!s->input_picture[j])
+        if (!m->input_picture[j])
             break;
 
         c = avcodec_alloc_context3(NULL);
@@ -1377,13 +1375,13 @@ static int select_input_picture(MPVMainEncContext *m)
     s->reordered_input_picture[MAX_PICTURE_COUNT - 1] = NULL;
 
     /* set next picture type & ordering */
-    if (!s->reordered_input_picture[0] && s->input_picture[0]) {
+    if (!s->reordered_input_picture[0] && m->input_picture[0]) {
         if (s->frame_skip_threshold || s->frame_skip_factor) {
             if (m->picture_in_gop_number < m->gop_size &&
                 s->next_picture_ptr &&
-                skip_check(m, s->input_picture[0], s->next_picture_ptr)) {
+                skip_check(m, m->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);
+                av_frame_unref(m->input_picture[0]->f);
 
                 ff_vbv_update(m, 0);
 
@@ -1393,7 +1391,7 @@ static int select_input_picture(MPVMainEncContext *m)
 
         if (/*s->picture_in_gop_number >= s->gop_size ||*/
             !s->next_picture_ptr || s->intra_only) {
-            s->reordered_input_picture[0] = s->input_picture[0];
+            s->reordered_input_picture[0] = m->input_picture[0];
             s->reordered_input_picture[0]->f->pict_type = AV_PICTURE_TYPE_I;
             s->reordered_input_picture[0]->f->coded_picture_number =
                 s->coded_picture_number++;
@@ -1402,38 +1400,38 @@ static int select_input_picture(MPVMainEncContext *m)
 
             if (s->avctx->flags & AV_CODEC_FLAG_PASS2) {
                 for (i = 0; i < s->max_b_frames + 1; i++) {
-                    int pict_num = s->input_picture[0]->f->display_picture_number + i;
+                    int pict_num = m->input_picture[0]->f->display_picture_number + i;
 
                     if (pict_num >= m->rc_context.num_entries)
                         break;
-                    if (!s->input_picture[i]) {
+                    if (!m->input_picture[i]) {
                         m->rc_context.entry[pict_num - 1].new_pict_type = AV_PICTURE_TYPE_P;
                         break;
                     }
 
-                    s->input_picture[i]->f->pict_type =
+                    m->input_picture[i]->f->pict_type =
                         m->rc_context.entry[pict_num].new_pict_type;
                 }
             }
 
             if (m->b_frame_strategy == 0) {
                 b_frames = s->max_b_frames;
-                while (b_frames && !s->input_picture[b_frames])
+                while (b_frames && !m->input_picture[b_frames])
                     b_frames--;
             } else if (m->b_frame_strategy == 1) {
                 for (i = 1; i < s->max_b_frames + 1; i++) {
-                    if (s->input_picture[i] &&
-                        s->input_picture[i]->b_frame_score == 0) {
-                        s->input_picture[i]->b_frame_score =
+                    if (m->input_picture[i] &&
+                        m->input_picture[i]->b_frame_score == 0) {
+                        m->input_picture[i]->b_frame_score =
                             get_intra_count(s,
-                                            s->input_picture[i    ]->f->data[0],
-                                            s->input_picture[i - 1]->f->data[0],
+                                            m->input_picture[i    ]->f->data[0],
+                                            m->input_picture[i - 1]->f->data[0],
                                             s->linesize) + 1;
                     }
                 }
                 for (i = 0; i < s->max_b_frames + 1; i++) {
-                    if (!s->input_picture[i] ||
-                        s->input_picture[i]->b_frame_score - 1 >
+                    if (!m->input_picture[i] ||
+                        m->input_picture[i]->b_frame_score - 1 >
                             s->mb_num / m->b_sensitivity)
                         break;
                 }
@@ -1442,7 +1440,7 @@ static int select_input_picture(MPVMainEncContext *m)
 
                 /* reset scores */
                 for (i = 0; i < b_frames + 1; i++) {
-                    s->input_picture[i]->b_frame_score = 0;
+                    m->input_picture[i]->b_frame_score = 0;
                 }
             } else if (m->b_frame_strategy == 2) {
                 b_frames = estimate_best_b_count(m);
@@ -1453,11 +1451,11 @@ static int select_input_picture(MPVMainEncContext *m)
             emms_c();
 
             for (i = b_frames - 1; i >= 0; i--) {
-                int type = s->input_picture[i]->f->pict_type;
+                int type = m->input_picture[i]->f->pict_type;
                 if (type && type != AV_PICTURE_TYPE_B)
                     b_frames = i;
             }
-            if (s->input_picture[b_frames]->f->pict_type == AV_PICTURE_TYPE_B &&
+            if (m->input_picture[b_frames]->f->pict_type == AV_PICTURE_TYPE_B &&
                 b_frames == s->max_b_frames) {
                 av_log(s->avctx, AV_LOG_ERROR,
                        "warning, too many B-frames in a row\n");
@@ -1470,21 +1468,21 @@ static int select_input_picture(MPVMainEncContext *m)
                 } else {
                     if (s->avctx->flags & AV_CODEC_FLAG_CLOSED_GOP)
                         b_frames = 0;
-                    s->input_picture[b_frames]->f->pict_type = AV_PICTURE_TYPE_I;
+                    m->input_picture[b_frames]->f->pict_type = AV_PICTURE_TYPE_I;
                 }
             }
 
             if ((s->avctx->flags & AV_CODEC_FLAG_CLOSED_GOP) && b_frames &&
-                s->input_picture[b_frames]->f->pict_type == AV_PICTURE_TYPE_I)
+                m->input_picture[b_frames]->f->pict_type == AV_PICTURE_TYPE_I)
                 b_frames--;
 
-            s->reordered_input_picture[0] = s->input_picture[b_frames];
+            s->reordered_input_picture[0] = m->input_picture[b_frames];
             if (s->reordered_input_picture[0]->f->pict_type != AV_PICTURE_TYPE_I)
                 s->reordered_input_picture[0]->f->pict_type = AV_PICTURE_TYPE_P;
             s->reordered_input_picture[0]->f->coded_picture_number =
                 s->coded_picture_number++;
             for (i = 0; i < b_frames; i++) {
-                s->reordered_input_picture[i + 1] = s->input_picture[i];
+                s->reordered_input_picture[i + 1] = m->input_picture[i];
                 s->reordered_input_picture[i + 1]->f->pict_type =
                     AV_PICTURE_TYPE_B;
                 s->reordered_input_picture[i + 1]->f->coded_picture_number =
diff --git a/libavcodec/mpegvideoenc.h b/libavcodec/mpegvideoenc.h
index 227701b3e3..a06e208be8 100644
--- a/libavcodec/mpegvideoenc.h
+++ b/libavcodec/mpegvideoenc.h
@@ -37,6 +37,8 @@ typedef MPVContext MPVEncContext;
 typedef struct MPVMainEncContext {
     MPVMainContext common;
 
+    Picture *input_picture[MAX_PICTURE_COUNT];   ///< next pictures in display order
+
     int me_penalty_compensation;
     int me_pre;                          ///< prepass for motion estimation
 
-- 
2.32.0

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

[FFmpeg-devel] [PATCH 27/41] avcodec/mpegvideo: Remove write-only [fb]_code

[Andreas Rheinhardt]

Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
---
 libavcodec/ituh263enc.c    | 1 -
 libavcodec/mpeg12enc.c     | 5 -----
 libavcodec/mpeg4videoenc.c | 8 --------
 libavcodec/mpegvideo.h     | 2 --
 libavcodec/mpegvideo_enc.c | 8 --------
 5 files changed, 24 deletions(-)

diff --git a/libavcodec/ituh263enc.c b/libavcodec/ituh263enc.c
index 4af7ccb527..571abdffd7 100644
--- a/libavcodec/ituh263enc.c
+++ b/libavcodec/ituh263enc.c
@@ -682,7 +682,6 @@ void ff_h263_encode_mb(MPVEncContext *s,
     if(interleaved_stats){
         if (!s->mb_intra) {
             s->p_tex_bits+= get_bits_diff(s);
-            s->f_count++;
         }else{
             s->i_tex_bits+= get_bits_diff(s);
             s->i_count++;
diff --git a/libavcodec/mpeg12enc.c b/libavcodec/mpeg12enc.c
index 78c802d897..2c937ecf61 100644
--- a/libavcodec/mpeg12enc.c
+++ b/libavcodec/mpeg12enc.c
@@ -942,7 +942,6 @@ static av_always_inline void mpeg1_encode_mb_internal(MPVEncContext *s,
                     put_sbits(&s->pb, 2, cbp);
                 }
             }
-            s->f_count++;
         } else {
             if (s->mv_type == MV_TYPE_16X16) {
                 if (cbp) {                      // With coded bloc pattern
@@ -973,7 +972,6 @@ static av_always_inline void mpeg1_encode_mb_internal(MPVEncContext *s,
                     s->last_mv[0][1][0] = s->mv[0][0][0];
                     s->last_mv[0][0][1] =
                     s->last_mv[0][1][1] = s->mv[0][0][1];
-                    s->f_count++;
                 }
                 if (s->mv_dir & MV_DIR_BACKWARD) {
                     mpeg1_encode_motion(s,
@@ -986,7 +984,6 @@ static av_always_inline void mpeg1_encode_mb_internal(MPVEncContext *s,
                     s->last_mv[1][1][0] = s->mv[1][0][0];
                     s->last_mv[1][0][1] =
                     s->last_mv[1][1][1] = s->mv[1][0][1];
-                    s->b_count++;
                 }
             } else {
                 av_assert2(s->mv_type == MV_TYPE_FIELD);
@@ -1019,7 +1016,6 @@ static av_always_inline void mpeg1_encode_mb_internal(MPVEncContext *s,
                         s->last_mv[0][i][0] = s->mv[0][i][0];
                         s->last_mv[0][i][1] = s->mv[0][i][1] * 2;
                     }
-                    s->f_count++;
                 }
                 if (s->mv_dir & MV_DIR_BACKWARD) {
                     for (i = 0; i < 2; i++) {
@@ -1033,7 +1029,6 @@ static av_always_inline void mpeg1_encode_mb_internal(MPVEncContext *s,
                         s->last_mv[1][i][0] = s->mv[1][i][0];
                         s->last_mv[1][i][1] = s->mv[1][i][1] * 2;
                     }
-                    s->b_count++;
                 }
             }
             s->mv_bits += get_bits_diff(s);
diff --git a/libavcodec/mpeg4videoenc.c b/libavcodec/mpeg4videoenc.c
index fcd436082f..4304562669 100644
--- a/libavcodec/mpeg4videoenc.c
+++ b/libavcodec/mpeg4videoenc.c
@@ -564,8 +564,6 @@ void ff_mpeg4_encode_mb(MPVEncContext *s, int16_t block[6][64],
             if (!mb_type) {
                 av_assert2(s->mv_dir & MV_DIRECT);
                 ff_h263_encode_motion_vector(s, motion_x, motion_y, 1);
-                s->b_count++;
-                s->f_count++;
             } else {
                 av_assert2(mb_type > 0 && mb_type < 4);
                 if (s->mv_type != MV_TYPE_FIELD) {
@@ -578,7 +576,6 @@ void ff_mpeg4_encode_mb(MPVEncContext *s, int16_t block[6][64],
                         s->last_mv[0][1][0] = s->mv[0][0][0];
                         s->last_mv[0][0][1] =
                         s->last_mv[0][1][1] = s->mv[0][0][1];
-                        s->f_count++;
                     }
                     if (s->mv_dir & MV_DIR_BACKWARD) {
                         ff_h263_encode_motion_vector(s,
@@ -589,7 +586,6 @@ void ff_mpeg4_encode_mb(MPVEncContext *s, int16_t block[6][64],
                         s->last_mv[1][1][0] = s->mv[1][0][0];
                         s->last_mv[1][0][1] =
                         s->last_mv[1][1][1] = s->mv[1][0][1];
-                        s->b_count++;
                     }
                 } else {
                     if (s->mv_dir & MV_DIR_FORWARD) {
@@ -609,7 +605,6 @@ void ff_mpeg4_encode_mb(MPVEncContext *s, int16_t block[6][64],
                             s->last_mv[0][i][0] = s->mv[0][i][0];
                             s->last_mv[0][i][1] = s->mv[0][i][1] * 2;
                         }
-                        s->f_count++;
                     }
                     if (s->mv_dir & MV_DIR_BACKWARD) {
                         for (i = 0; i < 2; i++) {
@@ -620,7 +615,6 @@ void ff_mpeg4_encode_mb(MPVEncContext *s, int16_t block[6][64],
                             s->last_mv[1][i][0] = s->mv[1][i][0];
                             s->last_mv[1][i][1] = s->mv[1][i][1] * 2;
                         }
-                        s->b_count++;
                     }
                 }
             }
@@ -796,8 +790,6 @@ void ff_mpeg4_encode_mb(MPVEncContext *s, int16_t block[6][64],
 
             if (interleaved_stats)
                 s->p_tex_bits += get_bits_diff(s);
-
-            s->f_count++;
         }
     } else {
         int cbp;
diff --git a/libavcodec/mpegvideo.h b/libavcodec/mpegvideo.h
index 98810ea231..bb14304495 100644
--- a/libavcodec/mpegvideo.h
+++ b/libavcodec/mpegvideo.h
@@ -306,8 +306,6 @@ typedef struct MPVContext {
     int i_tex_bits;
     int p_tex_bits;
     int i_count;
-    int f_count;
-    int b_count;
     int skip_count;
     int misc_bits; ///< cbp, mb_type
     int last_bits; ///< temp var used for calculating the above vars
diff --git a/libavcodec/mpegvideo_enc.c b/libavcodec/mpegvideo_enc.c
index 1cf194dcaf..71e751d88b 100644
--- a/libavcodec/mpegvideo_enc.c
+++ b/libavcodec/mpegvideo_enc.c
@@ -2445,8 +2445,6 @@ static inline void copy_context_before_encode(MPVEncContext *d,
     d->i_tex_bits= s->i_tex_bits;
     d->p_tex_bits= s->p_tex_bits;
     d->i_count= s->i_count;
-    d->f_count= s->f_count;
-    d->b_count= s->b_count;
     d->skip_count= s->skip_count;
     d->misc_bits= s->misc_bits;
     d->last_bits= 0;
@@ -2476,8 +2474,6 @@ static inline void copy_context_after_encode(MPVEncContext *d,
     d->i_tex_bits= s->i_tex_bits;
     d->p_tex_bits= s->p_tex_bits;
     d->i_count= s->i_count;
-    d->f_count= s->f_count;
-    d->b_count= s->b_count;
     d->skip_count= s->skip_count;
     d->misc_bits= s->misc_bits;
 
@@ -2785,8 +2781,6 @@ static int encode_thread(AVCodecContext *c, void *arg){
     s->i_tex_bits=0;
     s->p_tex_bits=0;
     s->i_count=0;
-    s->f_count=0;
-    s->b_count=0;
     s->skip_count=0;
 
     for(i=0; i<3; i++){
@@ -3418,8 +3412,6 @@ static void merge_context_after_encode(MPVEncContext *dst, MPVEncContext *src)
     MERGE(i_tex_bits);
     MERGE(p_tex_bits);
     MERGE(i_count);
-    MERGE(f_count);
-    MERGE(b_count);
     MERGE(skip_count);
     MERGE(misc_bits);
     MERGE(current_picture.encoding_error[0]);
-- 
2.32.0

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

[FFmpeg-devel] [PATCH 28/41] avcodec/mpegvideo: Move last-pic information to MPVMainEncContext

[Andreas Rheinhardt]

last_pict_type, last_non_b_pict_type and last_lambda_for
are only used by the encoder's main thread.

Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
---
 libavcodec/mpegvideo.h     |  3 ---
 libavcodec/mpegvideo_enc.c | 16 ++++++++--------
 libavcodec/mpegvideoenc.h  |  4 ++++
 libavcodec/msmpeg4enc.c    |  5 +++--
 libavcodec/ratecontrol.c   |  4 ++--
 libavcodec/snowenc.c       |  2 +-
 6 files changed, 18 insertions(+), 16 deletions(-)

diff --git a/libavcodec/mpegvideo.h b/libavcodec/mpegvideo.h
index bb14304495..8b5916f68d 100644
--- a/libavcodec/mpegvideo.h
+++ b/libavcodec/mpegvideo.h
@@ -183,10 +183,7 @@ typedef struct MPVContext {
     int dquant;                 ///< qscale difference to prev qscale
     int pict_type;              ///< AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B, ...
     int vbv_delay;
-    int last_pict_type; //FIXME removes
-    int last_non_b_pict_type;   ///< used for MPEG-4 gmc B-frames & ratecontrol
     int droppable;
-    int last_lambda_for[5];     ///< last lambda for a specific pict type
     int skipdct;                ///< skip dct and code zero residual
 
     /* motion compensation */
diff --git a/libavcodec/mpegvideo_enc.c b/libavcodec/mpegvideo_enc.c
index 71e751d88b..36e14efea2 100644
--- a/libavcodec/mpegvideo_enc.c
+++ b/libavcodec/mpegvideo_enc.c
@@ -1238,9 +1238,9 @@ static int estimate_best_b_count(MPVMainEncContext *m)
 
     //emms_c();
     //s->next_picture_ptr->quality;
-    p_lambda = s->last_lambda_for[AV_PICTURE_TYPE_P];
+    p_lambda = m->last_lambda_for[AV_PICTURE_TYPE_P];
     //p_lambda * FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
-    b_lambda = s->last_lambda_for[AV_PICTURE_TYPE_B];
+    b_lambda = m->last_lambda_for[AV_PICTURE_TYPE_B];
     if (!b_lambda) // FIXME we should do this somewhere else
         b_lambda = p_lambda;
     lambda2  = (b_lambda * b_lambda + (1 << FF_LAMBDA_SHIFT) / 2) >>
@@ -1575,10 +1575,10 @@ static void frame_end(MPVMainEncContext *m)
 
     emms_c();
 
-    s->last_pict_type                 = s->pict_type;
-    s->last_lambda_for [s->pict_type] = s->current_picture_ptr->f->quality;
+    m->last_pict_type                 = s->pict_type;
+    m->last_lambda_for [s->pict_type] = s->current_picture_ptr->f->quality;
     if (s->pict_type!= AV_PICTURE_TYPE_B)
-        s->last_non_b_pict_type = s->pict_type;
+        m->last_non_b_pict_type = s->pict_type;
 }
 
 static void update_noise_reduction(MPVMainEncContext *m)
@@ -3525,9 +3525,9 @@ static int encode_picture(MPVMainEncContext *m, int picture_number)
         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];
+            s->lambda = m->last_lambda_for[s->pict_type];
         else
-            s->lambda= s->last_lambda_for[s->last_non_b_pict_type];
+            s->lambda = m->last_lambda_for[m->last_non_b_pict_type];
         update_qscale(s);
     }
 
@@ -3553,7 +3553,7 @@ static int encode_picture(MPVMainEncContext *m, int picture_number)
         s->lambda  = (s->lambda  * m->me_penalty_compensation + 128) >> 8;
         s->lambda2 = (s->lambda2 * (int64_t) m->me_penalty_compensation + 128) >> 8;
         if (s->pict_type != AV_PICTURE_TYPE_B) {
-            if ((m->me_pre && s->last_non_b_pict_type == AV_PICTURE_TYPE_I) ||
+            if ((m->me_pre && m->last_non_b_pict_type == AV_PICTURE_TYPE_I) ||
                 m->me_pre == 2) {
                 s->avctx->execute(s->avctx, pre_estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
             }
diff --git a/libavcodec/mpegvideoenc.h b/libavcodec/mpegvideoenc.h
index a06e208be8..8e6c45c0b6 100644
--- a/libavcodec/mpegvideoenc.h
+++ b/libavcodec/mpegvideoenc.h
@@ -56,6 +56,10 @@ typedef struct MPVMainEncContext {
      * a delay */
     int64_t reordered_pts;
 
+    int last_pict_type; //FIXME remove
+    int last_non_b_pict_type;   ///< used for MPEG-4 gmc B-frames & ratecontrol
+    int last_lambda_for[5];     ///< last lambda for a specific pict type
+
     /* bit rate control */
     int64_t total_bits;
     int frame_bits;                ///< bits used for the current frame
diff --git a/libavcodec/msmpeg4enc.c b/libavcodec/msmpeg4enc.c
index 9ab7f9e146..d34de80192 100644
--- a/libavcodec/msmpeg4enc.c
+++ b/libavcodec/msmpeg4enc.c
@@ -153,7 +153,8 @@ av_cold void ff_msmpeg4_encode_init(MPVMainEncContext *m)
 
 static void find_best_tables(MSMPEG4EncContext *ms)
 {
-    MPVEncContext *const s = &ms->s.common;
+    MPVMainEncContext *const m = &ms->s;
+    MPVEncContext *const s = &m->common;
     int i;
     int best        = 0, best_size        = INT_MAX;
     int chroma_best = 0, best_chroma_size = INT_MAX;
@@ -206,7 +207,7 @@ static void find_best_tables(MSMPEG4EncContext *ms)
     s->rl_table_index       =        best;
     s->rl_chroma_table_index= chroma_best;
 
-    if(s->pict_type != s->last_non_b_pict_type){
+    if (s->pict_type != m->last_non_b_pict_type) {
         s->rl_table_index= 2;
         if(s->pict_type==AV_PICTURE_TYPE_I)
             s->rl_chroma_table_index= 1;
diff --git a/libavcodec/ratecontrol.c b/libavcodec/ratecontrol.c
index 4e7bbe49a7..03466a1a43 100644
--- a/libavcodec/ratecontrol.c
+++ b/libavcodec/ratecontrol.c
@@ -901,10 +901,10 @@ float ff_rate_estimate_qscale(MPVMainEncContext *m, int dry_run)
     /* update predictors */
     if (picture_number > 2 && !dry_run) {
         const int64_t last_var =
-            s->last_pict_type == AV_PICTURE_TYPE_I ? rcc->last_mb_var_sum
+            m->last_pict_type == AV_PICTURE_TYPE_I ? rcc->last_mb_var_sum
                                                    : rcc->last_mc_mb_var_sum;
         av_assert1(m->frame_bits >= m->stuffing_bits);
-        update_predictor(&rcc->pred[s->last_pict_type],
+        update_predictor(&rcc->pred[m->last_pict_type],
                          rcc->last_qscale,
                          sqrt(last_var),
                          m->frame_bits - m->stuffing_bits);
diff --git a/libavcodec/snowenc.c b/libavcodec/snowenc.c
index ebed90c729..6ff0491a77 100644
--- a/libavcodec/snowenc.c
+++ b/libavcodec/snowenc.c
@@ -1858,7 +1858,7 @@ redo_frame:
             return -1;
     if(avctx->flags&AV_CODEC_FLAG_PASS1)
         ff_write_pass1_stats(&s->m);
-    mpv->last_pict_type = mpv->pict_type;
+    s->m.last_pict_type = mpv->pict_type;
 
     emms_c();
 
-- 
2.32.0

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

[FFmpeg-devel] [PATCH 29/41] avcodec/mpegvideo: Move header_bits to MPVMainEncContext

[Andreas Rheinhardt]

The header is always written by the main thread, so it is
not surprising that header_bits can be moved to MPVMainEncContext
as well.

Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
---
 libavcodec/mjpegenc.c      | 14 ++++++++------
 libavcodec/mpegvideo.h     |  1 -
 libavcodec/mpegvideo_enc.c |  6 +++---
 libavcodec/mpegvideoenc.h  |  2 ++
 libavcodec/ratecontrol.c   |  2 +-
 5 files changed, 14 insertions(+), 11 deletions(-)

diff --git a/libavcodec/mjpegenc.c b/libavcodec/mjpegenc.c
index 23772c4c1f..a8efe72231 100644
--- a/libavcodec/mjpegenc.c
+++ b/libavcodec/mjpegenc.c
@@ -103,8 +103,9 @@ void ff_mjpeg_amv_encode_picture_header(MPVMainEncContext *main)
  *
  * @param s The MPVEncContext.
  */
-static void mjpeg_encode_picture_frame(MPVEncContext *s)
+static void mjpeg_encode_picture_frame(MPVMainEncContext *main)
 {
+    MPVEncContext *const s = &main->common;
     int nbits, code, table_id;
     MJpegContext *m = s->mjpeg_ctx;
     uint8_t  *huff_size[4] = { m->huff_size_dc_luminance,
@@ -118,7 +119,7 @@ static void mjpeg_encode_picture_frame(MPVEncContext *s)
     size_t total_bits = 0;
     size_t bytes_needed;
 
-    s->header_bits = get_bits_diff(s);
+    main->header_bits = get_bits_diff(s);
     // Estimate the total size first
     for (int i = 0; i < m->huff_ncode; i++) {
         table_id = m->huff_buffer[i].table_id;
@@ -224,6 +225,9 @@ int ff_mjpeg_encode_stuffing(MPVEncContext *s)
 
 #if CONFIG_MJPEG_ENCODER
     if (m->huffman == HUFFMAN_TABLE_OPTIMAL) {
+        /* HUFFMAN_TABLE_OPTIMAL is incompatible with slice threading,
+         * therefore the following cast is allowed. */
+        MPVMainEncContext *const main = (MPVMainEncContext*)s;
 
         mjpeg_build_optimal_huffman(m);
 
@@ -236,10 +240,8 @@ 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;
 
-        /* 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);
+        mjpeg_encode_picture_header(main);
+        mjpeg_encode_picture_frame(main);
     }
 #endif
 
diff --git a/libavcodec/mpegvideo.h b/libavcodec/mpegvideo.h
index 8b5916f68d..ed1416fca6 100644
--- a/libavcodec/mpegvideo.h
+++ b/libavcodec/mpegvideo.h
@@ -299,7 +299,6 @@ typedef struct MPVContext {
 
     /* statistics, used for 2-pass encoding */
     int mv_bits;
-    int header_bits;
     int i_tex_bits;
     int p_tex_bits;
     int i_count;
diff --git a/libavcodec/mpegvideo_enc.c b/libavcodec/mpegvideo_enc.c
index 36e14efea2..22f4cd2d0e 100644
--- a/libavcodec/mpegvideo_enc.c
+++ b/libavcodec/mpegvideo_enc.c
@@ -1737,7 +1737,7 @@ vbv_retry:
         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);
+            ff_mjpeg_encode_picture_trailer(&s->pb, m->header_bits);
 
         if (avctx->rc_buffer_size) {
             RateControlContext *rcc = &m->rc_context;
@@ -1794,7 +1794,7 @@ vbv_retry:
                                        s->pict_type);
 
         if (avctx->flags & AV_CODEC_FLAG_PASS1)
-            assert(put_bits_count(&s->pb) == s->header_bits + s->mv_bits +
+            assert(put_bits_count(&s->pb) == m->header_bits + s->mv_bits +
                                              s->misc_bits + s->i_tex_bits +
                                              s->p_tex_bits);
         flush_put_bits(&s->pb);
@@ -3754,7 +3754,7 @@ static int encode_picture(MPVMainEncContext *m, int picture_number)
         av_assert0(0);
     }
     bits= put_bits_count(&s->pb);
-    s->header_bits= bits - s->last_bits;
+    m->header_bits = bits - s->last_bits;
 
     for(i=1; i<context_count; i++){
         update_duplicate_context_after_me(s->thread_context[i], s);
diff --git a/libavcodec/mpegvideoenc.h b/libavcodec/mpegvideoenc.h
index 8e6c45c0b6..55c265edbe 100644
--- a/libavcodec/mpegvideoenc.h
+++ b/libavcodec/mpegvideoenc.h
@@ -60,6 +60,8 @@ typedef struct MPVMainEncContext {
     int last_non_b_pict_type;   ///< used for MPEG-4 gmc B-frames & ratecontrol
     int last_lambda_for[5];     ///< last lambda for a specific pict type
 
+    int header_bits;
+
     /* bit rate control */
     int64_t total_bits;
     int frame_bits;                ///< bits used for the current frame
diff --git a/libavcodec/ratecontrol.c b/libavcodec/ratecontrol.c
index 03466a1a43..c41682b29c 100644
--- a/libavcodec/ratecontrol.c
+++ b/libavcodec/ratecontrol.c
@@ -54,7 +54,7 @@ void ff_write_pass1_stats(MPVMainEncContext *m)
              s->current_picture.mc_mb_var_sum,
              s->current_picture.mb_var_sum,
              s->i_count, s->skip_count,
-             s->header_bits);
+             m->header_bits);
 }
 
 static double get_fps(AVCodecContext *avctx)
-- 
2.32.0

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

[FFmpeg-devel] [PATCH 30/41] avcodec/mpegvideo_enc: Remove unused function parameters

[Andreas Rheinhardt]

Seems to have been always unused since these functions were introduced
in 1f0cd30fd9b656122436ecd625656a04f6235fb3.

Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
---
 libavcodec/mpegvideo_enc.c | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/libavcodec/mpegvideo_enc.c b/libavcodec/mpegvideo_enc.c
index 22f4cd2d0e..61f8e20006 100644
--- a/libavcodec/mpegvideo_enc.c
+++ b/libavcodec/mpegvideo_enc.c
@@ -2429,7 +2429,7 @@ static av_always_inline void encode_mb(MPVEncContext *s, int motion_x, int motio
 }
 
 static inline void copy_context_before_encode(MPVEncContext *d,
-                                              const MPVEncContext *s, int type)
+                                              const MPVEncContext *s)
 {
     int i;
 
@@ -2457,7 +2457,7 @@ static inline void copy_context_before_encode(MPVEncContext *d,
 }
 
 static inline void copy_context_after_encode(MPVEncContext *d,
-                                             const MPVEncContext *s, int type)
+                                             const MPVEncContext *s)
 {
     int i;
 
@@ -2502,7 +2502,7 @@ static inline void encode_mb_hq(MPVEncContext *s, MPVEncContext *backup, MPVEncC
     int score;
     uint8_t *dest_backup[3];
 
-    copy_context_before_encode(s, backup, type);
+    copy_context_before_encode(s, backup);
 
     s->block= s->blocks[*next_block];
     s->pb= pb[*next_block];
@@ -2542,7 +2542,7 @@ static inline void encode_mb_hq(MPVEncContext *s, MPVEncContext *backup, MPVEncC
         *dmin= score;
         *next_block^=1;
 
-        copy_context_after_encode(best, s, type);
+        copy_context_after_encode(best, s);
     }
 }
 
@@ -2966,7 +2966,7 @@ static int encode_thread(AVCodecContext *c, void *arg){
                 int next_block=0;
                 int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
 
-                copy_context_before_encode(&backup_s, s, -1);
+                copy_context_before_encode(&backup_s, s);
                 backup_s.pb= s->pb;
                 best_s.data_partitioning= s->data_partitioning;
                 best_s.partitioned_frame= s->partitioned_frame;
@@ -3200,7 +3200,7 @@ static int encode_thread(AVCodecContext *c, void *arg){
 
                 s->current_picture.qscale_table[xy] = best_s.qscale;
 
-                copy_context_after_encode(s, &best_s, -1);
+                copy_context_after_encode(s, &best_s);
 
                 pb_bits_count= put_bits_count(&s->pb);
                 flush_put_bits(&s->pb);
-- 
2.32.0

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

[FFmpeg-devel] [PATCH 31/41] avcodec/mpegvideo_enc: Remove unused parameter from encode_mb_hq()

[Andreas Rheinhardt]

Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
---
 libavcodec/mpegvideo_enc.c | 32 ++++++++++++++++----------------
 1 file changed, 16 insertions(+), 16 deletions(-)

diff --git a/libavcodec/mpegvideo_enc.c b/libavcodec/mpegvideo_enc.c
index 61f8e20006..b90eb43399 100644
--- a/libavcodec/mpegvideo_enc.c
+++ b/libavcodec/mpegvideo_enc.c
@@ -2495,7 +2495,7 @@ static inline void copy_context_after_encode(MPVEncContext *d,
     d->esc3_level_length= s->esc3_level_length;
 }
 
-static inline void encode_mb_hq(MPVEncContext *s, MPVEncContext *backup, MPVEncContext *best, int type,
+static inline void encode_mb_hq(MPVEncContext *s, MPVEncContext *backup, MPVEncContext *best,
                            PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
                            int *dmin, int *next_block, int motion_x, int motion_y)
 {
@@ -2981,7 +2981,7 @@ static int encode_thread(AVCodecContext *c, void *arg){
                     s->mb_intra= 0;
                     s->mv[0][0][0] = s->p_mv_table[xy][0];
                     s->mv[0][0][1] = s->p_mv_table[xy][1];
-                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb,
+                    encode_mb_hq(s, &backup_s, &best_s, pb, pb2, tex_pb,
                                  &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
                 }
                 if(mb_type&CANDIDATE_MB_TYPE_INTER_I){
@@ -2993,7 +2993,7 @@ static int encode_thread(AVCodecContext *c, void *arg){
                         s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
                         s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
                     }
-                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb,
+                    encode_mb_hq(s, &backup_s, &best_s, pb, pb2, tex_pb,
                                  &dmin, &next_block, 0, 0);
                 }
                 if(mb_type&CANDIDATE_MB_TYPE_SKIPPED){
@@ -3002,7 +3002,7 @@ static int encode_thread(AVCodecContext *c, void *arg){
                     s->mb_intra= 0;
                     s->mv[0][0][0] = 0;
                     s->mv[0][0][1] = 0;
-                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPPED, pb, pb2, tex_pb,
+                    encode_mb_hq(s, &backup_s, &best_s, pb, pb2, tex_pb,
                                  &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
                 }
                 if(mb_type&CANDIDATE_MB_TYPE_INTER4V){
@@ -3013,7 +3013,7 @@ static int encode_thread(AVCodecContext *c, void *arg){
                         s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
                         s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
                     }
-                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb,
+                    encode_mb_hq(s, &backup_s, &best_s, pb, pb2, tex_pb,
                                  &dmin, &next_block, 0, 0);
                 }
                 if(mb_type&CANDIDATE_MB_TYPE_FORWARD){
@@ -3022,7 +3022,7 @@ static int encode_thread(AVCodecContext *c, void *arg){
                     s->mb_intra= 0;
                     s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
                     s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
-                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb,
+                    encode_mb_hq(s, &backup_s, &best_s, pb, pb2, tex_pb,
                                  &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
                 }
                 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){
@@ -3031,7 +3031,7 @@ static int encode_thread(AVCodecContext *c, void *arg){
                     s->mb_intra= 0;
                     s->mv[1][0][0] = s->b_back_mv_table[xy][0];
                     s->mv[1][0][1] = s->b_back_mv_table[xy][1];
-                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb,
+                    encode_mb_hq(s, &backup_s, &best_s, pb, pb2, tex_pb,
                                  &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
                 }
                 if(mb_type&CANDIDATE_MB_TYPE_BIDIR){
@@ -3042,7 +3042,7 @@ static int encode_thread(AVCodecContext *c, void *arg){
                     s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
                     s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
                     s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
-                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb,
+                    encode_mb_hq(s, &backup_s, &best_s, pb, pb2, tex_pb,
                                  &dmin, &next_block, 0, 0);
                 }
                 if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){
@@ -3054,7 +3054,7 @@ static int encode_thread(AVCodecContext *c, void *arg){
                         s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
                         s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
                     }
-                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb,
+                    encode_mb_hq(s, &backup_s, &best_s, pb, pb2, tex_pb,
                                  &dmin, &next_block, 0, 0);
                 }
                 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){
@@ -3066,7 +3066,7 @@ static int encode_thread(AVCodecContext *c, void *arg){
                         s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
                         s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
                     }
-                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb,
+                    encode_mb_hq(s, &backup_s, &best_s, pb, pb2, tex_pb,
                                  &dmin, &next_block, 0, 0);
                 }
                 if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){
@@ -3080,7 +3080,7 @@ static int encode_thread(AVCodecContext *c, void *arg){
                             s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
                         }
                     }
-                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb,
+                    encode_mb_hq(s, &backup_s, &best_s, pb, pb2, tex_pb,
                                  &dmin, &next_block, 0, 0);
                 }
                 if(mb_type&CANDIDATE_MB_TYPE_INTRA){
@@ -3089,7 +3089,7 @@ static int encode_thread(AVCodecContext *c, void *arg){
                     s->mb_intra= 1;
                     s->mv[0][0][0] = 0;
                     s->mv[0][0][1] = 0;
-                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb,
+                    encode_mb_hq(s, &backup_s, &best_s, pb, pb2, tex_pb,
                                  &dmin, &next_block, 0, 0);
                     if(s->h263_pred || s->h263_aic){
                         if(best_s.mb_intra)
@@ -3133,7 +3133,7 @@ static int encode_thread(AVCodecContext *c, void *arg){
                                 }
                             }
 
-                            encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
+                            encode_mb_hq(s, &backup_s, &best_s, pb, pb2, tex_pb,
                                          &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
                             if(best_s.qscale != qp){
                                 if(storecoefs){
@@ -3154,7 +3154,7 @@ static int encode_thread(AVCodecContext *c, void *arg){
                     s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
                     s->mb_intra= 0;
                     ff_mpeg4_set_direct_mv(s, mx, my);
-                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
+                    encode_mb_hq(s, &backup_s, &best_s, pb, pb2, tex_pb,
                                  &dmin, &next_block, mx, my);
                 }
                 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT0){
@@ -3162,7 +3162,7 @@ static int encode_thread(AVCodecContext *c, void *arg){
                     s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
                     s->mb_intra= 0;
                     ff_mpeg4_set_direct_mv(s, 0, 0);
-                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
+                    encode_mb_hq(s, &backup_s, &best_s, pb, pb2, tex_pb,
                                  &dmin, &next_block, 0, 0);
                 }
                 if (!best_s.mb_intra && s->mpv_flags & FF_MPV_FLAG_SKIP_RD) {
@@ -3192,7 +3192,7 @@ static int encode_thread(AVCodecContext *c, void *arg){
                         s->mv[1][0][1] = best_s.mv[1][0][1];*/
                         backup_s.dquant= 0;
                         s->skipdct=1;
-                        encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
+                        encode_mb_hq(s, &backup_s, &best_s, pb, pb2, tex_pb,
                                         &dmin, &next_block, mx, my);
                         s->skipdct=0;
                     }
-- 
2.32.0

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

[FFmpeg-devel] [PATCH 32/41] avcodec/mpegvideo: Move vbv_delay to Mpeg1Context

[Andreas Rheinhardt]

Only used there and only by the main thread.

Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
---
 libavcodec/mpeg12dec.c | 5 +++--
 libavcodec/mpegvideo.h | 1 -
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/libavcodec/mpeg12dec.c b/libavcodec/mpeg12dec.c
index 4c53451d8c..631582fd61 100644
--- a/libavcodec/mpeg12dec.c
+++ b/libavcodec/mpeg12dec.c
@@ -69,6 +69,7 @@ typedef struct Mpeg1Context {
     AVRational save_aspect;
     int save_width, save_height, save_progressive_seq;
     int rc_buffer_size;
+    int vbv_delay;
     AVRational frame_rate_ext;  /* MPEG-2 specific framerate modificator */
     unsigned frame_rate_index;
     int sync;                   /* Did we reach a sync point like a GOP/SEQ/KEYFrame? */
@@ -1284,7 +1285,7 @@ static int mpeg_decode_postinit(AVCodecContext *avctx)
         if (avctx->codec_id == AV_CODEC_ID_MPEG2VIDEO && s->bit_rate) {
             avctx->rc_max_rate = s->bit_rate;
         } else if (avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO && s->bit_rate &&
-                   (s->bit_rate != 0x3FFFF*400 || s->vbv_delay != 0xFFFF)) {
+                   (s->bit_rate != 0x3FFFF*400 || s1->vbv_delay != 0xFFFF)) {
             avctx->bit_rate = s->bit_rate;
         }
         s1->save_aspect          = s->avctx->sample_aspect_ratio;
@@ -1357,7 +1358,7 @@ static int mpeg1_decode_picture(AVCodecContext *avctx, const uint8_t *buf,
         return AVERROR_INVALIDDATA;
 
     vbv_delay = get_bits(&s->gb, 16);
-    s->vbv_delay = vbv_delay;
+    s1->vbv_delay = vbv_delay;
     if (s->pict_type == AV_PICTURE_TYPE_P ||
         s->pict_type == AV_PICTURE_TYPE_B) {
         s->full_pel[0] = get_bits1(&s->gb);
diff --git a/libavcodec/mpegvideo.h b/libavcodec/mpegvideo.h
index ed1416fca6..0e8e11743e 100644
--- a/libavcodec/mpegvideo.h
+++ b/libavcodec/mpegvideo.h
@@ -182,7 +182,6 @@ typedef struct MPVContext {
     int adaptive_quant;         ///< use adaptive quantization
     int dquant;                 ///< qscale difference to prev qscale
     int pict_type;              ///< AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B, ...
-    int vbv_delay;
     int droppable;
     int skipdct;                ///< skip dct and code zero residual
 
-- 
2.32.0

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

[FFmpeg-devel] [PATCH 33/41] avcodec/mpegvideo: Move brd_scale to MPVMainEncContext

[Andreas Rheinhardt]

Only used by the main encoding thread.

Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
---
 libavcodec/mpegvideo.h     | 1 -
 libavcodec/mpegvideo_enc.c | 6 +++---
 libavcodec/mpegvideoenc.h  | 5 +++--
 3 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/libavcodec/mpegvideo.h b/libavcodec/mpegvideo.h
index 0e8e11743e..c11aba340e 100644
--- a/libavcodec/mpegvideo.h
+++ b/libavcodec/mpegvideo.h
@@ -410,7 +410,6 @@ typedef struct MPVContext {
     int top_field_first;
     int concealment_motion_vectors;
     int q_scale_type;
-    int brd_scale;
     int intra_vlc_format;
     int alternate_scan;
 #define VIDEO_FORMAT_COMPONENT   0
diff --git a/libavcodec/mpegvideo_enc.c b/libavcodec/mpegvideo_enc.c
index b90eb43399..1039a50db8 100644
--- a/libavcodec/mpegvideo_enc.c
+++ b/libavcodec/mpegvideo_enc.c
@@ -907,8 +907,8 @@ av_cold int ff_mpv_encode_init(AVCodecContext *avctx)
                 return AVERROR(ENOMEM);
 
             m->tmp_frames[i]->format = AV_PIX_FMT_YUV420P;
-            m->tmp_frames[i]->width  = s->width  >> s->brd_scale;
-            m->tmp_frames[i]->height = s->height >> s->brd_scale;
+            m->tmp_frames[i]->width  = s->width  >> m->brd_scale;
+            m->tmp_frames[i]->height = s->height >> m->brd_scale;
 
             ret = av_frame_get_buffer(m->tmp_frames[i], 0);
             if (ret < 0)
@@ -1222,7 +1222,7 @@ static int estimate_best_b_count(MPVMainEncContext *m)
 {
     MPVEncContext *const s = &m->common;
     AVPacket *pkt;
-    const int scale = s->brd_scale;
+    const int scale = m->brd_scale;
     int width  = s->width  >> scale;
     int height = s->height >> scale;
     int i, j, out_size, p_lambda, b_lambda, lambda2;
diff --git a/libavcodec/mpegvideoenc.h b/libavcodec/mpegvideoenc.h
index 55c265edbe..539bdf3065 100644
--- a/libavcodec/mpegvideoenc.h
+++ b/libavcodec/mpegvideoenc.h
@@ -73,6 +73,7 @@ typedef struct MPVMainEncContext {
     AVFrame *tmp_frames[MAX_B_FRAMES + 2];
     int b_frame_strategy;
     int b_sensitivity;
+    int brd_scale;
 } MPVMainEncContext;
 
 /* mpegvideo_enc common options */
@@ -155,7 +156,7 @@ FF_MPV_OPT_CMP_FUNC, \
 #define FF_MPV_COMMON_BFRAME_OPTS \
 {"b_strategy", "Strategy to choose between I/P/B-frames",      FF_MPV_MAIN_OFFSET(b_frame_strategy), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, 2, FF_MPV_OPT_FLAGS }, \
 {"b_sensitivity", "Adjust sensitivity of b_frame_strategy 1",  FF_MPV_MAIN_OFFSET(b_sensitivity), AV_OPT_TYPE_INT, {.i64 = 40 }, 1, INT_MAX, FF_MPV_OPT_FLAGS }, \
-{"brd_scale", "Downscale frames for dynamic B-frame decision", FF_MPV_OFFSET(brd_scale), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, 3, FF_MPV_OPT_FLAGS },
+{"brd_scale", "Downscale frames for dynamic B-frame decision", FF_MPV_MAIN_OFFSET(brd_scale), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, 3, FF_MPV_OPT_FLAGS },
 
 #if FF_API_MPEGVIDEO_OPTS
 #define FF_MPV_DEPRECATED_MPEG_QUANT_OPT \
@@ -167,7 +168,7 @@ FF_MPV_OPT_CMP_FUNC, \
 #define FF_MPV_DEPRECATED_BFRAME_OPTS \
    { "b_strategy",    "Deprecated, does nothing", FF_MPV_MAIN_OFFSET(b_frame_strategy), AV_OPT_TYPE_INT, { .i64 =  0 }, 0, 2, FF_MPV_OPT_FLAGS | AV_OPT_FLAG_DEPRECATED }, \
    { "b_sensitivity", "Deprecated, does nothing", FF_MPV_MAIN_OFFSET(b_sensitivity),    AV_OPT_TYPE_INT, { .i64 = 40 }, 1, INT_MAX, FF_MPV_OPT_FLAGS | AV_OPT_FLAG_DEPRECATED }, \
-   { "brd_scale",     "Deprecated, does nothing", FF_MPV_OFFSET(brd_scale),        AV_OPT_TYPE_INT, { .i64 =  0 }, 0, 3, FF_MPV_OPT_FLAGS | AV_OPT_FLAG_DEPRECATED },
+   { "brd_scale",     "Deprecated, does nothing", FF_MPV_MAIN_OFFSET(brd_scale),        AV_OPT_TYPE_INT, { .i64 =  0 }, 0, 3, FF_MPV_OPT_FLAGS | AV_OPT_FLAG_DEPRECATED },
 #endif
 
 extern const AVClass ff_mpv_enc_class;
-- 
2.32.0

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

[FFmpeg-devel] [PATCH 34/41] avcodec/mpegvideo: Move ratecontrol parameters to MPVMainEncContext

[Andreas Rheinhardt]

All except vbv_ignore_qmax are only ever used by the main encoding
thread.

Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
---
 libavcodec/mpegvideo.h     | 13 -------------
 libavcodec/mpegvideo_enc.c |  4 ++--
 libavcodec/mpegvideoenc.h  | 31 ++++++++++++++++++++++---------
 libavcodec/ratecontrol.c   | 38 ++++++++++++++++++++------------------
 libavcodec/snowenc.c       |  6 +++---
 5 files changed, 47 insertions(+), 45 deletions(-)

diff --git a/libavcodec/mpegvideo.h b/libavcodec/mpegvideo.h
index c11aba340e..ed62175db5 100644
--- a/libavcodec/mpegvideo.h
+++ b/libavcodec/mpegvideo.h
@@ -473,21 +473,8 @@ typedef struct MPVContext {
     int mpv_flags;      ///< flags set by private options
     int quantizer_noise_shaping;
 
-    /**
-     * ratecontrol qmin qmax limiting method
-     * 0-> clipping, 1-> use a nice continuous function to limit qscale within qmin/qmax.
-     */
-    float rc_qsquish;
-    float rc_qmod_amp;
-    int   rc_qmod_freq;
-    float rc_initial_cplx;
-    float rc_buffer_aggressivity;
-    float border_masking;
-    int lmin, lmax;
     int vbv_ignore_qmax;
 
-    char *rc_eq;
-
     /* temp buffers for rate control */
     float *cplx_tab, *bits_tab;
 
diff --git a/libavcodec/mpegvideo_enc.c b/libavcodec/mpegvideo_enc.c
index 1039a50db8..fd82681869 100644
--- a/libavcodec/mpegvideo_enc.c
+++ b/libavcodec/mpegvideo_enc.c
@@ -406,7 +406,7 @@ av_cold int ff_mpv_encode_init(AVCodecContext *avctx)
                          avctx->temporal_cplx_masking ||
                          avctx->spatial_cplx_masking  ||
                          avctx->p_masking      ||
-                         s->border_masking ||
+                         m->border_masking ||
                          (s->mpv_flags & FF_MPV_FLAG_QP_RD)) &&
                         !s->fixed_qscale;
 
@@ -1746,7 +1746,7 @@ vbv_retry:
             int min_step = hq ? 1 : (1<<(FF_LAMBDA_SHIFT + 7))/139;
 
             if (put_bits_count(&s->pb) > max_size &&
-                s->lambda < s->lmax) {
+                s->lambda < m->lmax) {
                 m->next_lambda = FFMAX(s->lambda + min_step, s->lambda *
                                        (s->qscale + 1) / s->qscale);
                 if (s->adaptive_quant) {
diff --git a/libavcodec/mpegvideoenc.h b/libavcodec/mpegvideoenc.h
index 539bdf3065..ada5935410 100644
--- a/libavcodec/mpegvideoenc.h
+++ b/libavcodec/mpegvideoenc.h
@@ -68,6 +68,19 @@ typedef struct MPVMainEncContext {
     int stuffing_bits;             ///< bits used for stuffing
     int next_lambda;               ///< next lambda used for retrying to encode a frame
     RateControlContext rc_context; ///< contains stuff only accessed in ratecontrol.c
+    /**
+     * ratecontrol qmin qmax limiting method
+     * 0-> clipping, 1-> use a nice continuous function to limit qscale within qmin/qmax.
+     */
+    float rc_qsquish;
+    float rc_qmod_amp;
+    int   rc_qmod_freq;
+    float rc_initial_cplx;
+    float rc_buffer_aggressivity;
+    float border_masking;
+    int lmin, lmax;
+
+    char *rc_eq;
 
     /* temporary frames used by b_frame_strategy == 2 */
     AVFrame *tmp_frames[MAX_B_FRAMES + 2];
@@ -123,19 +136,19 @@ FF_MPV_OPT_CMP_FUNC, \
 { "error_rate", "Simulate errors in the bitstream to test error concealment.",                                                                                                  \
                                                                     FF_MPV_OFFSET(error_rate),              AV_OPT_TYPE_INT, { .i64 = 0 },       0, INT_MAX, FF_MPV_OPT_FLAGS },\
 {"qsquish", "how to keep quantizer between qmin and qmax (0 = clip, 1 = use differentiable function)",                                                                          \
-                                                                    FF_MPV_OFFSET(rc_qsquish), AV_OPT_TYPE_FLOAT, {.dbl = 0 }, 0, 99, FF_MPV_OPT_FLAGS},                        \
-{"rc_qmod_amp", "experimental quantizer modulation",                FF_MPV_OFFSET(rc_qmod_amp), AV_OPT_TYPE_FLOAT, {.dbl = 0 }, -FLT_MAX, FLT_MAX, FF_MPV_OPT_FLAGS},           \
-{"rc_qmod_freq", "experimental quantizer modulation",               FF_MPV_OFFSET(rc_qmod_freq), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS},             \
+                                                                    FF_MPV_MAIN_OFFSET(rc_qsquish), AV_OPT_TYPE_FLOAT, {.dbl = 0 }, 0, 99, FF_MPV_OPT_FLAGS},                        \
+{"rc_qmod_amp", "experimental quantizer modulation",                FF_MPV_MAIN_OFFSET(rc_qmod_amp), AV_OPT_TYPE_FLOAT, {.dbl = 0 }, -FLT_MAX, FLT_MAX, FF_MPV_OPT_FLAGS},           \
+{"rc_qmod_freq", "experimental quantizer modulation",               FF_MPV_MAIN_OFFSET(rc_qmod_freq), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS},             \
 {"rc_eq", "Set rate control equation. When computing the expression, besides the standard functions "                                                                           \
           "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.",                                                                         \
-                                                                    FF_MPV_OFFSET(rc_eq), AV_OPT_TYPE_STRING,                           .flags = FF_MPV_OPT_FLAGS },            \
-{"rc_init_cplx", "initial complexity for 1-pass encoding",          FF_MPV_OFFSET(rc_initial_cplx), AV_OPT_TYPE_FLOAT, {.dbl = 0 }, -FLT_MAX, FLT_MAX, FF_MPV_OPT_FLAGS},       \
-{"rc_buf_aggressivity", "currently useless",                        FF_MPV_OFFSET(rc_buffer_aggressivity), AV_OPT_TYPE_FLOAT, {.dbl = 1.0 }, -FLT_MAX, FLT_MAX, FF_MPV_OPT_FLAGS}, \
-{"border_mask", "increase the quantizer for macroblocks close to borders", FF_MPV_OFFSET(border_masking), AV_OPT_TYPE_FLOAT, {.dbl = 0 }, -FLT_MAX, FLT_MAX, FF_MPV_OPT_FLAGS},    \
-{"lmin", "minimum Lagrange factor (VBR)",                           FF_MPV_OFFSET(lmin), AV_OPT_TYPE_INT, {.i64 =  2*FF_QP2LAMBDA }, 0, INT_MAX, FF_MPV_OPT_FLAGS },            \
-{"lmax", "maximum Lagrange factor (VBR)",                           FF_MPV_OFFSET(lmax), AV_OPT_TYPE_INT, {.i64 = 31*FF_QP2LAMBDA }, 0, INT_MAX, FF_MPV_OPT_FLAGS },            \
+                                                                    FF_MPV_MAIN_OFFSET(rc_eq), AV_OPT_TYPE_STRING,                           .flags = FF_MPV_OPT_FLAGS },            \
+{"rc_init_cplx", "initial complexity for 1-pass encoding",          FF_MPV_MAIN_OFFSET(rc_initial_cplx), AV_OPT_TYPE_FLOAT, {.dbl = 0 }, -FLT_MAX, FLT_MAX, FF_MPV_OPT_FLAGS},       \
+{"rc_buf_aggressivity", "currently useless",                        FF_MPV_MAIN_OFFSET(rc_buffer_aggressivity), AV_OPT_TYPE_FLOAT, {.dbl = 1.0 }, -FLT_MAX, FLT_MAX, FF_MPV_OPT_FLAGS}, \
+{"border_mask", "increase the quantizer for macroblocks close to borders", FF_MPV_MAIN_OFFSET(border_masking), AV_OPT_TYPE_FLOAT, {.dbl = 0 }, -FLT_MAX, FLT_MAX, FF_MPV_OPT_FLAGS},    \
+{"lmin", "minimum Lagrange factor (VBR)",                           FF_MPV_MAIN_OFFSET(lmin), AV_OPT_TYPE_INT, {.i64 =  2*FF_QP2LAMBDA }, 0, INT_MAX, FF_MPV_OPT_FLAGS },            \
+{"lmax", "maximum Lagrange factor (VBR)",                           FF_MPV_MAIN_OFFSET(lmax), AV_OPT_TYPE_INT, {.i64 = 31*FF_QP2LAMBDA }, 0, INT_MAX, FF_MPV_OPT_FLAGS },            \
 {"ibias", "intra quant bias",                                       FF_MPV_OFFSET(intra_quant_bias), AV_OPT_TYPE_INT, {.i64 = FF_DEFAULT_QUANT_BIAS }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS },   \
 {"pbias", "inter quant bias",                                       FF_MPV_OFFSET(inter_quant_bias), AV_OPT_TYPE_INT, {.i64 = FF_DEFAULT_QUANT_BIAS }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS },   \
 {"motion_est", "motion estimation algorithm",                       FF_MPV_OFFSET(motion_est), AV_OPT_TYPE_INT, {.i64 = FF_ME_EPZS }, FF_ME_ZERO, FF_ME_XONE, FF_MPV_OPT_FLAGS, "motion_est" },   \
diff --git a/libavcodec/ratecontrol.c b/libavcodec/ratecontrol.c
index c41682b29c..fa28e6d61d 100644
--- a/libavcodec/ratecontrol.c
+++ b/libavcodec/ratecontrol.c
@@ -118,10 +118,12 @@ static double get_diff_limited_q(MPVMainEncContext *m, RateControlEntry *rce, do
 /**
  * Get the qmin & qmax for pict_type.
  */
-static void get_qminmax(int *qmin_ret, int *qmax_ret, MPVEncContext *s, int pict_type)
+static void get_qminmax(int *qmin_ret, int *qmax_ret,
+                        MPVMainEncContext *m, int pict_type)
 {
-    int qmin = s->lmin;
-    int qmax = s->lmax;
+    MPVEncContext *const s = &m->common;
+    int qmin = m->lmin;
+    int qmax = m->lmax;
 
     av_assert0(qmin <= qmax);
 
@@ -158,13 +160,13 @@ static double modify_qscale(MPVMainEncContext *m, RateControlEntry *rce,
     const int pict_type      = rce->new_pict_type;
     int qmin, qmax;
 
-    get_qminmax(&qmin, &qmax, s, pict_type);
+    get_qminmax(&qmin, &qmax, m, pict_type);
 
     /* modulation */
-    if (s->rc_qmod_freq &&
-        frame_num % s->rc_qmod_freq == 0 &&
+    if (m->rc_qmod_freq &&
+        frame_num % m->rc_qmod_freq == 0 &&
         pict_type == AV_PICTURE_TYPE_P)
-        q *= s->rc_qmod_amp;
+        q *= m->rc_qmod_amp;
 
     /* buffer overflow/underflow protection */
     if (buffer_size) {
@@ -177,7 +179,7 @@ static double modify_qscale(MPVMainEncContext *m, RateControlEntry *rce,
                 d = 1.0;
             else if (d < 0.0001)
                 d = 0.0001;
-            q *= pow(d, 1.0 / s->rc_buffer_aggressivity);
+            q *= pow(d, 1.0 / m->rc_buffer_aggressivity);
 
             q_limit = bits2qp(rce,
                               FFMAX((min_rate - buffer_size + rcc->buffer_index) *
@@ -197,7 +199,7 @@ static double modify_qscale(MPVMainEncContext *m, RateControlEntry *rce,
                 d = 1.0;
             else if (d < 0.0001)
                 d = 0.0001;
-            q /= pow(d, 1.0 / s->rc_buffer_aggressivity);
+            q /= pow(d, 1.0 / m->rc_buffer_aggressivity);
 
             q_limit = bits2qp(rce,
                               FFMAX(rcc->buffer_index *
@@ -213,8 +215,8 @@ static double modify_qscale(MPVMainEncContext *m, RateControlEntry *rce,
     }
     ff_dlog(s, "q:%f max:%f min:%f size:%f index:%f agr:%f\n",
             q, max_rate, min_rate, buffer_size, rcc->buffer_index,
-            s->rc_buffer_aggressivity);
-    if (s->rc_qsquish == 0.0 || qmin == qmax) {
+            m->rc_buffer_aggressivity);
+    if (m->rc_qsquish == 0.0 || qmin == qmax) {
         if (q < qmin)
             q = qmin;
         else if (q > qmax)
@@ -275,7 +277,7 @@ static double get_qscale(MPVMainEncContext *m, RateControlEntry *rce,
 
     bits = av_expr_eval(rcc->rc_eq_eval, const_values, rce);
     if (isnan(bits)) {
-        av_log(s->avctx, AV_LOG_ERROR, "Error evaluating rc_eq \"%s\"\n", s->rc_eq);
+        av_log(s->avctx, AV_LOG_ERROR, "Error evaluating rc_eq \"%s\"\n", m->rc_eq);
         return -1;
     }
 
@@ -522,11 +524,11 @@ av_cold int ff_rate_control_init(MPVMainEncContext *m)
     }
 
     res = av_expr_parse(&rcc->rc_eq_eval,
-                        s->rc_eq ? s->rc_eq : "tex^qComp",
+                        m->rc_eq ? m->rc_eq : "tex^qComp",
                         const_names, func1_names, func1,
                         NULL, NULL, 0, s->avctx);
     if (res < 0) {
-        av_log(s->avctx, AV_LOG_ERROR, "Error parsing rc_eq \"%s\"\n", s->rc_eq);
+        av_log(s->avctx, AV_LOG_ERROR, "Error parsing rc_eq \"%s\"\n", m->rc_eq);
         return res;
     }
 
@@ -627,9 +629,9 @@ av_cold int ff_rate_control_init(MPVMainEncContext *m)
             return -1;
         }
         /* init stuff with the user specified complexity */
-        if (s->rc_initial_cplx) {
+        if (m->rc_initial_cplx) {
             for (i = 0; i < 60 * 30; i++) {
-                double bits = s->rc_initial_cplx * (i / 10000.0 + 1.0) * s->mb_num;
+                double bits = m->rc_initial_cplx * (i / 10000.0 + 1.0) * s->mb_num;
                 RateControlEntry rce;
 
                 if (i % ((m->gop_size + 3) / 4) == 0)
@@ -753,7 +755,7 @@ static void adaptive_quantization(MPVMainEncContext *m, double q)
     const float temp_cplx_masking    = s->avctx->temporal_cplx_masking;
     const float spatial_cplx_masking = s->avctx->spatial_cplx_masking;
     const float p_masking            = s->avctx->p_masking;
-    const float border_masking       = s->border_masking;
+    const float border_masking       = m->border_masking;
     float bits_sum                   = 0.0;
     float cplx_sum                   = 0.0;
     float *cplx_tab                  = s->cplx_tab;
@@ -895,7 +897,7 @@ float ff_rate_estimate_qscale(MPVMainEncContext *m, int dry_run)
     Picture * const pic = &s->current_picture;
     emms_c();
 
-    get_qminmax(&qmin, &qmax, s, pict_type);
+    get_qminmax(&qmin, &qmax, m, pict_type);
 
     fps = get_fps(s->avctx);
     /* update predictors */
diff --git a/libavcodec/snowenc.c b/libavcodec/snowenc.c
index 6ff0491a77..ce5baa754f 100644
--- a/libavcodec/snowenc.c
+++ b/libavcodec/snowenc.c
@@ -75,8 +75,8 @@ static av_cold int encode_init(AVCodecContext *avctx)
 
     mpv->avctx   = avctx;
     mpv->bit_rate= avctx->bit_rate;
-    mpv->lmin    = avctx->mb_lmin;
-    mpv->lmax    = avctx->mb_lmax;
+    s->m.lmin    = avctx->mb_lmin;
+    s->m.lmax    = avctx->mb_lmax;
     mpv->mb_num  = (avctx->width * avctx->height + 255) / 256; // For ratecontrol
 
     mpv->me.temp      =
@@ -1907,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.common.rc_eq), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, VE },
+                                                                                  OFFSET(m.rc_eq), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, VE },
     { NULL },
 };
 
-- 
2.32.0

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

[FFmpeg-devel] [PATCH 35/41] avcodec/mpegvideo: Allocate encoder-only tables in mpegvideo_enc.c

[Andreas Rheinhardt]

This commit moves the encoder-only allocations of the tables
owned solely by the main encoder context to mpegvideo_enc.c.
This avoids checks in mpegvideo.c for whether we are dealing
with an encoder; it also improves modularity (if encoders are
disabled, this code will no longer be included in the binary).
And it also avoids having to reset these pointers at the beginning
of ff_mpv_common_init() (in case the dst context is uninitialized,
ff_mpeg_update_thread_context() simply copies the src context
into dst which therefore may contain pointers not owned by it,
but this does not happen for encoders at all).

Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
---
 libavcodec/mpegvideo.c     | 118 +++----------------------------------
 libavcodec/mpegvideo_enc.c |  68 ++++++++++++++++++++-
 2 files changed, 74 insertions(+), 112 deletions(-)

diff --git a/libavcodec/mpegvideo.c b/libavcodec/mpegvideo.c
index 500f8af19d..9836000ad9 100644
--- a/libavcodec/mpegvideo.c
+++ b/libavcodec/mpegvideo.c
@@ -557,61 +557,13 @@ int ff_mpv_init_context_frame(MPVContext *s)
 
     s->mb_index2xy[s->mb_height * s->mb_width] = (s->mb_height - 1) * s->mb_stride + s->mb_width; // FIXME really needed?
 
-    if (s->encoding) {
-        /* Allocate MV tables */
-        if (!FF_ALLOCZ_TYPED_ARRAY(s->p_mv_table_base,            mv_table_size) ||
-            !FF_ALLOCZ_TYPED_ARRAY(s->b_forw_mv_table_base,       mv_table_size) ||
-            !FF_ALLOCZ_TYPED_ARRAY(s->b_back_mv_table_base,       mv_table_size) ||
-            !FF_ALLOCZ_TYPED_ARRAY(s->b_bidir_forw_mv_table_base, mv_table_size) ||
-            !FF_ALLOCZ_TYPED_ARRAY(s->b_bidir_back_mv_table_base, mv_table_size) ||
-            !FF_ALLOCZ_TYPED_ARRAY(s->b_direct_mv_table_base,     mv_table_size))
-            return AVERROR(ENOMEM);
-        s->p_mv_table            = s->p_mv_table_base + s->mb_stride + 1;
-        s->b_forw_mv_table       = s->b_forw_mv_table_base + s->mb_stride + 1;
-        s->b_back_mv_table       = s->b_back_mv_table_base + s->mb_stride + 1;
-        s->b_bidir_forw_mv_table = s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
-        s->b_bidir_back_mv_table = s->b_bidir_back_mv_table_base + s->mb_stride + 1;
-        s->b_direct_mv_table     = s->b_direct_mv_table_base + s->mb_stride + 1;
-
-        /* Allocate MB type table */
-        if (!FF_ALLOCZ_TYPED_ARRAY(s->mb_type,      mb_array_size) ||
-            !FF_ALLOCZ_TYPED_ARRAY(s->lambda_table, mb_array_size) ||
-            !FF_ALLOC_TYPED_ARRAY (s->cplx_tab,     mb_array_size) ||
-            !FF_ALLOC_TYPED_ARRAY (s->bits_tab,     mb_array_size))
-            return AVERROR(ENOMEM);
-
-#define ALLOCZ_ARRAYS(p, mult, numb) ((p) = av_calloc(numb, mult * sizeof(*(p))))
-        if (s->codec_id == AV_CODEC_ID_MPEG4 ||
-            (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_ME)) {
-            int16_t (*tmp1)[2];
-            uint8_t *tmp2;
-            if (!(tmp1 = ALLOCZ_ARRAYS(s->b_field_mv_table_base, 8, mv_table_size)) ||
-                !(tmp2 = ALLOCZ_ARRAYS(s->b_field_select_table[0][0], 2 * 4, mv_table_size)) ||
-                !ALLOCZ_ARRAYS(s->p_field_select_table[0], 2 * 2, mv_table_size))
-                return AVERROR(ENOMEM);
-
-            s->p_field_select_table[1] = s->p_field_select_table[0] + 2 * mv_table_size;
-            tmp1 += s->mb_stride + 1;
-
-            for (int i = 0; i < 2; i++) {
-                for (int j = 0; j < 2; j++) {
-                    for (int k = 0; k < 2; k++) {
-                        s->b_field_mv_table[i][j][k] = tmp1;
-                        tmp1 += mv_table_size;
-                    }
-                    s->b_field_select_table[i][j] = tmp2;
-                    tmp2 += 2 * mv_table_size;
-                }
-            }
-        }
-    }
-
     if (s->codec_id == AV_CODEC_ID_MPEG4 ||
         (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_ME)) {
-        int16_t (*tmp)[2];
         /* interlaced direct mode decoding tables */
-        if (!(tmp = ALLOCZ_ARRAYS(s->p_field_mv_table_base, 4, mv_table_size)))
+        int16_t (*tmp)[2] = av_calloc(mv_table_size, 4 * sizeof(*tmp));
+        if (!tmp)
             return AVERROR(ENOMEM);
+        s->p_field_mv_table_base = tmp;
         tmp += s->mb_stride + 1;
         for (int i = 0; i < 2; i++) {
             for (int j = 0; j < 2; j++) {
@@ -654,8 +606,6 @@ int ff_mpv_init_context_frame(MPVContext *s)
 
 static void clear_context(MPVMainContext *s)
 {
-    int i, j, k;
-
     memset(&s->next_picture, 0, sizeof(s->next_picture));
     memset(&s->last_picture, 0, sizeof(s->last_picture));
     memset(&s->current_picture, 0, sizeof(s->current_picture));
@@ -684,31 +634,10 @@ static void clear_context(MPVMainContext *s)
     s->bitstream_buffer = NULL;
     s->allocated_bitstream_buffer_size = 0;
     s->picture          = NULL;
-    s->mb_type          = NULL;
-    s->p_mv_table_base  = NULL;
-    s->b_forw_mv_table_base = NULL;
-    s->b_back_mv_table_base = NULL;
-    s->b_bidir_forw_mv_table_base = NULL;
-    s->b_bidir_back_mv_table_base = NULL;
-    s->b_direct_mv_table_base = NULL;
-    s->p_mv_table            = NULL;
-    s->b_forw_mv_table       = NULL;
-    s->b_back_mv_table       = NULL;
-    s->b_bidir_forw_mv_table = NULL;
-    s->b_bidir_back_mv_table = NULL;
-    s->b_direct_mv_table     = NULL;
-    s->b_field_mv_table_base = NULL;
     s->p_field_mv_table_base = NULL;
-    for (i = 0; i < 2; i++) {
-        for (j = 0; j < 2; j++) {
-            for (k = 0; k < 2; k++) {
-                s->b_field_mv_table[i][j][k] = NULL;
-            }
-            s->b_field_select_table[i][j] = NULL;
+    for (int i = 0; i < 2; i++)
+        for (int j = 0; j < 2; j++)
             s->p_field_mv_table[i][j] = NULL;
-        }
-        s->p_field_select_table[i] = NULL;
-    }
 
     s->dc_val_base = NULL;
     s->coded_block_base = NULL;
@@ -721,10 +650,6 @@ static void clear_context(MPVMainContext *s)
     s->er.error_status_table = NULL;
     s->er.er_temp_buffer = NULL;
     s->mb_index2xy = NULL;
-    s->lambda_table = NULL;
-
-    s->cplx_tab = NULL;
-    s->bits_tab = NULL;
 }
 
 /**
@@ -820,37 +745,12 @@ av_cold int ff_mpv_common_init(MPVMainContext *s)
 
 void ff_mpv_free_context_frame(MPVMainContext *s)
 {
-    int i, j, k;
-
     free_duplicate_contexts(s);
 
-    av_freep(&s->mb_type);
-    av_freep(&s->p_mv_table_base);
-    av_freep(&s->b_forw_mv_table_base);
-    av_freep(&s->b_back_mv_table_base);
-    av_freep(&s->b_bidir_forw_mv_table_base);
-    av_freep(&s->b_bidir_back_mv_table_base);
-    av_freep(&s->b_direct_mv_table_base);
-    s->p_mv_table            = NULL;
-    s->b_forw_mv_table       = NULL;
-    s->b_back_mv_table       = NULL;
-    s->b_bidir_forw_mv_table = NULL;
-    s->b_bidir_back_mv_table = NULL;
-    s->b_direct_mv_table     = NULL;
-    av_freep(&s->b_field_mv_table_base);
-    av_freep(&s->b_field_select_table[0][0]);
     av_freep(&s->p_field_mv_table_base);
-    av_freep(&s->p_field_select_table[0]);
-    for (i = 0; i < 2; i++) {
-        for (j = 0; j < 2; j++) {
-            for (k = 0; k < 2; k++) {
-                s->b_field_mv_table[i][j][k] = NULL;
-            }
-            s->b_field_select_table[i][j] = NULL;
+    for (int i = 0; i < 2; i++)
+        for (int j = 0; j < 2; j++)
             s->p_field_mv_table[i][j] = NULL;
-        }
-        s->p_field_select_table[i] = NULL;
-    }
 
     av_freep(&s->dc_val_base);
     av_freep(&s->coded_block_base);
@@ -863,10 +763,6 @@ void ff_mpv_free_context_frame(MPVMainContext *s)
     av_freep(&s->er.error_status_table);
     av_freep(&s->er.er_temp_buffer);
     av_freep(&s->mb_index2xy);
-    av_freep(&s->lambda_table);
-
-    av_freep(&s->cplx_tab);
-    av_freep(&s->bits_tab);
 
     s->linesize = s->uvlinesize = 0;
 }
diff --git a/libavcodec/mpegvideo_enc.c b/libavcodec/mpegvideo_enc.c
index fd82681869..0204b4dacd 100644
--- a/libavcodec/mpegvideo_enc.c
+++ b/libavcodec/mpegvideo_enc.c
@@ -317,7 +317,7 @@ av_cold int ff_mpv_encode_init(AVCodecContext *avctx)
     MPVMainEncContext *const m = avctx->priv_data;
     MPVMainContext *const s = &m->common;
     AVCPBProperties *cpb_props;
-    int i, ret;
+    int i, ret, mv_table_size, mb_array_size;
 
     mpv_encode_defaults(m);
 
@@ -818,6 +818,56 @@ av_cold int ff_mpv_encode_init(AVCodecContext *avctx)
     ff_pixblockdsp_init(&s->pdsp, avctx);
     ff_qpeldsp_init(&s->qdsp);
 
+    /* Allocate MV tables; the MV and MB tables will be copied
+     * to slice contexts by ff_update_duplicate_context().  */
+    mv_table_size = (s->mb_height + 2) * s->mb_stride + 1;
+    if (!FF_ALLOCZ_TYPED_ARRAY(s->p_mv_table_base,            mv_table_size) ||
+        !FF_ALLOCZ_TYPED_ARRAY(s->b_forw_mv_table_base,       mv_table_size) ||
+        !FF_ALLOCZ_TYPED_ARRAY(s->b_back_mv_table_base,       mv_table_size) ||
+        !FF_ALLOCZ_TYPED_ARRAY(s->b_bidir_forw_mv_table_base, mv_table_size) ||
+        !FF_ALLOCZ_TYPED_ARRAY(s->b_bidir_back_mv_table_base, mv_table_size) ||
+        !FF_ALLOCZ_TYPED_ARRAY(s->b_direct_mv_table_base,     mv_table_size))
+        return AVERROR(ENOMEM);
+    s->p_mv_table            = s->p_mv_table_base + s->mb_stride + 1;
+    s->b_forw_mv_table       = s->b_forw_mv_table_base + s->mb_stride + 1;
+    s->b_back_mv_table       = s->b_back_mv_table_base + s->mb_stride + 1;
+    s->b_bidir_forw_mv_table = s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
+    s->b_bidir_back_mv_table = s->b_bidir_back_mv_table_base + s->mb_stride + 1;
+    s->b_direct_mv_table     = s->b_direct_mv_table_base + s->mb_stride + 1;
+
+    /* Allocate MB type table */
+    mb_array_size = s->mb_height * s->mb_stride;
+    if (!FF_ALLOCZ_TYPED_ARRAY(s->mb_type,      mb_array_size) ||
+        !FF_ALLOCZ_TYPED_ARRAY(s->lambda_table, mb_array_size) ||
+        !FF_ALLOC_TYPED_ARRAY (s->cplx_tab,     mb_array_size) ||
+        !FF_ALLOC_TYPED_ARRAY (s->bits_tab,     mb_array_size))
+        return AVERROR(ENOMEM);
+
+#define ALLOCZ_ARRAYS(p, mult, numb) ((p) = av_calloc(numb, mult * sizeof(*(p))))
+    if (s->codec_id == AV_CODEC_ID_MPEG4 ||
+        (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_ME)) {
+        int16_t (*tmp1)[2];
+        uint8_t *tmp2;
+        if (!(tmp1 = ALLOCZ_ARRAYS(s->b_field_mv_table_base, 8, mv_table_size)) ||
+            !(tmp2 = ALLOCZ_ARRAYS(s->b_field_select_table[0][0], 2 * 4, mv_table_size)) ||
+            !ALLOCZ_ARRAYS(s->p_field_select_table[0], 2 * 2, mv_table_size))
+            return AVERROR(ENOMEM);
+
+        s->p_field_select_table[1] = s->p_field_select_table[0] + 2 * mv_table_size;
+        tmp1 += s->mb_stride + 1;
+
+        for (int i = 0; i < 2; i++) {
+            for (int j = 0; j < 2; j++) {
+                for (int k = 0; k < 2; k++) {
+                    s->b_field_mv_table[i][j][k] = tmp1;
+                    tmp1 += mv_table_size;
+                }
+                s->b_field_select_table[i][j] = tmp2;
+                tmp2 += 2 * mv_table_size;
+            }
+        }
+    }
+
     if (!(avctx->stats_out = av_mallocz(256))               ||
         !FF_ALLOCZ_TYPED_ARRAY(s->q_intra_matrix,          32) ||
         !FF_ALLOCZ_TYPED_ARRAY(s->q_chroma_intra_matrix,   32) ||
@@ -943,6 +993,22 @@ av_cold int ff_mpv_encode_end(AVCodecContext *avctx)
 
     av_freep(&avctx->stats_out);
 
+    av_freep(&s->p_mv_table_base);
+    av_freep(&s->b_forw_mv_table_base);
+    av_freep(&s->b_back_mv_table_base);
+    av_freep(&s->b_bidir_forw_mv_table_base);
+    av_freep(&s->b_bidir_back_mv_table_base);
+    av_freep(&s->b_direct_mv_table_base);
+    av_freep(&s->b_field_mv_table_base);
+    av_freep(&s->b_field_select_table[0][0]);
+    av_freep(&s->p_field_select_table[0]);
+
+    av_freep(&s->mb_type);
+    av_freep(&s->lambda_table);
+
+    av_freep(&s->cplx_tab);
+    av_freep(&s->bits_tab);
+
     if(s->q_chroma_intra_matrix   != s->q_intra_matrix  ) av_freep(&s->q_chroma_intra_matrix);
     if(s->q_chroma_intra_matrix16 != s->q_intra_matrix16) av_freep(&s->q_chroma_intra_matrix16);
     s->q_chroma_intra_matrix=   NULL;
-- 
2.32.0

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

[FFmpeg-devel] [PATCH 36/41] avcodec/mpegvideo: Move encoder-only base-arrays to MPVMainEncContext

[Andreas Rheinhardt]

Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
---
 libavcodec/mpegvideo.h     | 10 --------
 libavcodec/mpegvideo_enc.c | 48 +++++++++++++++++++-------------------
 libavcodec/mpegvideoenc.h  | 11 +++++++++
 libavcodec/ratecontrol.c   |  4 ++--
 4 files changed, 37 insertions(+), 36 deletions(-)

diff --git a/libavcodec/mpegvideo.h b/libavcodec/mpegvideo.h
index ed62175db5..201ca81621 100644
--- a/libavcodec/mpegvideo.h
+++ b/libavcodec/mpegvideo.h
@@ -203,14 +203,7 @@ typedef struct MPVContext {
     H263DSPContext h263dsp;
     int f_code;                 ///< forward MV resolution
     int b_code;                 ///< backward MV resolution for B-frames (MPEG-4)
-    int16_t (*p_mv_table_base)[2];
-    int16_t (*b_forw_mv_table_base)[2];
-    int16_t (*b_back_mv_table_base)[2];
-    int16_t (*b_bidir_forw_mv_table_base)[2];
-    int16_t (*b_bidir_back_mv_table_base)[2];
-    int16_t (*b_direct_mv_table_base)[2];
     int16_t (*p_field_mv_table_base)[2];
-    int16_t (*b_field_mv_table_base)[2];
     int16_t (*p_mv_table)[2];            ///< MV table (1MV per MB) P-frame encoding
     int16_t (*b_forw_mv_table)[2];       ///< MV table (1MV per MB) forward mode B-frame encoding
     int16_t (*b_back_mv_table)[2];       ///< MV table (1MV per MB) backward mode B-frame encoding
@@ -475,9 +468,6 @@ typedef struct MPVContext {
 
     int vbv_ignore_qmax;
 
-    /* temp buffers for rate control */
-    float *cplx_tab, *bits_tab;
-
     /* flag to indicate a reinitialization is required, e.g. after
      * a frame size change */
     int context_reinit;
diff --git a/libavcodec/mpegvideo_enc.c b/libavcodec/mpegvideo_enc.c
index 0204b4dacd..892115b68f 100644
--- a/libavcodec/mpegvideo_enc.c
+++ b/libavcodec/mpegvideo_enc.c
@@ -821,26 +821,26 @@ av_cold int ff_mpv_encode_init(AVCodecContext *avctx)
     /* Allocate MV tables; the MV and MB tables will be copied
      * to slice contexts by ff_update_duplicate_context().  */
     mv_table_size = (s->mb_height + 2) * s->mb_stride + 1;
-    if (!FF_ALLOCZ_TYPED_ARRAY(s->p_mv_table_base,            mv_table_size) ||
-        !FF_ALLOCZ_TYPED_ARRAY(s->b_forw_mv_table_base,       mv_table_size) ||
-        !FF_ALLOCZ_TYPED_ARRAY(s->b_back_mv_table_base,       mv_table_size) ||
-        !FF_ALLOCZ_TYPED_ARRAY(s->b_bidir_forw_mv_table_base, mv_table_size) ||
-        !FF_ALLOCZ_TYPED_ARRAY(s->b_bidir_back_mv_table_base, mv_table_size) ||
-        !FF_ALLOCZ_TYPED_ARRAY(s->b_direct_mv_table_base,     mv_table_size))
+    if (!FF_ALLOCZ_TYPED_ARRAY(m->p_mv_table_base,            mv_table_size) ||
+        !FF_ALLOCZ_TYPED_ARRAY(m->b_forw_mv_table_base,       mv_table_size) ||
+        !FF_ALLOCZ_TYPED_ARRAY(m->b_back_mv_table_base,       mv_table_size) ||
+        !FF_ALLOCZ_TYPED_ARRAY(m->b_bidir_forw_mv_table_base, mv_table_size) ||
+        !FF_ALLOCZ_TYPED_ARRAY(m->b_bidir_back_mv_table_base, mv_table_size) ||
+        !FF_ALLOCZ_TYPED_ARRAY(m->b_direct_mv_table_base,     mv_table_size))
         return AVERROR(ENOMEM);
-    s->p_mv_table            = s->p_mv_table_base + s->mb_stride + 1;
-    s->b_forw_mv_table       = s->b_forw_mv_table_base + s->mb_stride + 1;
-    s->b_back_mv_table       = s->b_back_mv_table_base + s->mb_stride + 1;
-    s->b_bidir_forw_mv_table = s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
-    s->b_bidir_back_mv_table = s->b_bidir_back_mv_table_base + s->mb_stride + 1;
-    s->b_direct_mv_table     = s->b_direct_mv_table_base + s->mb_stride + 1;
+    s->p_mv_table            = m->p_mv_table_base + s->mb_stride + 1;
+    s->b_forw_mv_table       = m->b_forw_mv_table_base + s->mb_stride + 1;
+    s->b_back_mv_table       = m->b_back_mv_table_base + s->mb_stride + 1;
+    s->b_bidir_forw_mv_table = m->b_bidir_forw_mv_table_base + s->mb_stride + 1;
+    s->b_bidir_back_mv_table = m->b_bidir_back_mv_table_base + s->mb_stride + 1;
+    s->b_direct_mv_table     = m->b_direct_mv_table_base + s->mb_stride + 1;
 
     /* Allocate MB type table */
     mb_array_size = s->mb_height * s->mb_stride;
     if (!FF_ALLOCZ_TYPED_ARRAY(s->mb_type,      mb_array_size) ||
         !FF_ALLOCZ_TYPED_ARRAY(s->lambda_table, mb_array_size) ||
-        !FF_ALLOC_TYPED_ARRAY (s->cplx_tab,     mb_array_size) ||
-        !FF_ALLOC_TYPED_ARRAY (s->bits_tab,     mb_array_size))
+        !FF_ALLOC_TYPED_ARRAY (m->cplx_tab,     mb_array_size) ||
+        !FF_ALLOC_TYPED_ARRAY (m->bits_tab,     mb_array_size))
         return AVERROR(ENOMEM);
 
 #define ALLOCZ_ARRAYS(p, mult, numb) ((p) = av_calloc(numb, mult * sizeof(*(p))))
@@ -848,7 +848,7 @@ av_cold int ff_mpv_encode_init(AVCodecContext *avctx)
         (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_ME)) {
         int16_t (*tmp1)[2];
         uint8_t *tmp2;
-        if (!(tmp1 = ALLOCZ_ARRAYS(s->b_field_mv_table_base, 8, mv_table_size)) ||
+        if (!(tmp1 = ALLOCZ_ARRAYS(m->b_field_mv_table_base, 8, mv_table_size)) ||
             !(tmp2 = ALLOCZ_ARRAYS(s->b_field_select_table[0][0], 2 * 4, mv_table_size)) ||
             !ALLOCZ_ARRAYS(s->p_field_select_table[0], 2 * 2, mv_table_size))
             return AVERROR(ENOMEM);
@@ -993,21 +993,21 @@ av_cold int ff_mpv_encode_end(AVCodecContext *avctx)
 
     av_freep(&avctx->stats_out);
 
-    av_freep(&s->p_mv_table_base);
-    av_freep(&s->b_forw_mv_table_base);
-    av_freep(&s->b_back_mv_table_base);
-    av_freep(&s->b_bidir_forw_mv_table_base);
-    av_freep(&s->b_bidir_back_mv_table_base);
-    av_freep(&s->b_direct_mv_table_base);
-    av_freep(&s->b_field_mv_table_base);
+    av_freep(&m->p_mv_table_base);
+    av_freep(&m->b_forw_mv_table_base);
+    av_freep(&m->b_back_mv_table_base);
+    av_freep(&m->b_bidir_forw_mv_table_base);
+    av_freep(&m->b_bidir_back_mv_table_base);
+    av_freep(&m->b_direct_mv_table_base);
+    av_freep(&m->b_field_mv_table_base);
     av_freep(&s->b_field_select_table[0][0]);
     av_freep(&s->p_field_select_table[0]);
 
     av_freep(&s->mb_type);
     av_freep(&s->lambda_table);
 
-    av_freep(&s->cplx_tab);
-    av_freep(&s->bits_tab);
+    av_freep(&m->cplx_tab);
+    av_freep(&m->bits_tab);
 
     if(s->q_chroma_intra_matrix   != s->q_intra_matrix  ) av_freep(&s->q_chroma_intra_matrix);
     if(s->q_chroma_intra_matrix16 != s->q_intra_matrix16) av_freep(&s->q_chroma_intra_matrix16);
diff --git a/libavcodec/mpegvideoenc.h b/libavcodec/mpegvideoenc.h
index ada5935410..23381a31ca 100644
--- a/libavcodec/mpegvideoenc.h
+++ b/libavcodec/mpegvideoenc.h
@@ -82,11 +82,22 @@ typedef struct MPVMainEncContext {
 
     char *rc_eq;
 
+    /* temp buffers for rate control */
+    float *cplx_tab, *bits_tab;
+
     /* temporary frames used by b_frame_strategy == 2 */
     AVFrame *tmp_frames[MAX_B_FRAMES + 2];
     int b_frame_strategy;
     int b_sensitivity;
     int brd_scale;
+
+    int16_t (*p_mv_table_base)[2];
+    int16_t (*b_forw_mv_table_base)[2];
+    int16_t (*b_back_mv_table_base)[2];
+    int16_t (*b_bidir_forw_mv_table_base)[2];
+    int16_t (*b_bidir_back_mv_table_base)[2];
+    int16_t (*b_direct_mv_table_base)[2];
+    int16_t (*b_field_mv_table_base)[2];
 } MPVMainEncContext;
 
 /* mpegvideo_enc common options */
diff --git a/libavcodec/ratecontrol.c b/libavcodec/ratecontrol.c
index fa28e6d61d..bbaa9191a0 100644
--- a/libavcodec/ratecontrol.c
+++ b/libavcodec/ratecontrol.c
@@ -758,8 +758,8 @@ static void adaptive_quantization(MPVMainEncContext *m, double q)
     const float border_masking       = m->border_masking;
     float bits_sum                   = 0.0;
     float cplx_sum                   = 0.0;
-    float *cplx_tab                  = s->cplx_tab;
-    float *bits_tab                  = s->bits_tab;
+    float *cplx_tab                  = m->cplx_tab;
+    float *bits_tab                  = m->bits_tab;
     const int qmin                   = s->avctx->mb_lmin;
     const int qmax                   = s->avctx->mb_lmax;
     Picture *const pic               = &s->current_picture;
-- 
2.32.0

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

[FFmpeg-devel] [PATCH 37/41] avcodec/mpegvideo_enc: Initialize non-JPEG q-matrices only once

[Andreas Rheinhardt]

Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
---
 libavcodec/mpegvideo_enc.c | 11 ++++-------
 1 file changed, 4 insertions(+), 7 deletions(-)

diff --git a/libavcodec/mpegvideo_enc.c b/libavcodec/mpegvideo_enc.c
index 892115b68f..7b55e9c17d 100644
--- a/libavcodec/mpegvideo_enc.c
+++ b/libavcodec/mpegvideo_enc.c
@@ -945,6 +945,10 @@ av_cold int ff_mpv_encode_init(AVCodecContext *avctx)
         ff_convert_matrix(s, s->q_inter_matrix, s->q_inter_matrix16,
                           s->inter_matrix, s->inter_quant_bias, avctx->qmin,
                           31, 0);
+        av_freep(&s->q_chroma_intra_matrix);
+        av_freep(&s->q_chroma_intra_matrix16);
+        s->q_chroma_intra_matrix   = s->q_intra_matrix;
+        s->q_chroma_intra_matrix16 = s->q_intra_matrix16;
     }
 
     if ((ret = ff_rate_control_init(m)) < 0)
@@ -3597,13 +3601,6 @@ static int encode_picture(MPVMainEncContext *m, int picture_number)
         update_qscale(s);
     }
 
-    if (s->out_format != FMT_MJPEG) {
-        if(s->q_chroma_intra_matrix   != s->q_intra_matrix  ) av_freep(&s->q_chroma_intra_matrix);
-        if(s->q_chroma_intra_matrix16 != s->q_intra_matrix16) av_freep(&s->q_chroma_intra_matrix16);
-        s->q_chroma_intra_matrix   = s->q_intra_matrix;
-        s->q_chroma_intra_matrix16 = s->q_intra_matrix16;
-    }
-
     s->mb_intra=0; //for the rate distortion & bit compare functions
     for(i=1; i<context_count; i++){
         ret = ff_update_duplicate_context(s->thread_context[i], s);
-- 
2.32.0

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

[FFmpeg-devel] [PATCH 38/41] avcodec/mpegvideo_enc: Avoid allocations for q_int(er|ra)_matrix tables

[Andreas Rheinhardt]

Do this by making them part of an MPVMainEncContext; the MPVEncContexts
still retain their pointers to access them.
(These tables are quite big, so that putting them in the MpegEncContext
would have been very wasteful for all the decoders using said structure.
But this is no longer a problem: MPVMainEncContext is only used by
encoders and allows to directly share the tables when slice-threading
is in use.)

Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
---
 libavcodec/mpegvideo_enc.c | 24 ++++++++----------------
 libavcodec/mpegvideoenc.h  |  7 +++++++
 2 files changed, 15 insertions(+), 16 deletions(-)

diff --git a/libavcodec/mpegvideo_enc.c b/libavcodec/mpegvideo_enc.c
index 7b55e9c17d..01ed41a2e7 100644
--- a/libavcodec/mpegvideo_enc.c
+++ b/libavcodec/mpegvideo_enc.c
@@ -869,12 +869,6 @@ av_cold int ff_mpv_encode_init(AVCodecContext *avctx)
     }
 
     if (!(avctx->stats_out = av_mallocz(256))               ||
-        !FF_ALLOCZ_TYPED_ARRAY(s->q_intra_matrix,          32) ||
-        !FF_ALLOCZ_TYPED_ARRAY(s->q_chroma_intra_matrix,   32) ||
-        !FF_ALLOCZ_TYPED_ARRAY(s->q_inter_matrix,          32) ||
-        !FF_ALLOCZ_TYPED_ARRAY(s->q_intra_matrix16,        32) ||
-        !FF_ALLOCZ_TYPED_ARRAY(s->q_chroma_intra_matrix16, 32) ||
-        !FF_ALLOCZ_TYPED_ARRAY(s->q_inter_matrix16,        32) ||
         !FF_ALLOCZ_TYPED_ARRAY(s->reordered_input_picture, MAX_PICTURE_COUNT))
         return AVERROR(ENOMEM);
 
@@ -936,6 +930,11 @@ av_cold int ff_mpv_encode_init(AVCodecContext *avctx)
             s->inter_matrix[j] = avctx->inter_matrix[i];
     }
 
+    s->q_inter_matrix   = m->q_inter_matrix;
+    s->q_intra_matrix   = m->q_intra_matrix;
+    s->q_inter_matrix16 = m->q_inter_matrix16;
+    s->q_intra_matrix16 = m->q_intra_matrix16;
+
     /* precompute matrix */
     /* for mjpeg, we do include qscale in the matrix */
     if (s->out_format != FMT_MJPEG) {
@@ -945,10 +944,11 @@ av_cold int ff_mpv_encode_init(AVCodecContext *avctx)
         ff_convert_matrix(s, s->q_inter_matrix, s->q_inter_matrix16,
                           s->inter_matrix, s->inter_quant_bias, avctx->qmin,
                           31, 0);
-        av_freep(&s->q_chroma_intra_matrix);
-        av_freep(&s->q_chroma_intra_matrix16);
         s->q_chroma_intra_matrix   = s->q_intra_matrix;
         s->q_chroma_intra_matrix16 = s->q_intra_matrix16;
+    } else {
+        s->q_chroma_intra_matrix   = m->q_chroma_intra_matrix;
+        s->q_chroma_intra_matrix16 = m->q_chroma_intra_matrix16;
     }
 
     if ((ret = ff_rate_control_init(m)) < 0)
@@ -1013,14 +1013,6 @@ av_cold int ff_mpv_encode_end(AVCodecContext *avctx)
     av_freep(&m->cplx_tab);
     av_freep(&m->bits_tab);
 
-    if(s->q_chroma_intra_matrix   != s->q_intra_matrix  ) av_freep(&s->q_chroma_intra_matrix);
-    if(s->q_chroma_intra_matrix16 != s->q_intra_matrix16) av_freep(&s->q_chroma_intra_matrix16);
-    s->q_chroma_intra_matrix=   NULL;
-    s->q_chroma_intra_matrix16= NULL;
-    av_freep(&s->q_intra_matrix);
-    av_freep(&s->q_inter_matrix);
-    av_freep(&s->q_intra_matrix16);
-    av_freep(&s->q_inter_matrix16);
     av_freep(&s->reordered_input_picture);
     av_freep(&s->dct_offset);
 
diff --git a/libavcodec/mpegvideoenc.h b/libavcodec/mpegvideoenc.h
index 23381a31ca..bc69c6ea53 100644
--- a/libavcodec/mpegvideoenc.h
+++ b/libavcodec/mpegvideoenc.h
@@ -98,6 +98,13 @@ typedef struct MPVMainEncContext {
     int16_t (*b_bidir_back_mv_table_base)[2];
     int16_t (*b_direct_mv_table_base)[2];
     int16_t (*b_field_mv_table_base)[2];
+
+    int q_inter_matrix[32][64];
+    int q_intra_matrix[32][64];
+    int q_chroma_intra_matrix[32][64];
+    uint16_t q_inter_matrix16[32][2][64];
+    uint16_t q_intra_matrix16[32][2][64];
+    uint16_t q_chroma_intra_matrix16[32][2][64];
 } MPVMainEncContext;
 
 /* mpegvideo_enc common options */
-- 
2.32.0

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

[FFmpeg-devel] [PATCH 39/41] avcodec/mpegvideo: Move scenechange_threshold to MPVMainEncContext

[Andreas Rheinhardt]

Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
---
 libavcodec/mpegvideo.h     | 1 -
 libavcodec/mpegvideo_enc.c | 4 ++--
 libavcodec/mpegvideoenc.h  | 4 +++-
 3 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/libavcodec/mpegvideo.h b/libavcodec/mpegvideo.h
index 201ca81621..5c7654230a 100644
--- a/libavcodec/mpegvideo.h
+++ b/libavcodec/mpegvideo.h
@@ -482,7 +482,6 @@ typedef struct MPVContext {
     int frame_skip_exp;
     int frame_skip_cmp;
 
-    int scenechange_threshold;
     int noise_reduction;
 
     int intra_penalty;
diff --git a/libavcodec/mpegvideo_enc.c b/libavcodec/mpegvideo_enc.c
index 01ed41a2e7..1a88e4fb93 100644
--- a/libavcodec/mpegvideo_enc.c
+++ b/libavcodec/mpegvideo_enc.c
@@ -572,7 +572,7 @@ av_cold int ff_mpv_encode_init(AVCodecContext *avctx)
         return AVERROR(EINVAL);
     }
 
-    if (s->scenechange_threshold < 1000000000 &&
+    if (m->scenechange_threshold < 1000000000 &&
         (avctx->flags & AV_CODEC_FLAG_CLOSED_GOP)) {
         av_log(avctx, AV_LOG_ERROR,
                "closed gop with scene change detection are not supported yet, "
@@ -3632,7 +3632,7 @@ static int encode_picture(MPVMainEncContext *m, int picture_number)
     s->current_picture.   mb_var_sum= s->current_picture_ptr->   mb_var_sum= s->me.   mb_var_sum_temp;
     emms_c();
 
-    if (s->me.scene_change_score > s->scenechange_threshold &&
+    if (s->me.scene_change_score > m->scenechange_threshold &&
         s->pict_type == AV_PICTURE_TYPE_P) {
         s->pict_type= AV_PICTURE_TYPE_I;
         for(i=0; i<s->mb_stride*s->mb_height; i++)
diff --git a/libavcodec/mpegvideoenc.h b/libavcodec/mpegvideoenc.h
index bc69c6ea53..662236c102 100644
--- a/libavcodec/mpegvideoenc.h
+++ b/libavcodec/mpegvideoenc.h
@@ -42,6 +42,8 @@ typedef struct MPVMainEncContext {
     int me_penalty_compensation;
     int me_pre;                          ///< prepass for motion estimation
 
+    int scenechange_threshold;
+
     int gop_size;
     int picture_in_gop_number;     ///< 0-> first pic in gop, ...
 
@@ -177,7 +179,7 @@ FF_MPV_OPT_CMP_FUNC, \
 {"skip_factor", "Frame skip factor",                                FF_MPV_OFFSET(frame_skip_factor), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS }, \
 {"skip_exp", "Frame skip exponent",                                 FF_MPV_OFFSET(frame_skip_exp), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS }, \
 {"skip_cmp", "Frame skip compare function",                         FF_MPV_OFFSET(frame_skip_cmp), AV_OPT_TYPE_INT, {.i64 = FF_CMP_DCTMAX }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS, "cmp_func" }, \
-{"sc_threshold", "Scene change threshold",                          FF_MPV_OFFSET(scenechange_threshold), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS }, \
+{"sc_threshold", "Scene change threshold",                          FF_MPV_MAIN_OFFSET(scenechange_threshold), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS }, \
 {"noise_reduction", "Noise reduction",                              FF_MPV_OFFSET(noise_reduction), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS }, \
 {"ps", "RTP payload size in bytes",                             FF_MPV_OFFSET(rtp_payload_size), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS }, \
 {"mepc", "Motion estimation bitrate penalty compensation (1.0 = 256)", FF_MPV_MAIN_OFFSET(me_penalty_compensation), AV_OPT_TYPE_INT, {.i64 = 256 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS }, \
-- 
2.32.0

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

[FFmpeg-devel] [PATCH 40/41] avcodec/mpegvideo: Move dummy dst for depr. opts to MPVMainEncContext

[Andreas Rheinhardt]

Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
---
 libavcodec/mjpegenc.c     | 2 +-
 libavcodec/mpegvideo.h    | 4 ----
 libavcodec/mpegvideoenc.h | 8 ++++++--
 3 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/libavcodec/mjpegenc.c b/libavcodec/mjpegenc.c
index a8efe72231..064562e6c5 100644
--- a/libavcodec/mjpegenc.c
+++ b/libavcodec/mjpegenc.c
@@ -631,7 +631,7 @@ static int amv_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
 static const AVOption options[] = {
 FF_MPV_COMMON_OPTS
 #if FF_API_MJPEG_PRED
-{ "pred", "Deprecated, does nothing", FF_MPV_OFFSET(dummy), AV_OPT_TYPE_INT, { .i64 = 1 }, 1, 3, VE, "pred" },
+{ "pred", "Deprecated, does nothing", FF_MPV_MAIN_OFFSET(dummy), AV_OPT_TYPE_INT, { .i64 = 1 }, 1, 3, VE, "pred" },
     { "left",   NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, INT_MIN, INT_MAX, VE, "pred" },
     { "plane",  NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 2 }, INT_MIN, INT_MAX, VE, "pred" },
     { "median", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 3 }, INT_MIN, INT_MAX, VE, "pred" },
diff --git a/libavcodec/mpegvideo.h b/libavcodec/mpegvideo.h
index 5c7654230a..bf71d6242b 100644
--- a/libavcodec/mpegvideo.h
+++ b/libavcodec/mpegvideo.h
@@ -485,10 +485,6 @@ typedef struct MPVContext {
     int noise_reduction;
 
     int intra_penalty;
-
-#if FF_API_MPEGVIDEO_OPTS || FF_API_MJPEG_PRED
-    int dummy;               ///< used as target for deprecated options
-#endif
 } MPVContext;
 
 typedef MPVContext MPVDecContext;
diff --git a/libavcodec/mpegvideoenc.h b/libavcodec/mpegvideoenc.h
index 662236c102..ad55448363 100644
--- a/libavcodec/mpegvideoenc.h
+++ b/libavcodec/mpegvideoenc.h
@@ -107,6 +107,10 @@ typedef struct MPVMainEncContext {
     uint16_t q_inter_matrix16[32][2][64];
     uint16_t q_intra_matrix16[32][2][64];
     uint16_t q_chroma_intra_matrix16[32][2][64];
+
+#if FF_API_MPEGVIDEO_OPTS || FF_API_MJPEG_PRED
+    int dummy;               ///< used as target for deprecated options
+#endif
 } MPVMainEncContext;
 
 /* mpegvideo_enc common options */
@@ -195,9 +199,9 @@ FF_MPV_OPT_CMP_FUNC, \
 #define FF_MPV_DEPRECATED_MPEG_QUANT_OPT \
     { "mpeg_quant", "Deprecated, does nothing", FF_MPV_OFFSET(mpeg_quant), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, 0, FF_MPV_OPT_FLAGS | AV_OPT_FLAG_DEPRECATED },
 #define FF_MPV_DEPRECATED_A53_CC_OPT \
-    { "a53cc",      "Deprecated, does nothing", FF_MPV_OFFSET(dummy),      AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, FF_MPV_OPT_FLAGS | AV_OPT_FLAG_DEPRECATED },
+    { "a53cc",      "Deprecated, does nothing", FF_MPV_MAIN_OFFSET(dummy),      AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, FF_MPV_OPT_FLAGS | AV_OPT_FLAG_DEPRECATED },
 #define FF_MPV_DEPRECATED_MATRIX_OPT \
-   { "force_duplicated_matrix", "Deprecated, does nothing", FF_MPV_OFFSET(dummy), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, FF_MPV_OPT_FLAGS | AV_OPT_FLAG_DEPRECATED },
+   { "force_duplicated_matrix", "Deprecated, does nothing", FF_MPV_MAIN_OFFSET(dummy), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, FF_MPV_OPT_FLAGS | AV_OPT_FLAG_DEPRECATED },
 #define FF_MPV_DEPRECATED_BFRAME_OPTS \
    { "b_strategy",    "Deprecated, does nothing", FF_MPV_MAIN_OFFSET(b_frame_strategy), AV_OPT_TYPE_INT, { .i64 =  0 }, 0, 2, FF_MPV_OPT_FLAGS | AV_OPT_FLAG_DEPRECATED }, \
    { "b_sensitivity", "Deprecated, does nothing", FF_MPV_MAIN_OFFSET(b_sensitivity),    AV_OPT_TYPE_INT, { .i64 = 40 }, 1, INT_MAX, FF_MPV_OPT_FLAGS | AV_OPT_FLAG_DEPRECATED }, \
-- 
2.32.0

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

[FFmpeg-devel] [PATCH 41/41] avcodec/mpegvideo: Move frame_skip_(exp|cmp) to MPVMainEncContext

[Andreas Rheinhardt]

Only used by the main encoding thread.

Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
---
frame_skip_factor/threshold are used by slice threads;
they (and several other fields) could be moved by adding
a pointer to the const MPVMainContext. I intend to do this
in the future.

 libavcodec/mpegvideo.h     | 2 --
 libavcodec/mpegvideo_enc.c | 8 ++++----
 libavcodec/mpegvideoenc.h  | 7 +++++--
 3 files changed, 9 insertions(+), 8 deletions(-)

diff --git a/libavcodec/mpegvideo.h b/libavcodec/mpegvideo.h
index bf71d6242b..fc271991fd 100644
--- a/libavcodec/mpegvideo.h
+++ b/libavcodec/mpegvideo.h
@@ -479,8 +479,6 @@ typedef struct MPVContext {
     /* frame skip options for encoding */
     int frame_skip_threshold;
     int frame_skip_factor;
-    int frame_skip_exp;
-    int frame_skip_cmp;
 
     int noise_reduction;
 
diff --git a/libavcodec/mpegvideo_enc.c b/libavcodec/mpegvideo_enc.c
index 1a88e4fb93..8c369a94ec 100644
--- a/libavcodec/mpegvideo_enc.c
+++ b/libavcodec/mpegvideo_enc.c
@@ -892,7 +892,7 @@ av_cold int ff_mpv_encode_init(AVCodecContext *avctx)
     s->quant_precision = 5;
 
     ff_set_cmp(&s->mecc, s->mecc.ildct_cmp,      avctx->ildct_cmp);
-    ff_set_cmp(&s->mecc, s->mecc.frame_skip_cmp, s->frame_skip_cmp);
+    ff_set_cmp(&s->mecc, s->mecc.frame_skip_cmp, m->frame_skip_cmp);
 
     if (CONFIG_H261_ENCODER && s->out_format == FMT_H261) {
         ff_h261_encode_init(m);
@@ -1234,7 +1234,7 @@ static int skip_check(MPVMainEncContext *m, Picture *p, Picture *ref)
                 uint8_t *rptr = ref->f->data[plane] + 8 * (x + y * stride);
                 int v = s->mecc.frame_skip_cmp[1](s, dptr, rptr, stride, 8);
 
-                switch (FFABS(s->frame_skip_exp)) {
+                switch (FFABS(m->frame_skip_exp)) {
                 case 0: score    =  FFMAX(score, v);          break;
                 case 1: score   += FFABS(v);                  break;
                 case 2: score64 += v * (int64_t)v;                       break;
@@ -1248,9 +1248,9 @@ static int skip_check(MPVMainEncContext *m, Picture *p, Picture *ref)
 
     if (score)
         score64 = score;
-    if (s->frame_skip_exp < 0)
+    if (m->frame_skip_exp < 0)
         score64 = pow(score64 / (double)(s->mb_width * s->mb_height),
-                      -1.0/s->frame_skip_exp);
+                      -1.0/m->frame_skip_exp);
 
     if (score64 < s->frame_skip_threshold)
         return 1;
diff --git a/libavcodec/mpegvideoenc.h b/libavcodec/mpegvideoenc.h
index ad55448363..f18463c2bb 100644
--- a/libavcodec/mpegvideoenc.h
+++ b/libavcodec/mpegvideoenc.h
@@ -87,6 +87,9 @@ typedef struct MPVMainEncContext {
     /* temp buffers for rate control */
     float *cplx_tab, *bits_tab;
 
+    int frame_skip_exp;
+    int frame_skip_cmp;
+
     /* temporary frames used by b_frame_strategy == 2 */
     AVFrame *tmp_frames[MAX_B_FRAMES + 2];
     int b_frame_strategy;
@@ -181,8 +184,8 @@ FF_MPV_OPT_CMP_FUNC, \
 { "xone", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FF_ME_XONE }, 0, 0, FF_MPV_OPT_FLAGS, "motion_est" }, \
 {"skip_threshold", "Frame skip threshold",                          FF_MPV_OFFSET(frame_skip_threshold), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS }, \
 {"skip_factor", "Frame skip factor",                                FF_MPV_OFFSET(frame_skip_factor), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS }, \
-{"skip_exp", "Frame skip exponent",                                 FF_MPV_OFFSET(frame_skip_exp), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS }, \
-{"skip_cmp", "Frame skip compare function",                         FF_MPV_OFFSET(frame_skip_cmp), AV_OPT_TYPE_INT, {.i64 = FF_CMP_DCTMAX }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS, "cmp_func" }, \
+{"skip_exp", "Frame skip exponent",                                 FF_MPV_MAIN_OFFSET(frame_skip_exp), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS }, \
+{"skip_cmp", "Frame skip compare function",                         FF_MPV_MAIN_OFFSET(frame_skip_cmp), AV_OPT_TYPE_INT, {.i64 = FF_CMP_DCTMAX }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS, "cmp_func" }, \
 {"sc_threshold", "Scene change threshold",                          FF_MPV_MAIN_OFFSET(scenechange_threshold), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS }, \
 {"noise_reduction", "Noise reduction",                              FF_MPV_OFFSET(noise_reduction), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS }, \
 {"ps", "RTP payload size in bytes",                             FF_MPV_OFFSET(rtp_payload_size), AV_OPT_TYPE_INT, {.i64 = 0 }, INT_MIN, INT_MAX, FF_MPV_OPT_FLAGS }, \
-- 
2.32.0

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".