@@ -76,7 +76,7 @@ int ff_dxva2_commit_buffer(AVCodecContext *avctx,

     return result;

 }

-int ff_dxva2_common_end_frame(AVCodecContext *avctx, MpegEncContext *s,

+int ff_dxva2_common_end_frame(AVCodecContext *avctx, Picture *pic,

                               const void *pp, unsigned pp_size,

                               const void *qm, unsigned qm_size,

                               int (*commit_bs_si)(AVCodecContext *,

@@ -90,7 +90,7 @@ int ff_dxva2_common_end_frame(AVCodecContext *avctx, MpegEncContext *s,

     int      result;

     if (FAILED(IDirectXVideoDecoder_BeginFrame(ctx->decoder,

-                                               ff_dxva2_get_surface(s->current_picture_ptr),

+                                               ff_dxva2_get_surface(pic),

                                                NULL))) {

         av_log(avctx, AV_LOG_ERROR, "Failed to begin frame\n");

         return -1;

@@ -146,7 +146,5 @@ end:

         result = -1;

     }

-    if (!result)

-        ff_mpeg_draw_horiz_band(s, 0, s->avctx->height);

     return result;

 }

@@ -44,15 +44,14 @@ static void fill_picture_entry(DXVA_PicEntry_H264 *pic,

 static void fill_picture_parameters(struct dxva_context *ctx, const H264Context *h,

                                     DXVA_PicParams_H264 *pp)

 {

-    const MpegEncContext *s = &h->s;

-    const Picture *current_picture = s->current_picture_ptr;

+    const Picture *current_picture = h->cur_pic_ptr;

     int i, j;

     memset(pp, 0, sizeof(*pp));

     /* Configure current picture */

     fill_picture_entry(&pp->CurrPic,

                        ff_dxva2_get_surface_index(ctx, current_picture),

-                       s->picture_structure == PICT_BOTTOM_FIELD);

+                       h->picture_structure == PICT_BOTTOM_FIELD);

     /* Configure the set of references */

     pp->UsedForReferenceFlags  = 0;

     pp->NonExistingFrameFlags  = 0;

@@ -88,13 +87,13 @@ static void fill_picture_parameters(struct dxva_context *ctx, const H264Context

         }

     }

-    pp->wFrameWidthInMbsMinus1        = s->mb_width  - 1;

-    pp->wFrameHeightInMbsMinus1       = s->mb_height - 1;

+    pp->wFrameWidthInMbsMinus1        = h->mb_width  - 1;

+    pp->wFrameHeightInMbsMinus1       = h->mb_height - 1;

     pp->num_ref_frames                = h->sps.ref_frame_count;

-    pp->wBitFields                    = ((s->picture_structure != PICT_FRAME) <<  0) |

+    pp->wBitFields                    = ((h->picture_structure != PICT_FRAME) <<  0) |

                                         ((h->sps.mb_aff &&

-                                        (s->picture_structure == PICT_FRAME)) <<  1) |

+                                        (h->picture_structure == PICT_FRAME)) <<  1) |

                                         (h->sps.residual_color_transform_flag <<  2) |

                                         /* sp_for_switch_flag (not implemented by Libav) */

                                         (0                                    <<  3) |

@@ -120,11 +119,11 @@ static void fill_picture_parameters(struct dxva_context *ctx, const H264Context

         pp->Reserved16Bits            = 3; /* FIXME is there a way to detect the right mode ? */

     pp->StatusReportFeedbackNumber    = 1 + ctx->report_id++;

     pp->CurrFieldOrderCnt[0] = 0;

-    if ((s->picture_structure & PICT_TOP_FIELD) &&

+    if ((h->picture_structure & PICT_TOP_FIELD) &&

         current_picture->field_poc[0] != INT_MAX)

         pp->CurrFieldOrderCnt[0] = current_picture->field_poc[0];

     pp->CurrFieldOrderCnt[1] = 0;

-    if ((s->picture_structure & PICT_BOTTOM_FIELD) &&

+    if ((h->picture_structure & PICT_BOTTOM_FIELD) &&

         current_picture->field_poc[1] != INT_MAX)

         pp->CurrFieldOrderCnt[1] = current_picture->field_poc[1];

     pp->pic_init_qs_minus26           = h->pps.init_qs - 26;

@@ -200,7 +199,6 @@ static void fill_slice_long(AVCodecContext *avctx, DXVA_Slice_H264_Long *slice,

 {

     const H264Context *h = avctx->priv_data;

     struct dxva_context *ctx = avctx->hwaccel_context;

-    const MpegEncContext *s = &h->s;

     unsigned list;

     memset(slice, 0, sizeof(*slice));

@@ -208,9 +206,9 @@ static void fill_slice_long(AVCodecContext *avctx, DXVA_Slice_H264_Long *slice,

     slice->SliceBytesInBuffer    = size;

     slice->wBadSliceChopping     = 0;

-    slice->first_mb_in_slice     = (s->mb_y >> FIELD_OR_MBAFF_PICTURE) * s->mb_width + s->mb_x;

+    slice->first_mb_in_slice     = (h->mb_y >> FIELD_OR_MBAFF_PICTURE) * h->mb_width + h->mb_x;

     slice->NumMbsForSlice        = 0; /* XXX it is set once we have all slices */

-    slice->BitOffsetToSliceData  = get_bits_count(&s->gb);

+    slice->BitOffsetToSliceData  = get_bits_count(&h->gb);

     slice->slice_type            = ff_h264_get_slice_type(h);

     if (h->slice_type_fixed)

         slice->slice_type += 5;

@@ -260,7 +258,7 @@ static void fill_slice_long(AVCodecContext *avctx, DXVA_Slice_H264_Long *slice,

         }

     }

     slice->slice_qs_delta    = 0; /* XXX not implemented by Libav */

-    slice->slice_qp_delta    = s->qscale - h->pps.init_qp;

+    slice->slice_qp_delta    = h->qscale - h->pps.init_qp;

     slice->redundant_pic_cnt = h->redundant_pic_count;

     if (h->slice_type == AV_PICTURE_TYPE_B)

         slice->direct_spatial_mv_pred_flag = h->direct_spatial_mv_pred;

@@ -277,10 +275,9 @@ static int commit_bitstream_and_slice_buffer(AVCodecContext *avctx,

                                              DXVA2_DecodeBufferDesc *sc)

 {

     const H264Context *h = avctx->priv_data;

-    const MpegEncContext *s = &h->s;

-    const unsigned mb_count = s->mb_width * s->mb_height;

+    const unsigned mb_count = h->mb_width * h->mb_height;

     struct dxva_context *ctx = avctx->hwaccel_context;

-    const Picture *current_picture = h->s.current_picture_ptr;

+    const Picture *current_picture = h->cur_pic_ptr;

     struct dxva2_picture_context *ctx_pic = current_picture->f.hwaccel_picture_private;

     DXVA_Slice_H264_Short *slice = NULL;

     uint8_t  *dxva_data, *current, *end;

@@ -376,7 +373,7 @@ static int start_frame(AVCodecContext *avctx,

 {

     const H264Context *h = avctx->priv_data;

     struct dxva_context *ctx = avctx->hwaccel_context;

-    struct dxva2_picture_context *ctx_pic = h->s.current_picture_ptr->f.hwaccel_picture_private;

+    struct dxva2_picture_context *ctx_pic = h->cur_pic_ptr->f.hwaccel_picture_private;

     if (!ctx->decoder || !ctx->cfg || ctx->surface_count <= 0)

         return -1;

@@ -399,7 +396,7 @@ static int decode_slice(AVCodecContext *avctx,

 {

     const H264Context *h = avctx->priv_data;

     struct dxva_context *ctx = avctx->hwaccel_context;

-    const Picture *current_picture = h->s.current_picture_ptr;

+    const Picture *current_picture = h->cur_pic_ptr;

     struct dxva2_picture_context *ctx_pic = current_picture->f.hwaccel_picture_private;

     unsigned position;

@@ -427,16 +424,19 @@ static int decode_slice(AVCodecContext *avctx,

 static int end_frame(AVCodecContext *avctx)

 {

     H264Context *h = avctx->priv_data;

-    MpegEncContext *s = &h->s;

     struct dxva2_picture_context *ctx_pic =

-        h->s.current_picture_ptr->f.hwaccel_picture_private;

+        h->cur_pic_ptr->f.hwaccel_picture_private;

+    int ret;

     if (ctx_pic->slice_count <= 0 || ctx_pic->bitstream_size <= 0)

         return -1;

-    return ff_dxva2_common_end_frame(avctx, s,

-                                     &ctx_pic->pp, sizeof(ctx_pic->pp),

-                                     &ctx_pic->qm, sizeof(ctx_pic->qm),

-                                     commit_bitstream_and_slice_buffer);

+    ret = ff_dxva2_common_end_frame(avctx, h->cur_pic_ptr,

+                                    &ctx_pic->pp, sizeof(ctx_pic->pp),

+                                    &ctx_pic->qm, sizeof(ctx_pic->qm),

+                                    commit_bitstream_and_slice_buffer);

+    if (!ret)

+        ff_h264_draw_horiz_band(h, 0, h->avctx->height);

+    return ret;

 }

 AVHWAccel ff_h264_dxva2_hwaccel = {

@@ -47,7 +47,7 @@ int ff_dxva2_commit_buffer(AVCodecContext *, struct dxva_context *,

                            unsigned mb_count);

-int ff_dxva2_common_end_frame(AVCodecContext *, MpegEncContext *,

+int ff_dxva2_common_end_frame(AVCodecContext *, Picture *,

                               const void *pp, unsigned pp_size,

                               const void *qm, unsigned qm_size,

                               int (*commit_bs_si)(AVCodecContext *,

@@ -251,13 +251,17 @@ static int end_frame(AVCodecContext *avctx)

     struct MpegEncContext *s = avctx->priv_data;

     struct dxva2_picture_context *ctx_pic =

         s->current_picture_ptr->f.hwaccel_picture_private;

+    int ret;

     if (ctx_pic->slice_count <= 0 || ctx_pic->bitstream_size <= 0)

         return -1;

-    return ff_dxva2_common_end_frame(avctx, s,

-                                     &ctx_pic->pp, sizeof(ctx_pic->pp),

-                                     &ctx_pic->qm, sizeof(ctx_pic->qm),

-                                     commit_bitstream_and_slice_buffer);

+    ret = ff_dxva2_common_end_frame(avctx, s->current_picture_ptr,

+                                    &ctx_pic->pp, sizeof(ctx_pic->pp),

+                                    &ctx_pic->qm, sizeof(ctx_pic->qm),

+                                    commit_bitstream_and_slice_buffer);

+    if (!ret)

+        ff_mpeg_draw_horiz_band(s, 0, avctx->height);

+    return ret;

 }

 AVHWAccel ff_mpeg2_dxva2_hwaccel = {

@@ -254,14 +254,18 @@ static int end_frame(AVCodecContext *avctx)

 {

     VC1Context *v = avctx->priv_data;

     struct dxva2_picture_context *ctx_pic = v->s.current_picture_ptr->f.hwaccel_picture_private;

+    int ret;

     if (ctx_pic->bitstream_size <= 0)

         return -1;

-    return ff_dxva2_common_end_frame(avctx, &v->s,

-                                     &ctx_pic->pp, sizeof(ctx_pic->pp),

-                                     NULL, 0,

-                                     commit_bitstream_and_slice_buffer);

+    ret = ff_dxva2_common_end_frame(avctx, v->s.current_picture_ptr,

+                                    &ctx_pic->pp, sizeof(ctx_pic->pp),

+                                    NULL, 0,

+                                    commit_bitstream_and_slice_buffer);

+    if (!ret)

+        ff_mpeg_draw_horiz_band(&v->s, 0, avctx->height);

+    return ret;

 }

 #if CONFIG_WMV3_DXVA2_HWACCEL

@@ -83,11 +83,10 @@ static void h264_er_decode_mb(void *opaque, int ref, int mv_dir, int mv_type,

                               int mb_x, int mb_y, int mb_intra, int mb_skipped)

 {

     H264Context    *h = opaque;

-    MpegEncContext *s = &h->s;

-    s->mb_x  = mb_x;

-    s->mb_y  = mb_y;

-    h->mb_xy = s->mb_x + s->mb_y * s->mb_stride;

+    h->mb_x  = mb_x;

+    h->mb_y  = mb_y;

+    h->mb_xy = mb_x + mb_y * h->mb_stride;

     memset(h->non_zero_count_cache, 0, sizeof(h->non_zero_count_cache));

     assert(ref >= 0);

     /* FIXME: It is possible albeit uncommon that slice references

@@ -96,22 +95,179 @@ static void h264_er_decode_mb(void *opaque, int ref, int mv_dir, int mv_type,

      * practice then correct remapping should be added. */

     if (ref >= h->ref_count[0])

         ref = 0;

-    fill_rectangle(&s->current_picture.f.ref_index[0][4 * h->mb_xy],

+    fill_rectangle(&h->cur_pic.f.ref_index[0][4 * h->mb_xy],

                    2, 2, 2, ref, 1);

     fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, ref, 1);

     fill_rectangle(h->mv_cache[0][scan8[0]], 4, 4, 8,

-                   pack16to32(s->mv[0][0][0], s->mv[0][0][1]), 4);

+                   pack16to32((*mv)[0][0][0], (*mv)[0][0][1]), 4);

     assert(!FRAME_MBAFF);

     ff_h264_hl_decode_mb(h);

 }

+void ff_h264_draw_horiz_band(H264Context *h, int y, int height)

+{

+    ff_draw_horiz_band(h->avctx, &h->dsp, &h->cur_pic,

+                       h->ref_list[0][0].f.data[0] ? &h->ref_list[0][0] : NULL,

+                       y, height, h->picture_structure, h->first_field, 1,

+                       h->low_delay, h->mb_height * 16, h->mb_width * 16);

+}

+

+static void free_frame_buffer(H264Context *h, Picture *pic)

+{

+    ff_thread_release_buffer(h->avctx, &pic->f);

+    av_freep(&pic->f.hwaccel_picture_private);

+}

+

+static void free_picture(H264Context *h, Picture *pic)

+{

+    int i;

+

+    if (pic->f.data[0])

+        free_frame_buffer(h, pic);

+

+    av_freep(&pic->qscale_table_base);

+    pic->f.qscale_table = NULL;

+    av_freep(&pic->mb_type_base);

+    pic->f.mb_type = NULL;

+    for (i = 0; i < 2; i++) {

+        av_freep(&pic->motion_val_base[i]);

+        av_freep(&pic->f.ref_index[i]);

+        pic->f.motion_val[i] = NULL;

+    }

+}

+

+static void release_unused_pictures(H264Context *h, int remove_current)

+{

+    int i;

+

+    /* release non reference frames */

+    for (i = 0; i < h->picture_count; i++) {

+        if (h->DPB[i].f.data[0] && !h->DPB[i].f.reference &&

+            (!h->DPB[i].owner2 || h->DPB[i].owner2 == h) &&

+            (remove_current || &h->DPB[i] != h->cur_pic_ptr)) {

+            free_frame_buffer(h, &h->DPB[i]);

+        }

+    }

+}

+

+static int alloc_scratch_buffers(H264Context *h, int linesize)

+{

+    int alloc_size = FFALIGN(FFABS(linesize) + 32, 32);

+

+    if (h->bipred_scratchpad)

+        return 0;

+

+    h->bipred_scratchpad = av_malloc(16 * 6 * alloc_size);

+    // edge emu needs blocksize + filter length - 1

+    // (= 21x21 for  h264)

+    h->edge_emu_buffer = av_mallocz(alloc_size * 2 * 21);

+    h->me.scratchpad   = av_mallocz(alloc_size * 2 * 16 * 2);

+

+    if (!h->bipred_scratchpad || !h->edge_emu_buffer || !h->me.scratchpad) {

+        av_freep(&h->bipred_scratchpad);

+        av_freep(&h->edge_emu_buffer);

+        av_freep(&h->me.scratchpad);

+        return AVERROR(ENOMEM);

+    }

+

+    h->me.temp = h->me.scratchpad;

+

+    return 0;

+}

+

+static int alloc_picture(H264Context *h, Picture *pic)

+{

+    const int big_mb_num    = h->mb_stride * (h->mb_height + 1) + 1;

+    const int mb_array_size = h->mb_stride * h->mb_height;

+    const int b4_stride     = h->mb_width * 4 + 1;

+    const int b4_array_size = b4_stride * h->mb_height * 4;

+    int i, ret = 0;

+

+    av_assert0(!pic->f.data[0]);

+

+    if (h->avctx->hwaccel) {

+        const AVHWAccel *hwaccel = h->avctx->hwaccel;

+        av_assert0(!pic->f.hwaccel_picture_private);

+        if (hwaccel->priv_data_size) {

+            pic->f.hwaccel_picture_private = av_mallocz(hwaccel->priv_data_size);

+            if (!pic->f.hwaccel_picture_private)

+                return AVERROR(ENOMEM);

+        }

+    }

+    ret = ff_thread_get_buffer(h->avctx, &pic->f);

+    if (ret < 0)

+        goto fail;

+

+    h->linesize   = pic->f.linesize[0];

+    h->uvlinesize = pic->f.linesize[1];

+

+    if (pic->f.qscale_table == NULL) {

+        FF_ALLOCZ_OR_GOTO(h->avctx, pic->qscale_table_base,

+                          (big_mb_num + h->mb_stride) * sizeof(uint8_t),

+                          fail)

+        FF_ALLOCZ_OR_GOTO(h->avctx, pic->mb_type_base,

+                          (big_mb_num + h->mb_stride) * sizeof(uint32_t),

+                          fail)

+        pic->f.mb_type = pic->mb_type_base + 2 * h->mb_stride + 1;

+        pic->f.qscale_table = pic->qscale_table_base + 2 * h->mb_stride + 1;

+

+        for (i = 0; i < 2; i++) {

+            FF_ALLOCZ_OR_GOTO(h->avctx, pic->motion_val_base[i],

+                              2 * (b4_array_size + 4) * sizeof(int16_t),

+                              fail)

+            pic->f.motion_val[i] = pic->motion_val_base[i] + 4;

+            FF_ALLOCZ_OR_GOTO(h->avctx, pic->f.ref_index[i],

+                              4 * mb_array_size * sizeof(uint8_t), fail)

+        }

+        pic->f.motion_subsample_log2 = 2;

+

+        pic->f.qstride = h->mb_stride;

+    }

+

+    pic->owner2 = h;

+

+    return 0;

+fail:

+    free_frame_buffer(h, pic);

+    return (ret < 0) ? ret : AVERROR(ENOMEM);

+}

+

+static inline int pic_is_unused(H264Context *h, Picture *pic)

+{

+    if (pic->f.data[0] == NULL)

+        return 1;

+    if (pic->needs_realloc && !(pic->f.reference & DELAYED_PIC_REF))

+        if (!pic->owner2 || pic->owner2 == h)

+            return 1;

+    return 0;

+}

+

+static int find_unused_picture(H264Context *h)

+{

+    int i;

+

+    for (i = h->picture_range_start; i < h->picture_range_end; i++) {

+        if (pic_is_unused(h, &h->DPB[i]))

+            break;

+    }

+    if (i == h->picture_range_end)

+        return AVERROR_INVALIDDATA;

+

+    if (h->DPB[i].needs_realloc) {

+        h->DPB[i].needs_realloc = 0;

+        free_picture(h, &h->DPB[i]);

+        avcodec_get_frame_defaults(&h->DPB[i].f);

+    }

+

+    return i;

+}

+

 /**

  * Check if the top & left blocks are available if needed and

  * change the dc mode so it only uses the available blocks.

  */

 int ff_h264_check_intra4x4_pred_mode(H264Context *h)

 {

-    MpegEncContext *const s     = &h->s;

     static const int8_t top[12] = {

         -1, 0, LEFT_DC_PRED, -1, -1, -1, -1, -1, 0

     };

@@ -124,9 +280,9 @@ int ff_h264_check_intra4x4_pred_mode(H264Context *h)

         for (i = 0; i < 4; i++) {

             int status = top[h->intra4x4_pred_mode_cache[scan8[0] + i]];

             if (status < 0) {

-                av_log(h->s.avctx, AV_LOG_ERROR,

+                av_log(h->avctx, AV_LOG_ERROR,

                        "top block unavailable for requested intra4x4 mode %d at %d %d\n",

-                       status, s->mb_x, s->mb_y);

+                       status, h->mb_x, h->mb_y);

                 return -1;

             } else if (status) {

                 h->intra4x4_pred_mode_cache[scan8[0] + i] = status;

@@ -140,9 +296,9 @@ int ff_h264_check_intra4x4_pred_mode(H264Context *h)

             if (!(h->left_samples_available & mask[i])) {

                 int status = left[h->intra4x4_pred_mode_cache[scan8[0] + 8 * i]];

                 if (status < 0) {

-                    av_log(h->s.avctx, AV_LOG_ERROR,

+                    av_log(h->avctx, AV_LOG_ERROR,

                            "left block unavailable for requested intra4x4 mode %d at %d %d\n",

-                           status, s->mb_x, s->mb_y);

+                           status, h->mb_x, h->mb_y);

                     return -1;

                 } else if (status) {

                     h->intra4x4_pred_mode_cache[scan8[0] + 8 * i] = status;

@@ -159,23 +315,22 @@ int ff_h264_check_intra4x4_pred_mode(H264Context *h)

  */

 int ff_h264_check_intra_pred_mode(H264Context *h, int mode, int is_chroma)

 {

-    MpegEncContext *const s     = &h->s;

     static const int8_t top[7]  = { LEFT_DC_PRED8x8, 1, -1, -1 };

     static const int8_t left[7] = { TOP_DC_PRED8x8, -1, 2, -1, DC_128_PRED8x8 };

     if (mode > 6U) {

-        av_log(h->s.avctx, AV_LOG_ERROR,

+        av_log(h->avctx, AV_LOG_ERROR,

                "out of range intra chroma pred mode at %d %d\n",

-               s->mb_x, s->mb_y);

+               h->mb_x, h->mb_y);

         return -1;

     }

     if (!(h->top_samples_available & 0x8000)) {

         mode = top[mode];

         if (mode < 0) {

-            av_log(h->s.avctx, AV_LOG_ERROR,

+            av_log(h->avctx, AV_LOG_ERROR,

                    "top block unavailable for requested intra mode at %d %d\n",

-                   s->mb_x, s->mb_y);

+                   h->mb_x, h->mb_y);

             return -1;

         }

     }

@@ -189,9 +344,9 @@ int ff_h264_check_intra_pred_mode(H264Context *h, int mode, int is_chroma)

                    2 * (mode == DC_128_PRED8x8);

         }

         if (mode < 0) {

-            av_log(h->s.avctx, AV_LOG_ERROR,

+            av_log(h->avctx, AV_LOG_ERROR,

                    "left block unavailable for requested intra mode at %d %d\n",

-                   s->mb_x, s->mb_y);

+                   h->mb_x, h->mb_y);

             return -1;

         }

     }

@@ -314,7 +469,7 @@ static int decode_rbsp_trailing(H264Context *h, const uint8_t *src)

     int v = *src;

     int r;

-    tprintf(h->s.avctx, "rbsp trailing %X\n", v);

+    tprintf(h->avctx, "rbsp trailing %X\n", v);

     for (r = 1; r < 9; r++) {

         if (v & 1)

@@ -341,10 +496,9 @@ static inline void get_lowest_part_y(H264Context *h, int refs[2][48], int n,

                                      int height, int y_offset, int list0,

                                      int list1, int *nrefs)

 {

-    MpegEncContext *const s = &h->s;

     int my;

-    y_offset += 16 * (s->mb_y >> MB_FIELD);

+    y_offset += 16 * (h->mb_y >> MB_FIELD);

     if (list0) {

         int ref_n    = h->ref_cache[0][scan8[n]];

@@ -353,8 +507,8 @@ static inline void get_lowest_part_y(H264Context *h, int refs[2][48], int n,

         // Error resilience puts the current picture in the ref list.

         // Don't try to wait on these as it will cause a deadlock.

         // Fields can wait on each other, though.

-        if (ref->f.thread_opaque   != s->current_picture.f.thread_opaque ||

-            (ref->f.reference & 3) != s->picture_structure) {

+        if (ref->f.thread_opaque   != h->cur_pic.f.thread_opaque ||

+            (ref->f.reference & 3) != h->picture_structure) {

             my = get_lowest_part_list_y(h, ref, n, height, y_offset, 0);

             if (refs[0][ref_n] < 0)

                 nrefs[0] += 1;

@@ -366,8 +520,8 @@ static inline void get_lowest_part_y(H264Context *h, int refs[2][48], int n,

         int ref_n    = h->ref_cache[1][scan8[n]];

         Picture *ref = &h->ref_list[1][ref_n];

-        if (ref->f.thread_opaque   != s->current_picture.f.thread_opaque ||

-            (ref->f.reference & 3) != s->picture_structure) {

+        if (ref->f.thread_opaque   != h->cur_pic.f.thread_opaque ||

+            (ref->f.reference & 3) != h->picture_structure) {

             my = get_lowest_part_list_y(h, ref, n, height, y_offset, 1);

             if (refs[1][ref_n] < 0)

                 nrefs[1] += 1;

@@ -383,9 +537,8 @@ static inline void get_lowest_part_y(H264Context *h, int refs[2][48], int n,

  */

 static void await_references(H264Context *h)

 {

-    MpegEncContext *const s = &h->s;

     const int mb_xy   = h->mb_xy;

-    const int mb_type = s->current_picture.f.mb_type[mb_xy];

+    const int mb_type = h->cur_pic.f.mb_type[mb_xy];

     int refs[2][48];

     int nrefs[2] = { 0 };

     int ref, list;

@@ -459,7 +612,7 @@ static void await_references(H264Context *h)

                 Picture *ref_pic      = &h->ref_list[list][ref];

                 int ref_field         = ref_pic->f.reference - 1;

                 int ref_field_picture = ref_pic->field_picture;

-                int pic_height        = 16 * s->mb_height >> ref_field_picture;

+                int pic_height        = 16 * h->mb_height >> ref_field_picture;

                 row <<= MB_MBAFF;

                 nrefs[list]--;

@@ -500,7 +653,6 @@ static av_always_inline void mc_dir_part(H264Context *h, Picture *pic,

                                          h264_chroma_mc_func chroma_op,

                                          int pixel_shift, int chroma_idc)

 {

-    MpegEncContext *const s = &h->s;

     const int mx      = h->mv_cache[list][scan8[n]][0] + src_x_offset * 8;

     int my            = h->mv_cache[list][scan8[n]][1] + src_y_offset * 8;

     const int luma_xy = (mx & 3) + ((my & 3) << 2);

@@ -512,8 +664,8 @@ static av_always_inline void mc_dir_part(H264Context *h, Picture *pic,

     int emu = 0;

     const int full_mx    = mx >> 2;

     const int full_my    = my >> 2;

-    const int pic_width  = 16 * s->mb_width;

-    const int pic_height = 16 * s->mb_height >> MB_FIELD;

+    const int pic_width  = 16 * h->mb_width;

+    const int pic_height = 16 * h->mb_height >> MB_FIELD;

     int ysh;

     if (mx & 7)

@@ -525,12 +677,12 @@ static av_always_inline void mc_dir_part(H264Context *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,

+        h->vdsp.emulated_edge_mc(h->edge_emu_buffer,

                                  src_y - (2 << pixel_shift) - 2 * h->mb_linesize,

                                  h->mb_linesize,

                                  16 + 5, 16 + 5 /*FIXME*/, full_mx - 2,

                                  full_my - 2, pic_width, pic_height);

-        src_y = s->edge_emu_buffer + (2 << pixel_shift) + 2 * h->mb_linesize;

+        src_y = h->edge_emu_buffer + (2 << pixel_shift) + 2 * h->mb_linesize;

         emu   = 1;

     }

@@ -538,19 +690,19 @@ static av_always_inline void mc_dir_part(H264Context *h, Picture *pic,

     if (!square)

         qpix_op[luma_xy](dest_y + delta, src_y + delta, h->mb_linesize);

-    if (CONFIG_GRAY && s->flags & CODEC_FLAG_GRAY)

+    if (CONFIG_GRAY && h->flags & CODEC_FLAG_GRAY)

         return;

     if (chroma_idc == 3 /* yuv444 */) {

         src_cb = pic->f.data[1] + offset;

         if (emu) {

-            s->vdsp.emulated_edge_mc(s->edge_emu_buffer,

+            h->vdsp.emulated_edge_mc(h->edge_emu_buffer,

                                      src_cb - (2 << pixel_shift) - 2 * h->mb_linesize,

                                      h->mb_linesize,

                                      16 + 5, 16 + 5 /*FIXME*/,

                                      full_mx - 2, full_my - 2,

                                      pic_width, pic_height);

-            src_cb = s->edge_emu_buffer + (2 << pixel_shift) + 2 * h->mb_linesize;

+            src_cb = h->edge_emu_buffer + (2 << pixel_shift) + 2 * h->mb_linesize;

         }

         qpix_op[luma_xy](dest_cb, src_cb, h->mb_linesize); // FIXME try variable height perhaps?

         if (!square)

@@ -558,13 +710,13 @@ static av_always_inline void mc_dir_part(H264Context *h, Picture *pic,

         src_cr = pic->f.data[2] + offset;

         if (emu) {

-            s->vdsp.emulated_edge_mc(s->edge_emu_buffer,

+            h->vdsp.emulated_edge_mc(h->edge_emu_buffer,

                                      src_cr - (2 << pixel_shift) - 2 * h->mb_linesize,

                                      h->mb_linesize,

                                      16 + 5, 16 + 5 /*FIXME*/,

                                      full_mx - 2, full_my - 2,

                                      pic_width, pic_height);

-            src_cr = s->edge_emu_buffer + (2 << pixel_shift) + 2 * h->mb_linesize;

+            src_cr = h->edge_emu_buffer + (2 << pixel_shift) + 2 * h->mb_linesize;

         }

         qpix_op[luma_xy](dest_cr, src_cr, h->mb_linesize); // FIXME try variable height perhaps?

         if (!square)

@@ -575,7 +727,7 @@ static av_always_inline void mc_dir_part(H264Context *h, Picture *pic,

     ysh = 3 - (chroma_idc == 2 /* yuv422 */);

     if (chroma_idc == 1 /* yuv420 */ && MB_FIELD) {

         // chroma offset when predicting from a field of opposite parity

-        my  += 2 * ((s->mb_y & 1) - (pic->f.reference - 1));

+        my  += 2 * ((h->mb_y & 1) - (pic->f.reference - 1));

         emu |= (my >> 3) < 0 || (my >> 3) + 8 >= (pic_height >> 1);

     }

@@ -585,20 +737,20 @@ static av_always_inline void mc_dir_part(H264Context *h, Picture *pic,

              (my >> ysh) * h->mb_uvlinesize;

     if (emu) {

-        s->vdsp.emulated_edge_mc(s->edge_emu_buffer, src_cb, h->mb_uvlinesize,

+        h->vdsp.emulated_edge_mc(h->edge_emu_buffer, src_cb, h->mb_uvlinesize,

                                  9, 8 * chroma_idc + 1, (mx >> 3), (my >> ysh),

                                  pic_width >> 1, pic_height >> (chroma_idc == 1 /* yuv420 */));

-        src_cb = s->edge_emu_buffer;

+        src_cb = h->edge_emu_buffer;

     }

     chroma_op(dest_cb, src_cb, h->mb_uvlinesize,

               height >> (chroma_idc == 1 /* yuv420 */),

               mx & 7, (my << (chroma_idc == 2 /* yuv422 */)) & 7);

     if (emu) {

-        s->vdsp.emulated_edge_mc(s->edge_emu_buffer, src_cr, h->mb_uvlinesize,

+        h->vdsp.emulated_edge_mc(h->edge_emu_buffer, src_cr, h->mb_uvlinesize,

                                  9, 8 * chroma_idc + 1, (mx >> 3), (my >> ysh),

                                  pic_width >> 1, pic_height >> (chroma_idc == 1 /* yuv420 */));

-        src_cr = s->edge_emu_buffer;

+        src_cr = h->edge_emu_buffer;

     }

     chroma_op(dest_cr, src_cr, h->mb_uvlinesize, height >> (chroma_idc == 1 /* yuv420 */),

               mx & 7, (my << (chroma_idc == 2 /* yuv422 */)) & 7);

@@ -616,7 +768,6 @@ static av_always_inline void mc_part_std(H264Context *h, int n, int square,

                                          int list0, int list1,

                                          int pixel_shift, int chroma_idc)

 {

-    MpegEncContext *const s       = &h->s;

     qpel_mc_func *qpix_op         = qpix_put;

     h264_chroma_mc_func chroma_op = chroma_put;

@@ -631,8 +782,8 @@ static av_always_inline void mc_part_std(H264Context *h, int n, int square,

         dest_cb += (x_offset << pixel_shift) + y_offset * h->mb_uvlinesize;

         dest_cr += (x_offset << pixel_shift) + y_offset * h->mb_uvlinesize;

     }

-    x_offset += 8 * s->mb_x;

-    y_offset += 8 * (s->mb_y >> MB_FIELD);

+    x_offset += 8 * h->mb_x;

+    y_offset += 8 * (h->mb_y >> MB_FIELD);

     if (list0) {

         Picture *ref = &h->ref_list[0][h->ref_cache[0][scan8[n]]];

@@ -666,7 +817,6 @@ static av_always_inline void mc_part_weighted(H264Context *h, int n, int square,

                                               int list0, int list1,

                                               int pixel_shift, int chroma_idc)

 {

-    MpegEncContext *const s = &h->s;

     int chroma_height;

     dest_y += (2 * x_offset << pixel_shift) + 2 * y_offset * h->mb_linesize;

@@ -685,8 +835,8 @@ static av_always_inline void mc_part_weighted(H264Context *h, int n, int square,

         dest_cb      += (x_offset << pixel_shift) + y_offset * h->mb_uvlinesize;

         dest_cr      += (x_offset << pixel_shift) + y_offset * h->mb_uvlinesize;

     }

-    x_offset += 8 * s->mb_x;

-    y_offset += 8 * (s->mb_y >> MB_FIELD);

+    x_offset += 8 * h->mb_x;

+    y_offset += 8 * (h->mb_y >> MB_FIELD);

     if (list0 && list1) {

         /* don't optimize for luma-only case, since B-frames usually

@@ -707,7 +857,7 @@ static av_always_inline void mc_part_weighted(H264Context *h, int n, int square,

                     pixel_shift, chroma_idc);

         if (h->use_weight == 2) {

-            int weight0 = h->implicit_weight[refn0][refn1][s->mb_y & 1];

+            int weight0 = h->implicit_weight[refn0][refn1][h->mb_y & 1];

             int weight1 = 64 - weight0;

             luma_weight_avg(dest_y, tmp_y, h->mb_linesize,

                             height, 5, weight0, weight1, 0);

@@ -765,24 +915,23 @@ static av_always_inline void prefetch_motion(H264Context *h, int list,

 {

     /* fetch pixels for estimated mv 4 macroblocks ahead

      * optimized for 64byte cache lines */

-    MpegEncContext *const s = &h->s;

     const int refn = h->ref_cache[list][scan8[0]];

     if (refn >= 0) {

-        const int mx  = (h->mv_cache[list][scan8[0]][0] >> 2) + 16 * s->mb_x + 8;

-        const int my  = (h->mv_cache[list][scan8[0]][1] >> 2) + 16 * s->mb_y;

+        const int mx  = (h->mv_cache[list][scan8[0]][0] >> 2) + 16 * h->mb_x + 8;

+        const int my  = (h->mv_cache[list][scan8[0]][1] >> 2) + 16 * h->mb_y;

         uint8_t **src = h->ref_list[list][refn].f.data;

         int off       = (mx << pixel_shift) +

-                        (my + (s->mb_x & 3) * 4) * h->mb_linesize +

+                        (my + (h->mb_x & 3) * 4) * h->mb_linesize +

                         (64 << pixel_shift);

-        s->vdsp.prefetch(src[0] + off, s->linesize, 4);

+        h->vdsp.prefetch(src[0] + off, h->linesize, 4);

         if (chroma_idc == 3 /* yuv444 */) {

-            s->vdsp.prefetch(src[1] + off, s->linesize, 4);

-            s->vdsp.prefetch(src[2] + off, s->linesize, 4);

+            h->vdsp.prefetch(src[1] + off, h->linesize, 4);

+            h->vdsp.prefetch(src[2] + off, h->linesize, 4);

         } else {

             off = ((mx >> 1) << pixel_shift) +

-                  ((my >> 1) + (s->mb_x & 7)) * s->uvlinesize +

+                  ((my >> 1) + (h->mb_x & 7)) * h->uvlinesize +

                   (64 << pixel_shift);

-            s->vdsp.prefetch(src[1] + off, src[2] - src[1], 2);

+            h->vdsp.prefetch(src[1] + off, src[2] - src[1], 2);

         }

     }

 }

@@ -806,6 +955,18 @@ static void free_tables(H264Context *h, int free_rbsp)

     av_freep(&h->mb2b_xy);

     av_freep(&h->mb2br_xy);

+    if (free_rbsp) {

+        for (i = 0; i < h->picture_count && !h->avctx->internal->is_copy; i++)

+            free_picture(h, &h->DPB[i]);

+        av_freep(&h->DPB);

+        h->picture_count = 0;

+    } else if (h->DPB) {

+        for (i = 0; i < h->picture_count; i++)

+            h->DPB[i].needs_realloc = 1;

+    }

+

+    h->cur_pic_ptr = NULL;

+

     for (i = 0; i < MAX_THREADS; i++) {

         hx = h->thread_context[i];

         if (!hx)

@@ -813,6 +974,15 @@ static void free_tables(H264Context *h, int free_rbsp)

         av_freep(&hx->top_borders[1]);

         av_freep(&hx->top_borders[0]);

         av_freep(&hx->bipred_scratchpad);

+        av_freep(&hx->edge_emu_buffer);

+        av_freep(&hx->dc_val_base);

+        av_freep(&hx->me.scratchpad);

+        av_freep(&hx->er.mb_index2xy);

+        av_freep(&hx->er.error_status_table);

+        av_freep(&hx->er.er_temp_buffer);

+        av_freep(&hx->er.mbintra_table);

+        av_freep(&hx->er.mbskip_table);

+

         if (free_rbsp) {

             av_freep(&hx->rbsp_buffer[1]);

             av_freep(&hx->rbsp_buffer[0]);

@@ -896,50 +1066,59 @@ static void init_dequant_tables(H264Context *h)

 int ff_h264_alloc_tables(H264Context *h)

 {

-    MpegEncContext *const s = &h->s;

-    const int big_mb_num    = s->mb_stride * (s->mb_height + 1);

-    const int row_mb_num    = s->mb_stride * 2 * s->avctx->thread_count;

-    int x, y;

+    const int big_mb_num    = h->mb_stride * (h->mb_height + 1);

+    const int row_mb_num    = h->mb_stride * 2 * h->avctx->thread_count;

+    int x, y, i;

-    FF_ALLOCZ_OR_GOTO(h->s.avctx, h->intra4x4_pred_mode,

+    FF_ALLOCZ_OR_GOTO(h->avctx, h->intra4x4_pred_mode,

                       row_mb_num * 8 * sizeof(uint8_t), fail)

-    FF_ALLOCZ_OR_GOTO(h->s.avctx, h->non_zero_count,

+    FF_ALLOCZ_OR_GOTO(h->avctx, h->non_zero_count,

                       big_mb_num * 48 * sizeof(uint8_t), fail)

-    FF_ALLOCZ_OR_GOTO(h->s.avctx, h->slice_table_base,

-                      (big_mb_num + s->mb_stride) * sizeof(*h->slice_table_base), fail)

-    FF_ALLOCZ_OR_GOTO(h->s.avctx, h->cbp_table,

+    FF_ALLOCZ_OR_GOTO(h->avctx, h->slice_table_base,

+                      (big_mb_num + h->mb_stride) * sizeof(*h->slice_table_base), fail)

+    FF_ALLOCZ_OR_GOTO(h->avctx, h->cbp_table,

                       big_mb_num * sizeof(uint16_t), fail)

-    FF_ALLOCZ_OR_GOTO(h->s.avctx, h->chroma_pred_mode_table,

+    FF_ALLOCZ_OR_GOTO(h->avctx, h->chroma_pred_mode_table,

                       big_mb_num * sizeof(uint8_t), fail)

-    FF_ALLOCZ_OR_GOTO(h->s.avctx, h->mvd_table[0],

+    FF_ALLOCZ_OR_GOTO(h->avctx, h->mvd_table[0],

                       16 * row_mb_num * sizeof(uint8_t), fail);

-    FF_ALLOCZ_OR_GOTO(h->s.avctx, h->mvd_table[1],

+    FF_ALLOCZ_OR_GOTO(h->avctx, h->mvd_table[1],

                       16 * row_mb_num * sizeof(uint8_t), fail);

-    FF_ALLOCZ_OR_GOTO(h->s.avctx, h->direct_table,

+    FF_ALLOCZ_OR_GOTO(h->avctx, h->direct_table,

                       4 * big_mb_num * sizeof(uint8_t), fail);

-    FF_ALLOCZ_OR_GOTO(h->s.avctx, h->list_counts,

+    FF_ALLOCZ_OR_GOTO(h->avctx, h->list_counts,

                       big_mb_num * sizeof(uint8_t), fail)

     memset(h->slice_table_base, -1,

-           (big_mb_num + s->mb_stride) * sizeof(*h->slice_table_base));

-    h->slice_table = h->slice_table_base + s->mb_stride * 2 + 1;

+           (big_mb_num + h->mb_stride) * sizeof(*h->slice_table_base));

+    h->slice_table = h->slice_table_base + h->mb_stride * 2 + 1;

-    FF_ALLOCZ_OR_GOTO(h->s.avctx, h->mb2b_xy,

+    FF_ALLOCZ_OR_GOTO(h->avctx, h->mb2b_xy,

                       big_mb_num * sizeof(uint32_t), fail);

-    FF_ALLOCZ_OR_GOTO(h->s.avctx, h->mb2br_xy,

+    FF_ALLOCZ_OR_GOTO(h->avctx, h->mb2br_xy,

                       big_mb_num * sizeof(uint32_t), fail);

-    for (y = 0; y < s->mb_height; y++)

-        for (x = 0; x < s->mb_width; x++) {

-            const int mb_xy = x + y * s->mb_stride;

+    for (y = 0; y < h->mb_height; y++)

+        for (x = 0; x < h->mb_width; x++) {

+            const int mb_xy = x + y * h->mb_stride;

             const int b_xy  = 4 * x + 4 * y * h->b_stride;

             h->mb2b_xy[mb_xy]  = b_xy;

-            h->mb2br_xy[mb_xy] = 8 * (FMO ? mb_xy : (mb_xy % (2 * s->mb_stride)));

+            h->mb2br_xy[mb_xy] = 8 * (FMO ? mb_xy : (mb_xy % (2 * h->mb_stride)));

         }

     if (!h->dequant4_coeff[0])

         init_dequant_tables(h);

+    if (!h->DPB) {

+        h->picture_count = MAX_PICTURE_COUNT * FFMAX(1, h->avctx->thread_count);

+        h->DPB = av_mallocz_array(h->picture_count, sizeof(*h->DPB));

+        if (!h->DPB)

+            return AVERROR(ENOMEM);

+        for (i = 0; i < h->picture_count; i++)

+            avcodec_get_frame_defaults(&h->DPB[i].f);

+        avcodec_get_frame_defaults(&h->cur_pic.f);

+    }

+

     return 0;

 fail:

@@ -952,20 +1131,24 @@ fail:

  */

 static void clone_tables(H264Context *dst, H264Context *src, int i)

 {

-    MpegEncContext *const s     = &src->s;

-    dst->intra4x4_pred_mode     = src->intra4x4_pred_mode + i * 8 * 2 * s->mb_stride;

+    dst->intra4x4_pred_mode     = src->intra4x4_pred_mode + i * 8 * 2 * src->mb_stride;

     dst->non_zero_count         = src->non_zero_count;

     dst->slice_table            = src->slice_table;

     dst->cbp_table              = src->cbp_table;

     dst->mb2b_xy                = src->mb2b_xy;

     dst->mb2br_xy               = src->mb2br_xy;

     dst->chroma_pred_mode_table = src->chroma_pred_mode_table;

-    dst->mvd_table[0]           = src->mvd_table[0] + i * 8 * 2 * s->mb_stride;

-    dst->mvd_table[1]           = src->mvd_table[1] + i * 8 * 2 * s->mb_stride;

+    dst->mvd_table[0]           = src->mvd_table[0] + i * 8 * 2 * src->mb_stride;

+    dst->mvd_table[1]           = src->mvd_table[1] + i * 8 * 2 * src->mb_stride;

     dst->direct_table           = src->direct_table;

     dst->list_counts            = src->list_counts;

+    dst->DPB                    = src->DPB;

+    dst->cur_pic_ptr            = src->cur_pic_ptr;

+    dst->cur_pic                = src->cur_pic;

     dst->bipred_scratchpad      = NULL;

-    ff_h264_pred_init(&dst->hpc, src->s.codec_id, src->sps.bit_depth_luma,

+    dst->edge_emu_buffer        = NULL;

+    dst->me.scratchpad          = NULL;

+    ff_h264_pred_init(&dst->hpc, src->avctx->codec_id, src->sps.bit_depth_luma,

                       src->sps.chroma_format_idc);

 }

@@ -975,10 +1158,17 @@ static void clone_tables(H264Context *dst, H264Context *src, int i)

  */

 static int context_init(H264Context *h)