h264: deMpegEncContextize

Most of the changes are just trivial are just trivial replacements of
fields from MpegEncContext with equivalent fields in H264Context.
Everything in h264* other than h264.c are those trivial changes.

The nontrivial parts are:
1) extracting a simplified version of the frame management code from
   mpegvideo.c. We don't need last/next_picture anymore, since h264 uses
   its own more complex system already and those were set only to appease
   the mpegvideo parts.
2) some tables that need to be allocated/freed in appropriate places.
3) hwaccels -- mostly trivial replacements.
   for dxva, the draw_horiz_band() call is moved from
   ff_dxva2_common_end_frame() to per-codec end_frame() callbacks,
   because it's now different for h264 and MpegEncContext-based
   decoders.
4) svq3 -- it does not use h264 complex reference system, so I just
   added some very simplistic frame management instead and dropped the
   use of ff_h264_frame_start(). Because of this I also had to move some
   initialization code to svq3.

Additional fixes for chroma format and bit depth changes by
Janne Grunau <janne-libav@jannau.net>

Signed-off-by: Anton Khirnov <anton@khirnov.net>

1 files changed, 130 insertions, 136 deletions

diff --git a/libavcodec/h264_ps.c b/libavcodec/h264_ps.c
index 63f371c80c..e35dab21d3 100644
--- a/libavcodec/h264_ps.c
+++ b/libavcodec/h264_ps.c
@@ -121,46 +121,44 @@ static const uint8_t default_scaling8[2][64]={
 }};
 
 static inline int decode_hrd_parameters(H264Context *h, SPS *sps){
-    MpegEncContext * const s = &h->s;
     int cpb_count, i;
-    cpb_count = get_ue_golomb_31(&s->gb) + 1;
+    cpb_count = get_ue_golomb_31(&h->gb) + 1;
 
     if(cpb_count > 32U){
-        av_log(h->s.avctx, AV_LOG_ERROR, "cpb_count %d invalid\n", cpb_count);
+        av_log(h->avctx, AV_LOG_ERROR, "cpb_count %d invalid\n", cpb_count);
         return -1;
     }
 
-    get_bits(&s->gb, 4); /* bit_rate_scale */
-    get_bits(&s->gb, 4); /* cpb_size_scale */
+    get_bits(&h->gb, 4); /* bit_rate_scale */
+    get_bits(&h->gb, 4); /* cpb_size_scale */
     for(i=0; i<cpb_count; i++){
-        get_ue_golomb_long(&s->gb); /* bit_rate_value_minus1 */
-        get_ue_golomb_long(&s->gb); /* cpb_size_value_minus1 */
-        get_bits1(&s->gb);     /* cbr_flag */
+        get_ue_golomb_long(&h->gb); /* bit_rate_value_minus1 */
+        get_ue_golomb_long(&h->gb); /* cpb_size_value_minus1 */
+        get_bits1(&h->gb);     /* cbr_flag */
     }
-    sps->initial_cpb_removal_delay_length = get_bits(&s->gb, 5) + 1;
-    sps->cpb_removal_delay_length = get_bits(&s->gb, 5) + 1;
-    sps->dpb_output_delay_length = get_bits(&s->gb, 5) + 1;
-    sps->time_offset_length = get_bits(&s->gb, 5);
+    sps->initial_cpb_removal_delay_length = get_bits(&h->gb, 5) + 1;
+    sps->cpb_removal_delay_length = get_bits(&h->gb, 5) + 1;
+    sps->dpb_output_delay_length = get_bits(&h->gb, 5) + 1;
+    sps->time_offset_length = get_bits(&h->gb, 5);
     sps->cpb_cnt = cpb_count;
     return 0;
 }
 
 static inline int decode_vui_parameters(H264Context *h, SPS *sps){
-    MpegEncContext * const s = &h->s;
     int aspect_ratio_info_present_flag;
     unsigned int aspect_ratio_idc;
 
-    aspect_ratio_info_present_flag= get_bits1(&s->gb);
+    aspect_ratio_info_present_flag= get_bits1(&h->gb);
 
     if( aspect_ratio_info_present_flag ) {
-        aspect_ratio_idc= get_bits(&s->gb, 8);
+        aspect_ratio_idc= get_bits(&h->gb, 8);
         if( aspect_ratio_idc == EXTENDED_SAR ) {
-            sps->sar.num= get_bits(&s->gb, 16);
-            sps->sar.den= get_bits(&s->gb, 16);
+            sps->sar.num= get_bits(&h->gb, 16);
+            sps->sar.den= get_bits(&h->gb, 16);
         }else if(aspect_ratio_idc < FF_ARRAY_ELEMS(pixel_aspect)){
             sps->sar=  pixel_aspect[aspect_ratio_idc];
         }else{
-            av_log(h->s.avctx, AV_LOG_ERROR, "illegal aspect ratio\n");
+            av_log(h->avctx, AV_LOG_ERROR, "illegal aspect ratio\n");
             return -1;
         }
     }else{
@@ -169,20 +167,20 @@ static inline int decode_vui_parameters(H264Context *h, SPS *sps){
     }
 //            s->avctx->aspect_ratio= sar_width*s->width / (float)(s->height*sar_height);
 
-    if(get_bits1(&s->gb)){      /* overscan_info_present_flag */
-        get_bits1(&s->gb);      /* overscan_appropriate_flag */
+    if(get_bits1(&h->gb)){      /* overscan_info_present_flag */
+        get_bits1(&h->gb);      /* overscan_appropriate_flag */
     }
 
-    sps->video_signal_type_present_flag = get_bits1(&s->gb);
+    sps->video_signal_type_present_flag = get_bits1(&h->gb);
     if(sps->video_signal_type_present_flag){
-        get_bits(&s->gb, 3);    /* video_format */
-        sps->full_range = get_bits1(&s->gb); /* video_full_range_flag */
+        get_bits(&h->gb, 3);    /* video_format */
+        sps->full_range = get_bits1(&h->gb); /* video_full_range_flag */
 
-        sps->colour_description_present_flag = get_bits1(&s->gb);
+        sps->colour_description_present_flag = get_bits1(&h->gb);
         if(sps->colour_description_present_flag){
-            sps->color_primaries = get_bits(&s->gb, 8); /* colour_primaries */
-            sps->color_trc       = get_bits(&s->gb, 8); /* transfer_characteristics */
-            sps->colorspace      = get_bits(&s->gb, 8); /* matrix_coefficients */
+            sps->color_primaries = get_bits(&h->gb, 8); /* colour_primaries */
+            sps->color_trc       = get_bits(&h->gb, 8); /* transfer_characteristics */
+            sps->colorspace      = get_bits(&h->gb, 8); /* matrix_coefficients */
             if (sps->color_primaries >= AVCOL_PRI_NB)
                 sps->color_primaries  = AVCOL_PRI_UNSPECIFIED;
             if (sps->color_trc >= AVCOL_TRC_NB)
@@ -192,56 +190,56 @@ static inline int decode_vui_parameters(H264Context *h, SPS *sps){
         }
     }
 
-    if(get_bits1(&s->gb)){      /* chroma_location_info_present_flag */
-        s->avctx->chroma_sample_location = get_ue_golomb(&s->gb)+1;  /* chroma_sample_location_type_top_field */
-        get_ue_golomb(&s->gb);  /* chroma_sample_location_type_bottom_field */
+    if(get_bits1(&h->gb)){      /* chroma_location_info_present_flag */
+        h->avctx->chroma_sample_location = get_ue_golomb(&h->gb)+1;  /* chroma_sample_location_type_top_field */
+        get_ue_golomb(&h->gb);  /* chroma_sample_location_type_bottom_field */
     }
 
-    sps->timing_info_present_flag = get_bits1(&s->gb);
+    sps->timing_info_present_flag = get_bits1(&h->gb);
     if(sps->timing_info_present_flag){
-        sps->num_units_in_tick = get_bits_long(&s->gb, 32);
-        sps->time_scale = get_bits_long(&s->gb, 32);
+        sps->num_units_in_tick = get_bits_long(&h->gb, 32);
+        sps->time_scale = get_bits_long(&h->gb, 32);
         if(!sps->num_units_in_tick || !sps->time_scale){
-            av_log(h->s.avctx, AV_LOG_ERROR, "time_scale/num_units_in_tick invalid or unsupported (%d/%d)\n", sps->time_scale, sps->num_units_in_tick);
+            av_log(h->avctx, AV_LOG_ERROR, "time_scale/num_units_in_tick invalid or unsupported (%d/%d)\n", sps->time_scale, sps->num_units_in_tick);
             return -1;
         }
-        sps->fixed_frame_rate_flag = get_bits1(&s->gb);
+        sps->fixed_frame_rate_flag = get_bits1(&h->gb);
     }
 
-    sps->nal_hrd_parameters_present_flag = get_bits1(&s->gb);
+    sps->nal_hrd_parameters_present_flag = get_bits1(&h->gb);
     if(sps->nal_hrd_parameters_present_flag)
         if(decode_hrd_parameters(h, sps) < 0)
             return -1;
-    sps->vcl_hrd_parameters_present_flag = get_bits1(&s->gb);
+    sps->vcl_hrd_parameters_present_flag = get_bits1(&h->gb);
     if(sps->vcl_hrd_parameters_present_flag)
         if(decode_hrd_parameters(h, sps) < 0)
             return -1;
     if(sps->nal_hrd_parameters_present_flag || sps->vcl_hrd_parameters_present_flag)
-        get_bits1(&s->gb);     /* low_delay_hrd_flag */
-    sps->pic_struct_present_flag = get_bits1(&s->gb);
+        get_bits1(&h->gb);     /* low_delay_hrd_flag */
+    sps->pic_struct_present_flag = get_bits1(&h->gb);
 
-    sps->bitstream_restriction_flag = get_bits1(&s->gb);
+    sps->bitstream_restriction_flag = get_bits1(&h->gb);
     if(sps->bitstream_restriction_flag){
-        get_bits1(&s->gb);     /* motion_vectors_over_pic_boundaries_flag */
-        get_ue_golomb(&s->gb); /* max_bytes_per_pic_denom */
-        get_ue_golomb(&s->gb); /* max_bits_per_mb_denom */
-        get_ue_golomb(&s->gb); /* log2_max_mv_length_horizontal */
-        get_ue_golomb(&s->gb); /* log2_max_mv_length_vertical */
-        sps->num_reorder_frames= get_ue_golomb(&s->gb);
-        get_ue_golomb(&s->gb); /*max_dec_frame_buffering*/
-
-        if (get_bits_left(&s->gb) < 0) {
+        get_bits1(&h->gb);     /* motion_vectors_over_pic_boundaries_flag */
+        get_ue_golomb(&h->gb); /* max_bytes_per_pic_denom */
+        get_ue_golomb(&h->gb); /* max_bits_per_mb_denom */
+        get_ue_golomb(&h->gb); /* log2_max_mv_length_horizontal */
+        get_ue_golomb(&h->gb); /* log2_max_mv_length_vertical */
+        sps->num_reorder_frames= get_ue_golomb(&h->gb);
+        get_ue_golomb(&h->gb); /*max_dec_frame_buffering*/
+
+        if (get_bits_left(&h->gb) < 0) {
             sps->num_reorder_frames=0;
             sps->bitstream_restriction_flag= 0;
         }
 
         if(sps->num_reorder_frames > 16U /*max_dec_frame_buffering || max_dec_frame_buffering > 16*/){
-            av_log(h->s.avctx, AV_LOG_ERROR, "illegal num_reorder_frames %d\n", sps->num_reorder_frames);
+            av_log(h->avctx, AV_LOG_ERROR, "illegal num_reorder_frames %d\n", sps->num_reorder_frames);
             return -1;
         }
     }
-    if (get_bits_left(&s->gb) < 0) {
-        av_log(h->s.avctx, AV_LOG_ERROR, "Overread VUI by %d bits\n", -get_bits_left(&s->gb));
+    if (get_bits_left(&h->gb) < 0) {
+        av_log(h->avctx, AV_LOG_ERROR, "Overread VUI by %d bits\n", -get_bits_left(&h->gb));
         return AVERROR_INVALIDDATA;
     }
 
@@ -250,15 +248,14 @@ static inline int decode_vui_parameters(H264Context *h, SPS *sps){
 
 static void decode_scaling_list(H264Context *h, uint8_t *factors, int size,
                                 const uint8_t *jvt_list, const uint8_t *fallback_list){
-    MpegEncContext * const s = &h->s;
     int i, last = 8, next = 8;
     const uint8_t *scan = size == 16 ? zigzag_scan : ff_zigzag_direct;
-    if(!get_bits1(&s->gb)) /* matrix not written, we use the predicted one */
+    if(!get_bits1(&h->gb)) /* matrix not written, we use the predicted one */
         memcpy(factors, fallback_list, size*sizeof(uint8_t));
     else
     for(i=0;i<size;i++){
         if(next)
-            next = (last + get_se_golomb(&s->gb)) & 0xff;
+            next = (last + get_se_golomb(&h->gb)) & 0xff;
         if(!i && !next){ /* matrix not written, we use the preset one */
             memcpy(factors, jvt_list, size*sizeof(uint8_t));
             break;
@@ -269,7 +266,6 @@ static void decode_scaling_list(H264Context *h, uint8_t *factors, int size,
 
 static void decode_scaling_matrices(H264Context *h, SPS *sps, PPS *pps, int is_sps,
                                    uint8_t (*scaling_matrix4)[16], uint8_t (*scaling_matrix8)[64]){
-    MpegEncContext * const s = &h->s;
     int fallback_sps = !is_sps && sps->scaling_matrix_present;
     const uint8_t *fallback[4] = {
         fallback_sps ? sps->scaling_matrix4[0] : default_scaling4[0],
@@ -277,7 +273,7 @@ static void decode_scaling_matrices(H264Context *h, SPS *sps, PPS *pps, int is_s
         fallback_sps ? sps->scaling_matrix8[0] : default_scaling8[0],
         fallback_sps ? sps->scaling_matrix8[3] : default_scaling8[1]
     };
-    if(get_bits1(&s->gb)){
+    if(get_bits1(&h->gb)){
         sps->scaling_matrix_present |= is_sps;
         decode_scaling_list(h,scaling_matrix4[0],16,default_scaling4[0],fallback[0]); // Intra, Y
         decode_scaling_list(h,scaling_matrix4[1],16,default_scaling4[0],scaling_matrix4[0]); // Intra, Cr
@@ -301,23 +297,22 @@ static void decode_scaling_matrices(H264Context *h, SPS *sps, PPS *pps, int is_s
 }
 
 int ff_h264_decode_seq_parameter_set(H264Context *h){
-    MpegEncContext * const s = &h->s;
     int profile_idc, level_idc, constraint_set_flags = 0;
     unsigned int sps_id;
     int i, log2_max_frame_num_minus4;
     SPS *sps;
 
-    profile_idc= get_bits(&s->gb, 8);
-    constraint_set_flags |= get_bits1(&s->gb) << 0;   //constraint_set0_flag
-    constraint_set_flags |= get_bits1(&s->gb) << 1;   //constraint_set1_flag
-    constraint_set_flags |= get_bits1(&s->gb) << 2;   //constraint_set2_flag
-    constraint_set_flags |= get_bits1(&s->gb) << 3;   //constraint_set3_flag
-    get_bits(&s->gb, 4); // reserved
-    level_idc= get_bits(&s->gb, 8);
-    sps_id= get_ue_golomb_31(&s->gb);
+    profile_idc= get_bits(&h->gb, 8);
+    constraint_set_flags |= get_bits1(&h->gb) << 0;   //constraint_set0_flag
+    constraint_set_flags |= get_bits1(&h->gb) << 1;   //constraint_set1_flag
+    constraint_set_flags |= get_bits1(&h->gb) << 2;   //constraint_set2_flag
+    constraint_set_flags |= get_bits1(&h->gb) << 3;   //constraint_set3_flag
+    get_bits(&h->gb, 4); // reserved
+    level_idc= get_bits(&h->gb, 8);
+    sps_id= get_ue_golomb_31(&h->gb);
 
     if(sps_id >= MAX_SPS_COUNT) {
-        av_log(h->s.avctx, AV_LOG_ERROR, "sps_id (%d) out of range\n", sps_id);
+        av_log(h->avctx, AV_LOG_ERROR, "sps_id (%d) out of range\n", sps_id);
         return -1;
     }
     sps= av_mallocz(sizeof(SPS));
@@ -338,16 +333,16 @@ int ff_h264_decode_seq_parameter_set(H264Context *h){
         sps->profile_idc ==  44 || sps->profile_idc ==  83 ||
         sps->profile_idc ==  86 || sps->profile_idc == 118 ||
         sps->profile_idc == 128 || sps->profile_idc == 144) {
-        sps->chroma_format_idc= get_ue_golomb_31(&s->gb);
+        sps->chroma_format_idc= get_ue_golomb_31(&h->gb);
         if(sps->chroma_format_idc > 3) {
-            av_log(h->s.avctx, AV_LOG_ERROR, "chroma_format_idc (%u) out of range\n", sps->chroma_format_idc);
+            av_log(h->avctx, AV_LOG_ERROR, "chroma_format_idc (%u) out of range\n", sps->chroma_format_idc);
             goto fail;
         } else if(sps->chroma_format_idc == 3) {
-            sps->residual_color_transform_flag = get_bits1(&s->gb);
+            sps->residual_color_transform_flag = get_bits1(&h->gb);
         }
-        sps->bit_depth_luma   = get_ue_golomb(&s->gb) + 8;
-        sps->bit_depth_chroma = get_ue_golomb(&s->gb) + 8;
-        sps->transform_bypass = get_bits1(&s->gb);
+        sps->bit_depth_luma   = get_ue_golomb(&h->gb) + 8;
+        sps->bit_depth_chroma = get_ue_golomb(&h->gb) + 8;
+        sps->transform_bypass = get_bits1(&h->gb);
         decode_scaling_matrices(h, sps, NULL, 1, sps->scaling_matrix4, sps->scaling_matrix8);
     }else{
         sps->chroma_format_idc= 1;
@@ -355,78 +350,78 @@ int ff_h264_decode_seq_parameter_set(H264Context *h){
         sps->bit_depth_chroma = 8;
     }
 
-    log2_max_frame_num_minus4 = get_ue_golomb(&s->gb);
+    log2_max_frame_num_minus4 = get_ue_golomb(&h->gb);
     if (log2_max_frame_num_minus4 < MIN_LOG2_MAX_FRAME_NUM - 4 ||
         log2_max_frame_num_minus4 > MAX_LOG2_MAX_FRAME_NUM - 4) {
-        av_log(h->s.avctx, AV_LOG_ERROR,
+        av_log(h->avctx, AV_LOG_ERROR,
                "log2_max_frame_num_minus4 out of range (0-12): %d\n",
                log2_max_frame_num_minus4);
         goto fail;
     }
     sps->log2_max_frame_num = log2_max_frame_num_minus4 + 4;
 
-    sps->poc_type= get_ue_golomb_31(&s->gb);
+    sps->poc_type= get_ue_golomb_31(&h->gb);
 
     if(sps->poc_type == 0){ //FIXME #define
-        sps->log2_max_poc_lsb= get_ue_golomb(&s->gb) + 4;
+        sps->log2_max_poc_lsb= get_ue_golomb(&h->gb) + 4;
     } else if(sps->poc_type == 1){//FIXME #define
-        sps->delta_pic_order_always_zero_flag= get_bits1(&s->gb);
-        sps->offset_for_non_ref_pic= get_se_golomb(&s->gb);
-        sps->offset_for_top_to_bottom_field= get_se_golomb(&s->gb);
-        sps->poc_cycle_length                = get_ue_golomb(&s->gb);
+        sps->delta_pic_order_always_zero_flag= get_bits1(&h->gb);
+        sps->offset_for_non_ref_pic= get_se_golomb(&h->gb);
+        sps->offset_for_top_to_bottom_field= get_se_golomb(&h->gb);
+        sps->poc_cycle_length                = get_ue_golomb(&h->gb);
 
         if((unsigned)sps->poc_cycle_length >= FF_ARRAY_ELEMS(sps->offset_for_ref_frame)){
-            av_log(h->s.avctx, AV_LOG_ERROR, "poc_cycle_length overflow %u\n", sps->poc_cycle_length);
+            av_log(h->avctx, AV_LOG_ERROR, "poc_cycle_length overflow %u\n", sps->poc_cycle_length);
             goto fail;
         }
 
         for(i=0; i<sps->poc_cycle_length; i++)
-            sps->offset_for_ref_frame[i]= get_se_golomb(&s->gb);
+            sps->offset_for_ref_frame[i]= get_se_golomb(&h->gb);
     }else if(sps->poc_type != 2){
-        av_log(h->s.avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type);
+        av_log(h->avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type);
         goto fail;
     }
 
-    sps->ref_frame_count= get_ue_golomb_31(&s->gb);
+    sps->ref_frame_count= get_ue_golomb_31(&h->gb);
     if(sps->ref_frame_count > MAX_PICTURE_COUNT-2 || sps->ref_frame_count >= 32U){
-        av_log(h->s.avctx, AV_LOG_ERROR, "too many reference frames\n");
+        av_log(h->avctx, AV_LOG_ERROR, "too many reference frames\n");
         goto fail;
     }
-    sps->gaps_in_frame_num_allowed_flag= get_bits1(&s->gb);
-    sps->mb_width = get_ue_golomb(&s->gb) + 1;
-    sps->mb_height= get_ue_golomb(&s->gb) + 1;
+    sps->gaps_in_frame_num_allowed_flag= get_bits1(&h->gb);
+    sps->mb_width = get_ue_golomb(&h->gb) + 1;
+    sps->mb_height= get_ue_golomb(&h->gb) + 1;
     if((unsigned)sps->mb_width >= INT_MAX/16 || (unsigned)sps->mb_height >= INT_MAX/16 ||
-       av_image_check_size(16*sps->mb_width, 16*sps->mb_height, 0, h->s.avctx)){
-        av_log(h->s.avctx, AV_LOG_ERROR, "mb_width/height overflow\n");
+       av_image_check_size(16*sps->mb_width, 16*sps->mb_height, 0, h->avctx)){
+        av_log(h->avctx, AV_LOG_ERROR, "mb_width/height overflow\n");
         goto fail;
     }
 
-    sps->frame_mbs_only_flag= get_bits1(&s->gb);
+    sps->frame_mbs_only_flag= get_bits1(&h->gb);
     if(!sps->frame_mbs_only_flag)
-        sps->mb_aff= get_bits1(&s->gb);
+        sps->mb_aff= get_bits1(&h->gb);
     else
         sps->mb_aff= 0;
 
-    sps->direct_8x8_inference_flag= get_bits1(&s->gb);
+    sps->direct_8x8_inference_flag= get_bits1(&h->gb);
     if(!sps->frame_mbs_only_flag && !sps->direct_8x8_inference_flag){
-        av_log(h->s.avctx, AV_LOG_ERROR, "This stream was generated by a broken encoder, invalid 8x8 inference\n");
+        av_log(h->avctx, AV_LOG_ERROR, "This stream was generated by a broken encoder, invalid 8x8 inference\n");
         goto fail;
     }
 
 #ifndef ALLOW_INTERLACE
     if(sps->mb_aff)
-        av_log(h->s.avctx, AV_LOG_ERROR, "MBAFF support not included; enable it at compile-time.\n");
+        av_log(h->avctx, AV_LOG_ERROR, "MBAFF support not included; enable it at compile-time.\n");
 #endif
-    sps->crop= get_bits1(&s->gb);
+    sps->crop= get_bits1(&h->gb);
     if(sps->crop){
         int crop_vertical_limit   = sps->chroma_format_idc  & 2 ? 16 : 8;
         int crop_horizontal_limit = sps->chroma_format_idc == 3 ? 16 : 8;
-        sps->crop_left  = get_ue_golomb(&s->gb);
-        sps->crop_right = get_ue_golomb(&s->gb);
-        sps->crop_top   = get_ue_golomb(&s->gb);
-        sps->crop_bottom= get_ue_golomb(&s->gb);
-        if (h->s.avctx->flags2 & CODEC_FLAG2_IGNORE_CROP) {
-            av_log(h->s.avctx, AV_LOG_DEBUG,
+        sps->crop_left  = get_ue_golomb(&h->gb);
+        sps->crop_right = get_ue_golomb(&h->gb);
+        sps->crop_top   = get_ue_golomb(&h->gb);
+        sps->crop_bottom= get_ue_golomb(&h->gb);
+        if (h->avctx->flags2 & CODEC_FLAG2_IGNORE_CROP) {
+            av_log(h->avctx, AV_LOG_DEBUG,
                    "discarding sps cropping, "
                    "original values are l:%u r:%u t:%u b:%u\n",
                    sps->crop_left,
@@ -440,10 +435,10 @@ int ff_h264_decode_seq_parameter_set(H264Context *h){
             sps->crop_bottom = 0;
         }
         if(sps->crop_left || sps->crop_top){
-            av_log(h->s.avctx, AV_LOG_ERROR, "insane cropping not completely supported, this could look slightly wrong ...\n");
+            av_log(h->avctx, AV_LOG_ERROR, "insane cropping not completely supported, this could look slightly wrong ...\n");
         }
         if(sps->crop_right >= crop_horizontal_limit || sps->crop_bottom >= crop_vertical_limit){
-            av_log(h->s.avctx, AV_LOG_ERROR, "brainfart cropping not supported, this could look slightly wrong ...\n");
+            av_log(h->avctx, AV_LOG_ERROR, "brainfart cropping not supported, this could look slightly wrong ...\n");
         }
     }else{
         sps->crop_left  =
@@ -452,7 +447,7 @@ int ff_h264_decode_seq_parameter_set(H264Context *h){
         sps->crop_bottom= 0;
     }
 
-    sps->vui_parameters_present_flag= get_bits1(&s->gb);
+    sps->vui_parameters_present_flag= get_bits1(&h->gb);
     if( sps->vui_parameters_present_flag )
         if (decode_vui_parameters(h, sps) < 0)
             goto fail;
@@ -460,9 +455,9 @@ int ff_h264_decode_seq_parameter_set(H264Context *h){
     if(!sps->sar.den)
         sps->sar.den= 1;
 
-    if(s->avctx->debug&FF_DEBUG_PICT_INFO){
+    if(h->avctx->debug&FF_DEBUG_PICT_INFO){
         static const char csp[4][5] = { "Gray", "420", "422", "444" };
-        av_log(h->s.avctx, AV_LOG_DEBUG, "sps:%u profile:%d/%d poc:%d ref:%d %dx%d %s %s crop:%d/%d/%d/%d %s %s %d/%d\n",
+        av_log(h->avctx, AV_LOG_DEBUG, "sps:%u profile:%d/%d poc:%d ref:%d %dx%d %s %s crop:%d/%d/%d/%d %s %s %d/%d\n",
                sps_id, sps->profile_idc, sps->level_idc,
                sps->poc_type,
                sps->ref_frame_count,
@@ -500,35 +495,34 @@ build_qp_table(PPS *pps, int t, int index, const int depth)
 }
 
 int ff_h264_decode_picture_parameter_set(H264Context *h, int bit_length){
-    MpegEncContext * const s = &h->s;
-    unsigned int pps_id= get_ue_golomb(&s->gb);
+    unsigned int pps_id= get_ue_golomb(&h->gb);
     PPS *pps;
     const int qp_bd_offset = 6*(h->sps.bit_depth_luma-8);
     int bits_left;
 
     if(pps_id >= MAX_PPS_COUNT) {
-        av_log(h->s.avctx, AV_LOG_ERROR, "pps_id (%d) out of range\n", pps_id);
+        av_log(h->avctx, AV_LOG_ERROR, "pps_id (%d) out of range\n", pps_id);
         return -1;
     } else if (h->sps.bit_depth_luma > 10) {
-        av_log(h->s.avctx, AV_LOG_ERROR, "Unimplemented luma bit depth=%d (max=10)\n", h->sps.bit_depth_luma);
+        av_log(h->avctx, AV_LOG_ERROR, "Unimplemented luma bit depth=%d (max=10)\n", h->sps.bit_depth_luma);
         return AVERROR_PATCHWELCOME;
     }
 
     pps= av_mallocz(sizeof(PPS));
     if(pps == NULL)
         return -1;
-    pps->sps_id= get_ue_golomb_31(&s->gb);
+    pps->sps_id= get_ue_golomb_31(&h->gb);
     if((unsigned)pps->sps_id>=MAX_SPS_COUNT || h->sps_buffers[pps->sps_id] == NULL){
-        av_log(h->s.avctx, AV_LOG_ERROR, "sps_id out of range\n");
+        av_log(h->avctx, AV_LOG_ERROR, "sps_id out of range\n");
         goto fail;
     }
 
-    pps->cabac= get_bits1(&s->gb);
-    pps->pic_order_present= get_bits1(&s->gb);
-    pps->slice_group_count= get_ue_golomb(&s->gb) + 1;
+    pps->cabac= get_bits1(&h->gb);
+    pps->pic_order_present= get_bits1(&h->gb);
+    pps->slice_group_count= get_ue_golomb(&h->gb) + 1;
     if(pps->slice_group_count > 1 ){
-        pps->mb_slice_group_map_type= get_ue_golomb(&s->gb);
-        av_log(h->s.avctx, AV_LOG_ERROR, "FMO not supported\n");
+        pps->mb_slice_group_map_type= get_ue_golomb(&h->gb);
+        av_log(h->avctx, AV_LOG_ERROR, "FMO not supported\n");
         switch(pps->mb_slice_group_map_type){
         case 0:
 #if 0
@@ -563,33 +557,33 @@ int ff_h264_decode_picture_parameter_set(H264Context *h, int bit_length){
             break;
         }
     }
-    pps->ref_count[0]= get_ue_golomb(&s->gb) + 1;
-    pps->ref_count[1]= get_ue_golomb(&s->gb) + 1;
+    pps->ref_count[0]= get_ue_golomb(&h->gb) + 1;
+    pps->ref_count[1]= get_ue_golomb(&h->gb) + 1;
     if(pps->ref_count[0]-1 > 32-1 || pps->ref_count[1]-1 > 32-1){
-        av_log(h->s.avctx, AV_LOG_ERROR, "reference overflow (pps)\n");
+        av_log(h->avctx, AV_LOG_ERROR, "reference overflow (pps)\n");
         goto fail;
     }
 
-    pps->weighted_pred= get_bits1(&s->gb);
-    pps->weighted_bipred_idc= get_bits(&s->gb, 2);
-    pps->init_qp= get_se_golomb(&s->gb) + 26 + qp_bd_offset;
-    pps->init_qs= get_se_golomb(&s->gb) + 26 + qp_bd_offset;
-    pps->chroma_qp_index_offset[0]= get_se_golomb(&s->gb);
-    pps->deblocking_filter_parameters_present= get_bits1(&s->gb);
-    pps->constrained_intra_pred= get_bits1(&s->gb);
-    pps->redundant_pic_cnt_present = get_bits1(&s->gb);
+    pps->weighted_pred= get_bits1(&h->gb);
+    pps->weighted_bipred_idc= get_bits(&h->gb, 2);
+    pps->init_qp= get_se_golomb(&h->gb) + 26 + qp_bd_offset;
+    pps->init_qs= get_se_golomb(&h->gb) + 26 + qp_bd_offset;
+    pps->chroma_qp_index_offset[0]= get_se_golomb(&h->gb);
+    pps->deblocking_filter_parameters_present= get_bits1(&h->gb);
+    pps->constrained_intra_pred= get_bits1(&h->gb);
+    pps->redundant_pic_cnt_present = get_bits1(&h->gb);
 
     pps->transform_8x8_mode= 0;
     h->dequant_coeff_pps= -1; //contents of sps/pps can change even if id doesn't, so reinit
     memcpy(pps->scaling_matrix4, h->sps_buffers[pps->sps_id]->scaling_matrix4, sizeof(pps->scaling_matrix4));
     memcpy(pps->scaling_matrix8, h->sps_buffers[pps->sps_id]->scaling_matrix8, sizeof(pps->scaling_matrix8));
 
-    bits_left = bit_length - get_bits_count(&s->gb);
+    bits_left = bit_length - get_bits_count(&h->gb);
     if (bits_left && (bits_left > 8 ||
-                      show_bits(&s->gb, bits_left) != 1 << (bits_left - 1))) {
-        pps->transform_8x8_mode= get_bits1(&s->gb);
+                      show_bits(&h->gb, bits_left) != 1 << (bits_left - 1))) {
+        pps->transform_8x8_mode= get_bits1(&h->gb);
         decode_scaling_matrices(h, h->sps_buffers[pps->sps_id], pps, 0, pps->scaling_matrix4, pps->scaling_matrix8);
-        pps->chroma_qp_index_offset[1]= get_se_golomb(&s->gb); //second_chroma_qp_index_offset
+        pps->chroma_qp_index_offset[1]= get_se_golomb(&h->gb); //second_chroma_qp_index_offset
     } else {
         pps->chroma_qp_index_offset[1]= pps->chroma_qp_index_offset[0];
     }
@@ -599,8 +593,8 @@ int ff_h264_decode_picture_parameter_set(H264Context *h, int bit_length){
     if(pps->chroma_qp_index_offset[0] != pps->chroma_qp_index_offset[1])
         pps->chroma_qp_diff= 1;
 
-    if(s->avctx->debug&FF_DEBUG_PICT_INFO){
-        av_log(h->s.avctx, AV_LOG_DEBUG, "pps:%u sps:%u %s slice_groups:%d ref:%d/%d %s qp:%d/%d/%d/%d %s %s %s %s\n",
+    if(h->avctx->debug&FF_DEBUG_PICT_INFO){
+        av_log(h->avctx, AV_LOG_DEBUG, "pps:%u sps:%u %s slice_groups:%d ref:%d/%d %s qp:%d/%d/%d/%d %s %s %s %s\n",
                pps_id, pps->sps_id,
                pps->cabac ? "CABAC" : "CAVLC",
                pps->slice_group_count,