cavs: deMpegEncContextize

It does not use any of the mpegvideo infrastructure, just a few fields
from the context.

Fixes a segfault with the emu edge flag, since emu edge buffer is now
allocated as a part of the frame buffer allocation and cavs calls
ff_get_buffer() directly, it does not use mpegvideo buffer management.

Fixes a memleak of the last frame.

3 files changed, 189 insertions, 156 deletions

diff --git a/libavcodec/cavs.c b/libavcodec/cavs.c
index 8042f8236e..c110882377 100644
--- a/libavcodec/cavs.c
+++ b/libavcodec/cavs.c
@@ -375,20 +375,19 @@ void ff_cavs_modify_mb_i(AVSContext *h, int *pred_mode_uv)
  *
  ****************************************************************************/
 
-static inline void mc_dir_part(AVSContext *h,Picture *pic,
+static inline void mc_dir_part(AVSContext *h, AVFrame *pic,
                                int chroma_height,int delta,int list,uint8_t *dest_y,
                                uint8_t *dest_cb,uint8_t *dest_cr,int src_x_offset,
                                int src_y_offset,qpel_mc_func *qpix_op,
                                h264_chroma_mc_func chroma_op,cavs_vector *mv)
 {
-    MpegEncContext * const s = &h->s;
     const int mx= mv->x + src_x_offset*8;
     const int my= mv->y + src_y_offset*8;
     const int luma_xy= (mx&3) + ((my&3)<<2);
-    uint8_t * src_y  = pic->f.data[0] + (mx >> 2) + (my >> 2) * h->l_stride;
-    uint8_t * src_cb = pic->f.data[1] + (mx >> 3) + (my >> 3) * h->c_stride;
-    uint8_t * src_cr = pic->f.data[2] + (mx >> 3) + (my >> 3) * h->c_stride;
-    int extra_width= 0; //(s->flags&CODEC_FLAG_EMU_EDGE) ? 0 : 16;
+    uint8_t * src_y  = pic->data[0] + (mx >> 2) + (my >> 2) * h->l_stride;
+    uint8_t * src_cb = pic->data[1] + (mx >> 3) + (my >> 3) * h->c_stride;
+    uint8_t * src_cr = pic->data[2] + (mx >> 3) + (my >> 3) * h->c_stride;
+    int extra_width = 0;
     int extra_height= extra_width;
     int emu=0;
     const int full_mx= mx>>2;
@@ -396,7 +395,7 @@ static inline void mc_dir_part(AVSContext *h,Picture *pic,
     const int pic_width  = 16*h->mb_width;
     const int pic_height = 16*h->mb_height;
 
-    if(!pic->f.data[0])
+    if (!pic->data[0])
         return;
     if(mx&7) extra_width -= 3;
     if(my&7) extra_height -= 3;
@@ -405,25 +404,25 @@ static inline void mc_dir_part(AVSContext *h,Picture *pic,
           || full_my < 0-extra_height
           || full_mx + 16/*FIXME*/ > pic_width + extra_width
           || full_my + 16/*FIXME*/ > pic_height + extra_height){
-        s->vdsp.emulated_edge_mc(s->edge_emu_buffer, src_y - 2 - 2*h->l_stride, h->l_stride,
+        h->vdsp.emulated_edge_mc(h->edge_emu_buffer, src_y - 2 - 2*h->l_stride, h->l_stride,
                             16+5, 16+5/*FIXME*/, full_mx-2, full_my-2, pic_width, pic_height);
-        src_y= s->edge_emu_buffer + 2 + 2*h->l_stride;
+        src_y= h->edge_emu_buffer + 2 + 2*h->l_stride;
         emu=1;
     }
 
     qpix_op[luma_xy](dest_y, src_y, h->l_stride); //FIXME try variable height perhaps?
 
     if(emu){
-        s->vdsp.emulated_edge_mc(s->edge_emu_buffer, src_cb, h->c_stride,
+        h->vdsp.emulated_edge_mc(h->edge_emu_buffer, src_cb, h->c_stride,
                             9, 9/*FIXME*/, (mx>>3), (my>>3), pic_width>>1, pic_height>>1);
-        src_cb= s->edge_emu_buffer;
+        src_cb= h->edge_emu_buffer;
     }
     chroma_op(dest_cb, src_cb, h->c_stride, chroma_height, mx&7, my&7);
 
     if(emu){
-        s->vdsp.emulated_edge_mc(s->edge_emu_buffer, src_cr, h->c_stride,
+        h->vdsp.emulated_edge_mc(h->edge_emu_buffer, src_cr, h->c_stride,
                             9, 9/*FIXME*/, (mx>>3), (my>>3), pic_width>>1, pic_height>>1);
-        src_cr= s->edge_emu_buffer;
+        src_cr= h->edge_emu_buffer;
     }
     chroma_op(dest_cr, src_cr, h->c_stride, chroma_height, mx&7, my&7);
 }
@@ -444,7 +443,7 @@ static inline void mc_part_std(AVSContext *h,int chroma_height,int delta,
     y_offset += 8*h->mby;
 
     if(mv->ref >= 0){
-        Picture *ref= &h->DPB[mv->ref];
+        AVFrame *ref = h->DPB[mv->ref].f;
         mc_dir_part(h, ref, chroma_height, delta, 0,
                     dest_y, dest_cb, dest_cr, x_offset, y_offset,
                     qpix_op, chroma_op, mv);
@@ -454,7 +453,7 @@ static inline void mc_part_std(AVSContext *h,int chroma_height,int delta,
     }
 
     if((mv+MV_BWD_OFFS)->ref >= 0){
-        Picture *ref= &h->DPB[0];
+        AVFrame *ref = h->DPB[0].f;
         mc_dir_part(h, ref, chroma_height, delta, 1,
                     dest_y, dest_cb, dest_cr, x_offset, y_offset,
                     qpix_op, chroma_op, mv+MV_BWD_OFFS);
@@ -465,30 +464,30 @@ void ff_cavs_inter(AVSContext *h, enum cavs_mb mb_type) {
     if(ff_cavs_partition_flags[mb_type] == 0){ // 16x16
         mc_part_std(h, 8, 0, h->cy, h->cu, h->cv, 0, 0,
                 h->cdsp.put_cavs_qpel_pixels_tab[0],
-                h->s.dsp.put_h264_chroma_pixels_tab[0],
+                h->dsp.put_h264_chroma_pixels_tab[0],
                 h->cdsp.avg_cavs_qpel_pixels_tab[0],
-                h->s.dsp.avg_h264_chroma_pixels_tab[0],&h->mv[MV_FWD_X0]);
+                h->dsp.avg_h264_chroma_pixels_tab[0],&h->mv[MV_FWD_X0]);
     }else{
         mc_part_std(h, 4, 0, h->cy, h->cu, h->cv, 0, 0,
                 h->cdsp.put_cavs_qpel_pixels_tab[1],
-                h->s.dsp.put_h264_chroma_pixels_tab[1],
+                h->dsp.put_h264_chroma_pixels_tab[1],
                 h->cdsp.avg_cavs_qpel_pixels_tab[1],
-                h->s.dsp.avg_h264_chroma_pixels_tab[1],&h->mv[MV_FWD_X0]);
+                h->dsp.avg_h264_chroma_pixels_tab[1],&h->mv[MV_FWD_X0]);
         mc_part_std(h, 4, 0, h->cy, h->cu, h->cv, 4, 0,
                 h->cdsp.put_cavs_qpel_pixels_tab[1],
-                h->s.dsp.put_h264_chroma_pixels_tab[1],
+                h->dsp.put_h264_chroma_pixels_tab[1],
                 h->cdsp.avg_cavs_qpel_pixels_tab[1],
-                h->s.dsp.avg_h264_chroma_pixels_tab[1],&h->mv[MV_FWD_X1]);
+                h->dsp.avg_h264_chroma_pixels_tab[1],&h->mv[MV_FWD_X1]);
         mc_part_std(h, 4, 0, h->cy, h->cu, h->cv, 0, 4,
                 h->cdsp.put_cavs_qpel_pixels_tab[1],
-                h->s.dsp.put_h264_chroma_pixels_tab[1],
+                h->dsp.put_h264_chroma_pixels_tab[1],
                 h->cdsp.avg_cavs_qpel_pixels_tab[1],
-                h->s.dsp.avg_h264_chroma_pixels_tab[1],&h->mv[MV_FWD_X2]);
+                h->dsp.avg_h264_chroma_pixels_tab[1],&h->mv[MV_FWD_X2]);
         mc_part_std(h, 4, 0, h->cy, h->cu, h->cv, 4, 4,
                 h->cdsp.put_cavs_qpel_pixels_tab[1],
-                h->s.dsp.put_h264_chroma_pixels_tab[1],
+                h->dsp.put_h264_chroma_pixels_tab[1],
                 h->cdsp.avg_cavs_qpel_pixels_tab[1],
-                h->s.dsp.avg_h264_chroma_pixels_tab[1],&h->mv[MV_FWD_X3]);
+                h->dsp.avg_h264_chroma_pixels_tab[1],&h->mv[MV_FWD_X3]);
     }
 }
 
@@ -569,8 +568,8 @@ void ff_cavs_mv(AVSContext *h, enum cavs_mv_loc nP, enum cavs_mv_loc nC,
         mv_pred_median(h, mvP, mvA, mvB, mvC);
 
     if(mode < MV_PRED_PSKIP) {
-        mvP->x += get_se_golomb(&h->s.gb);
-        mvP->y += get_se_golomb(&h->s.gb);
+        mvP->x += get_se_golomb(&h->gb);
+        mvP->y += get_se_golomb(&h->gb);
     }
     set_mvs(mvP,size);
 }
@@ -652,9 +651,9 @@ int ff_cavs_next_mb(AVSContext *h) {
         h->mbx = 0;
         h->mby++;
         /* re-calculate sample pointers */
-        h->cy = h->picture.f.data[0] + h->mby * 16 * h->l_stride;
-        h->cu = h->picture.f.data[1] + h->mby *  8 * h->c_stride;
-        h->cv = h->picture.f.data[2] + h->mby *  8 * h->c_stride;
+        h->cy = h->cur.f->data[0] + h->mby * 16 * h->l_stride;
+        h->cu = h->cur.f->data[1] + h->mby *  8 * h->c_stride;
+        h->cv = h->cur.f->data[2] + h->mby *  8 * h->c_stride;
         if(h->mby == h->mb_height) { //frame end
             return 0;
         }
@@ -679,11 +678,11 @@ void ff_cavs_init_pic(AVSContext *h) {
     h->mv[MV_FWD_X0] = ff_cavs_dir_mv;
     set_mvs(&h->mv[MV_FWD_X0], BLK_16X16);
     h->pred_mode_Y[3] = h->pred_mode_Y[6] = NOT_AVAIL;
-    h->cy           = h->picture.f.data[0];
-    h->cu           = h->picture.f.data[1];
-    h->cv           = h->picture.f.data[2];
-    h->l_stride     = h->picture.f.linesize[0];
-    h->c_stride     = h->picture.f.linesize[1];
+    h->cy           = h->cur.f->data[0];
+    h->cu           = h->cur.f->data[1];
+    h->cv           = h->cur.f->data[2];
+    h->l_stride     = h->cur.f->linesize[0];
+    h->c_stride     = h->cur.f->linesize[1];
     h->luma_scan[2] = 8*h->l_stride;
     h->luma_scan[3] = 8*h->l_stride+8;
     h->mbx = h->mby = h->mbidx = 0;
@@ -719,14 +718,25 @@ void ff_cavs_init_top_lines(AVSContext *h) {
 
 av_cold int ff_cavs_init(AVCodecContext *avctx) {
     AVSContext *h = avctx->priv_data;
-    MpegEncContext * const s = &h->s;
 
-    ff_MPV_decode_defaults(s);
+    ff_dsputil_init(&h->dsp, avctx);
+    ff_videodsp_init(&h->vdsp, 8);
     ff_cavsdsp_init(&h->cdsp, avctx);
-    s->avctx = avctx;
+    ff_init_scantable_permutation(h->dsp.idct_permutation,
+                                  h->cdsp.idct_perm);
+    ff_init_scantable(h->dsp.idct_permutation, &h->scantable, ff_zigzag_direct);
 
+    h->avctx = avctx;
     avctx->pix_fmt= AV_PIX_FMT_YUV420P;
 
+    h->cur.f    = avcodec_alloc_frame();
+    h->DPB[0].f = avcodec_alloc_frame();
+    h->DPB[1].f = avcodec_alloc_frame();
+    if (!h->cur.f || !h->DPB[0].f || !h->DPB[1].f) {
+        ff_cavs_end(avctx);
+        return AVERROR(ENOMEM);
+    }
+
     h->luma_scan[0] = 0;
     h->luma_scan[1] = 8;
     h->intra_pred_l[      INTRA_L_VERT] = intra_pred_vert;
@@ -752,6 +762,16 @@ av_cold int ff_cavs_init(AVCodecContext *avctx) {
 av_cold int ff_cavs_end(AVCodecContext *avctx) {
     AVSContext *h = avctx->priv_data;
 
+    if (h->cur.f->data[0])
+        avctx->release_buffer(avctx, h->cur.f);
+    if (h->DPB[0].f->data[0])
+        avctx->release_buffer(avctx, h->DPB[0].f);
+    if (h->DPB[1].f->data[0])
+        avctx->release_buffer(avctx, h->DPB[1].f);
+    avcodec_free_frame(&h->cur.f);
+    avcodec_free_frame(&h->DPB[0].f);
+    avcodec_free_frame(&h->DPB[1].f);
+
     av_free(h->top_qp);
     av_free(h->top_mv[0]);
     av_free(h->top_mv[1]);
@@ -762,5 +782,6 @@ av_cold int ff_cavs_end(AVCodecContext *avctx) {
     av_free(h->col_mv);
     av_free(h->col_type_base);
     av_free(h->block);
+    av_freep(&h->edge_emu_buffer);
     return 0;
 }
diff --git a/libavcodec/cavs.h b/libavcodec/cavs.h
index 2e43124927..2032441351 100644
--- a/libavcodec/cavs.h
+++ b/libavcodec/cavs.h
@@ -22,9 +22,10 @@
 #ifndef AVCODEC_CAVS_H
 #define AVCODEC_CAVS_H
 
-#include "dsputil.h"
-#include "mpegvideo.h"
 #include "cavsdsp.h"
+#include "dsputil.h"
+#include "get_bits.h"
+#include "videodsp.h"
 
 #define SLICE_MAX_START_CODE    0x000001af
 #define EXT_START_CODE          0x000001b5
@@ -152,15 +153,25 @@ struct dec_2dvlc {
   int8_t max_run;
 };
 
+typedef struct AVSFrame {
+    AVFrame *f;
+    int poc;
+} AVSFrame;
+
 typedef struct AVSContext {
-    MpegEncContext s;
-    CAVSDSPContext cdsp;
-    Picture picture; ///< currently decoded frame
-    Picture DPB[2];  ///< reference frames
+    AVCodecContext *avctx;
+    DSPContext       dsp;
+    VideoDSPContext vdsp;
+    CAVSDSPContext  cdsp;
+    GetBitContext gb;
+    AVSFrame cur;     ///< currently decoded frame
+    AVSFrame DPB[2];  ///< reference frames
     int dist[2];     ///< temporal distances from current frame to ref frames
+    int low_delay;
     int profile, level;
     int aspect_ratio;
     int mb_width, mb_height;
+    int width, height;
     int pic_type;
     int stream_revision; ///<0 for samples from 2006, 1 for rm52j encoder
     int progressive;
@@ -221,6 +232,8 @@ typedef struct AVSContext {
     int direct_den[2]; ///< for scaling in direct B block
     int scale_den[2];  ///< for scaling neighbouring MVs
 
+    uint8_t *edge_emu_buffer;
+
     int got_keyframe;
     DCTELEM *block;
 } AVSContext;
diff --git a/libavcodec/cavsdec.c b/libavcodec/cavsdec.c
index 6799b56ef3..e09802b6b1 100644
--- a/libavcodec/cavsdec.c
+++ b/libavcodec/cavsdec.c
@@ -30,6 +30,8 @@
 #include "golomb.h"
 #include "cavs.h"
 #include "internal.h"
+#include "mpeg12data.h"
+#include "mpegvideo.h"
 
 static const uint8_t mv_scan[4] = {
     MV_FWD_X0, MV_FWD_X1,
@@ -525,9 +527,9 @@ static inline int dequant(AVSContext *h, DCTELEM *level_buf, uint8_t *run_buf,
     while (--coeff_num >= 0) {
         pos += run_buf[coeff_num];
         if (pos > 63) {
-            av_log(h->s.avctx, AV_LOG_ERROR,
+            av_log(h->avctx, AV_LOG_ERROR,
                    "position out of block bounds at pic %d MB(%d,%d)\n",
-                   h->picture.poc, h->mbx, h->mby);
+                   h->cur.poc, h->mbx, h->mby);
             return -1;
         }
         dst[scantab[pos]] = (level_buf[coeff_num] * mul + round) >> shift;
@@ -579,7 +581,7 @@ static int decode_residual_block(AVSContext *h, GetBitContext *gb,
                 dequant_shift[qp], i))
         return -1;
     h->cdsp.cavs_idct8_add(dst, block, stride);
-    h->s.dsp.clear_block(block);
+    h->dsp.clear_block(block);
     return 0;
 }
 
@@ -587,10 +589,10 @@ static int decode_residual_block(AVSContext *h, GetBitContext *gb,
 static inline void decode_residual_chroma(AVSContext *h)
 {
     if (h->cbp & (1 << 4))
-        decode_residual_block(h, &h->s.gb, chroma_dec, 0,
+        decode_residual_block(h, &h->gb, chroma_dec, 0,
                               cavs_chroma_qp[h->qp], h->cu, h->c_stride);
     if (h->cbp & (1 << 5))
-        decode_residual_block(h, &h->s.gb, chroma_dec, 0,
+        decode_residual_block(h, &h->gb, chroma_dec, 0,
                               cavs_chroma_qp[h->qp], h->cv, h->c_stride);
 }
 
@@ -599,19 +601,19 @@ static inline int decode_residual_inter(AVSContext *h)
     int block;
 
     /* get coded block pattern */
-    int cbp = get_ue_golomb(&h->s.gb);
+    int cbp = get_ue_golomb(&h->gb);
     if (cbp > 63) {
-        av_log(h->s.avctx, AV_LOG_ERROR, "illegal inter cbp\n");
+        av_log(h->avctx, AV_LOG_ERROR, "illegal inter cbp\n");
         return -1;
     }
     h->cbp = cbp_tab[cbp][1];
 
     /* get quantizer */
     if (h->cbp && !h->qp_fixed)
-        h->qp = (h->qp + get_se_golomb(&h->s.gb)) & 63;
+        h->qp = (h->qp + get_se_golomb(&h->gb)) & 63;
     for (block = 0; block < 4; block++)
         if (h->cbp & (1 << block))
-            decode_residual_block(h, &h->s.gb, inter_dec, 0, h->qp,
+            decode_residual_block(h, &h->gb, inter_dec, 0, h->qp,
                                   h->cy + h->luma_scan[block], h->l_stride);
     decode_residual_chroma(h);
 
@@ -636,7 +638,7 @@ static inline void set_mv_intra(AVSContext *h)
 
 static int decode_mb_i(AVSContext *h, int cbp_code)
 {
-    GetBitContext *gb = &h->s.gb;
+    GetBitContext *gb = &h->gb;
     unsigned pred_mode_uv;
     int block;
     uint8_t top[18];
@@ -663,7 +665,7 @@ static int decode_mb_i(AVSContext *h, int cbp_code)
     }
     pred_mode_uv = get_ue_golomb(gb);
     if (pred_mode_uv > 6) {
-        av_log(h->s.avctx, AV_LOG_ERROR, "illegal intra chroma pred mode\n");
+        av_log(h->avctx, AV_LOG_ERROR, "illegal intra chroma pred mode\n");
         return -1;
     }
     ff_cavs_modify_mb_i(h, &pred_mode_uv);
@@ -672,7 +674,7 @@ static int decode_mb_i(AVSContext *h, int cbp_code)
     if (h->pic_type == AV_PICTURE_TYPE_I)
         cbp_code = get_ue_golomb(gb);
     if (cbp_code > 63) {
-        av_log(h->s.avctx, AV_LOG_ERROR, "illegal intra cbp\n");
+        av_log(h->avctx, AV_LOG_ERROR, "illegal intra cbp\n");
         return -1;
     }
     h->cbp = cbp_tab[cbp_code][0];
@@ -715,7 +717,7 @@ static inline void set_intra_mode_default(AVSContext *h)
 
 static void decode_mb_p(AVSContext *h, enum cavs_mb mb_type)
 {
-    GetBitContext *gb = &h->s.gb;
+    GetBitContext *gb = &h->gb;
     int ref[4];
 
     ff_cavs_init_mb(h);
@@ -796,7 +798,7 @@ static void decode_mb_b(AVSContext *h, enum cavs_mb mb_type)
         break;
     case B_8X8:
         for (block = 0; block < 4; block++)
-            sub_type[block] = get_bits(&h->s.gb, 2);
+            sub_type[block] = get_bits(&h->gb, 2);
         for (block = 0; block < 4; block++) {
             switch (sub_type[block]) {
             case B_SUB_DIRECT:
@@ -876,7 +878,7 @@ static void decode_mb_b(AVSContext *h, enum cavs_mb mb_type)
 static inline int decode_slice_header(AVSContext *h, GetBitContext *gb)
 {
     if (h->stc > 0xAF)
-        av_log(h->s.avctx, AV_LOG_ERROR, "unexpected start code 0x%02x\n", h->stc);
+        av_log(h->avctx, AV_LOG_ERROR, "unexpected start code 0x%02x\n", h->stc);
     h->mby   = h->stc;
     h->mbidx = h->mby * h->mb_width;
 
@@ -890,7 +892,7 @@ static inline int decode_slice_header(AVSContext *h, GetBitContext *gb)
     if ((h->pic_type != AV_PICTURE_TYPE_I) ||
         (!h->pic_structure && h->mby >= h->mb_width / 2))
         if (get_bits1(gb)) { //slice_weighting_flag
-            av_log(h->s.avctx, AV_LOG_ERROR,
+            av_log(h->avctx, AV_LOG_ERROR,
                    "weighted prediction not yet supported\n");
         }
     return 0;
@@ -898,7 +900,7 @@ static inline int decode_slice_header(AVSContext *h, GetBitContext *gb)
 
 static inline int check_for_slice(AVSContext *h)
 {
-    GetBitContext *gb = &h->s.gb;
+    GetBitContext *gb = &h->gb;
     int align;
 
     if (h->mbx)
@@ -926,57 +928,57 @@ static inline int check_for_slice(AVSContext *h)
 
 static int decode_pic(AVSContext *h)
 {
-    MpegEncContext *s = &h->s;
     int skip_count    = -1;
     enum cavs_mb mb_type;
 
-    if (!s->context_initialized) {
-        if (ff_MPV_common_init(s) < 0)
-            return -1;
-        ff_init_scantable_permutation(s->dsp.idct_permutation,
-                                      h->cdsp.idct_perm);
-        ff_init_scantable(s->dsp.idct_permutation, &h->scantable, ff_zigzag_direct);
-    }
-    skip_bits(&s->gb, 16);//bbv_dwlay
+    skip_bits(&h->gb, 16);//bbv_dwlay
     if (h->stc == PIC_PB_START_CODE) {
-        h->pic_type = get_bits(&s->gb, 2) + AV_PICTURE_TYPE_I;
+        h->pic_type = get_bits(&h->gb, 2) + AV_PICTURE_TYPE_I;
         if (h->pic_type > AV_PICTURE_TYPE_B) {
-            av_log(s->avctx, AV_LOG_ERROR, "illegal picture type\n");
+            av_log(h->avctx, AV_LOG_ERROR, "illegal picture type\n");
             return -1;
         }
         /* make sure we have the reference frames we need */
-        if (!h->DPB[0].f.data[0] ||
-           (!h->DPB[1].f.data[0] && h->pic_type == AV_PICTURE_TYPE_B))
+        if (!h->DPB[0].f->data[0] ||
+           (!h->DPB[1].f->data[0] && h->pic_type == AV_PICTURE_TYPE_B))
             return -1;
     } else {
         h->pic_type = AV_PICTURE_TYPE_I;
-        if (get_bits1(&s->gb))
-            skip_bits(&s->gb, 24);//time_code
+        if (get_bits1(&h->gb))
+            skip_bits(&h->gb, 24);//time_code
         /* old sample clips were all progressive and no low_delay,
            bump stream revision if detected otherwise */
-        if (s->low_delay || !(show_bits(&s->gb, 9) & 1))
+        if (h->low_delay || !(show_bits(&h->gb, 9) & 1))
             h->stream_revision = 1;
         /* similarly test top_field_first and repeat_first_field */
-        else if (show_bits(&s->gb, 11) & 3)
+        else if (show_bits(&h->gb, 11) & 3)
             h->stream_revision = 1;
         if (h->stream_revision > 0)
-            skip_bits(&s->gb, 1); //marker_bit
+            skip_bits(&h->gb, 1); //marker_bit
     }
     /* release last B frame */
-    if (h->picture.f.data[0])
-        s->avctx->release_buffer(s->avctx, &h->picture.f);
+    if (h->cur.f->data[0])
+        h->avctx->release_buffer(h->avctx, h->cur.f);
+
+    ff_get_buffer(h->avctx, h->cur.f);
+
+    if (!h->edge_emu_buffer) {
+        int alloc_size = FFALIGN(FFABS(h->cur.f->linesize[0]) + 32, 32);
+        h->edge_emu_buffer = av_mallocz(alloc_size * 2 * 24);
+        if (!h->edge_emu_buffer)
+            return AVERROR(ENOMEM);
+    }
 
-    ff_get_buffer(s->avctx, &h->picture.f);
     ff_cavs_init_pic(h);
-    h->picture.poc = get_bits(&s->gb, 8) * 2;
+    h->cur.poc = get_bits(&h->gb, 8) * 2;
 
     /* get temporal distances and MV scaling factors */
     if (h->pic_type != AV_PICTURE_TYPE_B) {
-        h->dist[0] = (h->picture.poc - h->DPB[0].poc  + 512) % 512;
+        h->dist[0] = (h->cur.poc - h->DPB[0].poc  + 512) % 512;
     } else {
-        h->dist[0] = (h->DPB[0].poc  - h->picture.poc + 512) % 512;
+        h->dist[0] = (h->DPB[0].poc  - h->cur.poc + 512) % 512;
     }
-    h->dist[1] = (h->picture.poc - h->DPB[1].poc  + 512) % 512;
+    h->dist[1] = (h->cur.poc - h->DPB[1].poc  + 512) % 512;
     h->scale_den[0] = h->dist[0] ? 512/h->dist[0] : 0;
     h->scale_den[1] = h->dist[1] ? 512/h->dist[1] : 0;
     if (h->pic_type == AV_PICTURE_TYPE_B) {
@@ -986,32 +988,32 @@ static int decode_pic(AVSContext *h)
         h->direct_den[1] = h->dist[1] ? 16384 / h->dist[1] : 0;
     }
 
-    if (s->low_delay)
-        get_ue_golomb(&s->gb); //bbv_check_times
-    h->progressive   = get_bits1(&s->gb);
+    if (h->low_delay)
+        get_ue_golomb(&h->gb); //bbv_check_times
+    h->progressive   = get_bits1(&h->gb);
     h->pic_structure = 1;
     if (!h->progressive)
-        h->pic_structure = get_bits1(&s->gb);
+        h->pic_structure = get_bits1(&h->gb);
     if (!h->pic_structure && h->stc == PIC_PB_START_CODE)
-        skip_bits1(&s->gb);     //advanced_pred_mode_disable
-    skip_bits1(&s->gb);        //top_field_first
-    skip_bits1(&s->gb);        //repeat_first_field
-    h->qp_fixed = get_bits1(&s->gb);
-    h->qp       = get_bits(&s->gb, 6);
+        skip_bits1(&h->gb);     //advanced_pred_mode_disable
+    skip_bits1(&h->gb);        //top_field_first
+    skip_bits1(&h->gb);        //repeat_first_field
+    h->qp_fixed = get_bits1(&h->gb);
+    h->qp       = get_bits(&h->gb, 6);
     if (h->pic_type == AV_PICTURE_TYPE_I) {
         if (!h->progressive && !h->pic_structure)
-            skip_bits1(&s->gb);//what is this?
-        skip_bits(&s->gb, 4);   //reserved bits
+            skip_bits1(&h->gb);//what is this?
+        skip_bits(&h->gb, 4);   //reserved bits
     } else {
         if (!(h->pic_type == AV_PICTURE_TYPE_B && h->pic_structure == 1))
-            h->ref_flag        = get_bits1(&s->gb);
-        skip_bits(&s->gb, 4);   //reserved bits
-        h->skip_mode_flag      = get_bits1(&s->gb);
+            h->ref_flag        = get_bits1(&h->gb);
+        skip_bits(&h->gb, 4);   //reserved bits
+        h->skip_mode_flag      = get_bits1(&h->gb);
     }
-    h->loop_filter_disable     = get_bits1(&s->gb);
-    if (!h->loop_filter_disable && get_bits1(&s->gb)) {
-        h->alpha_offset        = get_se_golomb(&s->gb);
-        h->beta_offset         = get_se_golomb(&s->gb);
+    h->loop_filter_disable     = get_bits1(&h->gb);
+    if (!h->loop_filter_disable && get_bits1(&h->gb)) {
+        h->alpha_offset        = get_se_golomb(&h->gb);
+        h->beta_offset         = get_se_golomb(&h->gb);
     } else {
         h->alpha_offset = h->beta_offset  = 0;
     }
@@ -1025,11 +1027,11 @@ static int decode_pic(AVSContext *h)
             if (check_for_slice(h))
                 skip_count = -1;
             if (h->skip_mode_flag && (skip_count < 0))
-                skip_count = get_ue_golomb(&s->gb);
+                skip_count = get_ue_golomb(&h->gb);
             if (h->skip_mode_flag && skip_count--) {
                 decode_mb_p(h, P_SKIP);
             } else {
-                mb_type = get_ue_golomb(&s->gb) + P_SKIP + h->skip_mode_flag;
+                mb_type = get_ue_golomb(&h->gb) + P_SKIP + h->skip_mode_flag;
                 if (mb_type > P_8X8)
                     decode_mb_i(h, mb_type - P_8X8 - 1);
                 else
@@ -1041,11 +1043,11 @@ static int decode_pic(AVSContext *h)
             if (check_for_slice(h))
                 skip_count = -1;
             if (h->skip_mode_flag && (skip_count < 0))
-                skip_count = get_ue_golomb(&s->gb);
+                skip_count = get_ue_golomb(&h->gb);
             if (h->skip_mode_flag && skip_count--) {
                 decode_mb_b(h, B_SKIP);
             } else {
-                mb_type = get_ue_golomb(&s->gb) + B_SKIP + h->skip_mode_flag;
+                mb_type = get_ue_golomb(&h->gb) + B_SKIP + h->skip_mode_flag;
                 if (mb_type > B_8X8)
                     decode_mb_i(h, mb_type - B_8X8 - 1);
                 else
@@ -1054,11 +1056,10 @@ static int decode_pic(AVSContext *h)
         } while (ff_cavs_next_mb(h));
     }
     if (h->pic_type != AV_PICTURE_TYPE_B) {
-        if (h->DPB[1].f.data[0])
-            s->avctx->release_buffer(s->avctx, &h->DPB[1].f);
-        h->DPB[1] = h->DPB[0];
-        h->DPB[0] = h->picture;
-        memset(&h->picture, 0, sizeof(Picture));
+        if (h->DPB[1].f->data[0])
+            h->avctx->release_buffer(h->avctx, h->DPB[1].f);
+        FFSWAP(AVSFrame, h->cur, h->DPB[1]);
+        FFSWAP(AVSFrame, h->DPB[0], h->DPB[1]);
     }
     return 0;
 }
@@ -1071,37 +1072,36 @@ static int decode_pic(AVSContext *h)
 
 static int decode_seq_header(AVSContext *h)
 {
-    MpegEncContext *s = &h->s;
     int frame_rate_code;
     int width, height;
 
-    h->profile = get_bits(&s->gb, 8);
-    h->level   = get_bits(&s->gb, 8);
-    skip_bits1(&s->gb); //progressive sequence
+    h->profile = get_bits(&h->gb, 8);
+    h->level   = get_bits(&h->gb, 8);
+    skip_bits1(&h->gb); //progressive sequence
 
-    width  = get_bits(&s->gb, 14);
-    height = get_bits(&s->gb, 14);
-    if ((s->width || s->height) && (s->width != width || s->height != height)) {
-        av_log_missing_feature(s, "Width/height changing in CAVS", 0);
+    width  = get_bits(&h->gb, 14);
+    height = get_bits(&h->gb, 14);
+    if ((h->width || h->height) && (h->width != width || h->height != height)) {
+        av_log_missing_feature(h->avctx, "Width/height changing in CAVS", 0);
         return AVERROR_PATCHWELCOME;
     }
-    s->width  = width;
-    s->height = height;
-
-    skip_bits(&s->gb, 2); //chroma format
-    skip_bits(&s->gb, 3); //sample_precision
-    h->aspect_ratio = get_bits(&s->gb, 4);
-    frame_rate_code = get_bits(&s->gb, 4);
-    skip_bits(&s->gb, 18); //bit_rate_lower
-    skip_bits1(&s->gb);    //marker_bit
-    skip_bits(&s->gb, 12); //bit_rate_upper
-    s->low_delay =  get_bits1(&s->gb);
-    h->mb_width  = (s->width  + 15) >> 4;
-    h->mb_height = (s->height + 15) >> 4;
-    h->s.avctx->time_base.den = ff_mpeg12_frame_rate_tab[frame_rate_code].num;
-    h->s.avctx->time_base.num = ff_mpeg12_frame_rate_tab[frame_rate_code].den;
-    h->s.avctx->width  = s->width;
-    h->s.avctx->height = s->height;
+    h->width  = width;
+    h->height = height;
+
+    skip_bits(&h->gb, 2); //chroma format
+    skip_bits(&h->gb, 3); //sample_precision
+    h->aspect_ratio = get_bits(&h->gb, 4);
+    frame_rate_code = get_bits(&h->gb, 4);
+    skip_bits(&h->gb, 18); //bit_rate_lower
+    skip_bits1(&h->gb);    //marker_bit
+    skip_bits(&h->gb, 12); //bit_rate_upper
+    h->low_delay =  get_bits1(&h->gb);
+    h->mb_width  = (h->width  + 15) >> 4;
+    h->mb_height = (h->height + 15) >> 4;
+    h->avctx->time_base.den = ff_mpeg12_frame_rate_tab[frame_rate_code].num;
+    h->avctx->time_base.num = ff_mpeg12_frame_rate_tab[frame_rate_code].den;
+    h->avctx->width  = h->width;
+    h->avctx->height = h->height;
     if (!h->top_qp)
         ff_cavs_init_top_lines(h);
     return 0;
@@ -1117,7 +1117,6 @@ static int cavs_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
                              AVPacket *avpkt)
 {
     AVSContext *h      = avctx->priv_data;
-    MpegEncContext *s  = &h->s;
     const uint8_t *buf = avpkt->data;
     int buf_size       = avpkt->size;
     AVFrame *picture   = data;
@@ -1126,13 +1125,13 @@ static int cavs_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
     const uint8_t *buf_end;
     const uint8_t *buf_ptr;
 
-    s->avctx = avctx;
-
     if (buf_size == 0) {
-        if (!s->low_delay && h->DPB[0].f.data[0]) {
+        if (!h->low_delay && h->DPB[0].f->data[0]) {
             *got_frame = 1;
-            *picture = h->DPB[0].f;
-            memset(&h->DPB[0], 0, sizeof(h->DPB[0]));
+            *picture = *h->DPB[0].f;
+            if (h->cur.f->data[0])
+                avctx->release_buffer(avctx, h->cur.f);
+            FFSWAP(AVSFrame, h->cur, h->DPB[0]);
         }
         return 0;
     }
@@ -1142,38 +1141,38 @@ static int cavs_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
     for(;;) {
         buf_ptr = avpriv_mpv_find_start_code(buf_ptr, buf_end, &stc);
         if ((stc & 0xFFFFFE00) || buf_ptr == buf_end)
-            return FFMAX(0, buf_ptr - buf - s->parse_context.last_index);
+            return FFMAX(0, buf_ptr - buf);
         input_size = (buf_end - buf_ptr) * 8;
         switch (stc) {
         case CAVS_START_CODE:
-            init_get_bits(&s->gb, buf_ptr, input_size);
+            init_get_bits(&h->gb, buf_ptr, input_size);
             decode_seq_header(h);
             break;
         case PIC_I_START_CODE:
             if (!h->got_keyframe) {
-                if(h->DPB[0].f.data[0])
-                    avctx->release_buffer(avctx, &h->DPB[0].f);
-                if(h->DPB[1].f.data[0])
-                    avctx->release_buffer(avctx, &h->DPB[1].f);
+                if(h->DPB[0].f->data[0])
+                    avctx->release_buffer(avctx, h->DPB[0].f);
+                if(h->DPB[1].f->data[0])
+                    avctx->release_buffer(avctx, h->DPB[1].f);
                 h->got_keyframe = 1;
             }
         case PIC_PB_START_CODE:
             *got_frame = 0;
             if (!h->got_keyframe)
                 break;
-            init_get_bits(&s->gb, buf_ptr, input_size);
+            init_get_bits(&h->gb, buf_ptr, input_size);
             h->stc = stc;
             if (decode_pic(h))
                 break;
             *got_frame = 1;
             if (h->pic_type != AV_PICTURE_TYPE_B) {
-                if (h->DPB[1].f.data[0]) {
-                    *picture = h->DPB[1].f;
+                if (h->DPB[1].f->data[0]) {
+                    *picture = *h->DPB[1].f;
                 } else {
                     *got_frame = 0;
                 }
             } else
-                *picture = h->picture.f;
+                *picture = *h->cur.f;
             break;
         case EXT_START_CODE:
             //mpeg_decode_extension(avctx, buf_ptr, input_size);
@@ -1183,8 +1182,8 @@ static int cavs_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
             break;
         default:
             if (stc <= SLICE_MAX_START_CODE) {
-                init_get_bits(&s->gb, buf_ptr, input_size);
-                decode_slice_header(h, &s->gb);
+                init_get_bits(&h->gb, buf_ptr, input_size);
+                decode_slice_header(h, &h->gb);
             }
             break;
         }