static int h264_slice_header_parse(H264Context *h, H264SliceContext *sl)

{

    const SPS *sps;

    const PPS *pps;

    unsigned int first_mb_in_slice;

    unsigned int pps_id;

    int ret;

    unsigned int slice_type, tmp, i;

    int last_pic_structure, last_pic_droppable;

    int needs_reinit = 0;

    int field_pic_flag, bottom_field_flag;

    int frame_num, droppable, picture_structure;

    int mb_aff_frame = 0;



    first_mb_in_slice = get_ue_golomb(&sl->gb);



    if (first_mb_in_slice == 0) { // FIXME better field boundary detection

        if (h->current_slice && h->cur_pic_ptr && FIELD_PICTURE(h)) {

            ff_h264_field_end(h, sl, 1);

        }



        h->current_slice = 0;

        if (!h->first_field) {

            if (h->cur_pic_ptr && !h->droppable) {

                ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX,

                                          h->picture_structure == PICT_BOTTOM_FIELD);

            }

            h->cur_pic_ptr = NULL;

        }

    }



    slice_type = get_ue_golomb_31(&sl->gb);

    if (slice_type > 9) {

        av_log(h->avctx, AV_LOG_ERROR,

               "slice type %d too large at %d\n",

               slice_type, first_mb_in_slice);

        return AVERROR_INVALIDDATA;

    }

    if (slice_type > 4) {

        slice_type -= 5;

        sl->slice_type_fixed = 1;

    } else

        sl->slice_type_fixed = 0;



    slice_type         = ff_h264_golomb_to_pict_type[slice_type];

    sl->slice_type     = slice_type;

    sl->slice_type_nos = slice_type & 3;



    if (h->nal_unit_type  == NAL_IDR_SLICE &&

        sl->slice_type_nos != AV_PICTURE_TYPE_I) {

        av_log(h->avctx, AV_LOG_ERROR, "A non-intra slice in an IDR NAL unit.\n");

        return AVERROR_INVALIDDATA;

    }



    pps_id = get_ue_golomb(&sl->gb);

    if (pps_id >= MAX_PPS_COUNT) {

        av_log(h->avctx, AV_LOG_ERROR, "pps_id %u out of range\n", pps_id);

        return AVERROR_INVALIDDATA;

    }

    if (!h->ps.pps_list[pps_id]) {

        av_log(h->avctx, AV_LOG_ERROR,

               "non-existing PPS %u referenced\n",

               pps_id);

        return AVERROR_INVALIDDATA;

    }

    if (!h->setup_finished) {

        h->ps.pps = (const PPS*)h->ps.pps_list[pps_id]->data;

    } else if (h->ps.pps != (const PPS*)h->ps.pps_list[pps_id]->data) {

        av_log(h->avctx, AV_LOG_ERROR, "PPS changed between slices\n");

        return AVERROR_INVALIDDATA;

    }



    if (!h->ps.sps_list[h->ps.pps->sps_id]) {

        av_log(h->avctx, AV_LOG_ERROR,

               "non-existing SPS %u referenced\n",

               h->ps.pps->sps_id);

        return AVERROR_INVALIDDATA;

    }



    if (h->ps.sps != (const SPS*)h->ps.sps_list[h->ps.pps->sps_id]->data) {

        h->ps.sps = (SPS*)h->ps.sps_list[h->ps.pps->sps_id]->data;



        if (h->bit_depth_luma    != h->ps.sps->bit_depth_luma ||

            h->chroma_format_idc != h->ps.sps->chroma_format_idc)

            needs_reinit         = 1;

    }



    pps = h->ps.pps;

    sps = h->ps.sps;



    if (!h->setup_finished) {

        h->avctx->profile = ff_h264_get_profile(sps);

        h->avctx->level   = sps->level_idc;

        h->avctx->refs    = sps->ref_frame_count;



        if (h->mb_width  != sps->mb_width ||

            h->mb_height != sps->mb_height * (2 - sps->frame_mbs_only_flag))

            needs_reinit = 1;



        h->mb_width  = sps->mb_width;

        h->mb_height = sps->mb_height * (2 - sps->frame_mbs_only_flag);

        h->mb_num    = h->mb_width * h->mb_height;

        h->mb_stride = h->mb_width + 1;



        h->b_stride = h->mb_width * 4;



        h->chroma_y_shift = sps->chroma_format_idc <= 1; // 400 uses yuv420p



        h->width  = 16 * h->mb_width;

        h->height = 16 * h->mb_height;



        ret = init_dimensions(h);

        if (ret < 0)

            return ret;



        if (sps->video_signal_type_present_flag) {

            h->avctx->color_range = sps->full_range ? AVCOL_RANGE_JPEG

                : AVCOL_RANGE_MPEG;

            if (sps->colour_description_present_flag) {

                if (h->avctx->colorspace != sps->colorspace)

                    needs_reinit = 1;

                h->avctx->color_primaries = sps->color_primaries;

                h->avctx->color_trc       = sps->color_trc;

                h->avctx->colorspace      = sps->colorspace;

            }

        }

    }



    if (h->context_initialized && needs_reinit) {

        h->context_initialized = 0;

        if (sl != h->slice_ctx) {

            av_log(h->avctx, AV_LOG_ERROR,

                   "changing width %d -> %d / height %d -> %d on "

                   "slice %d\n",

                   h->width, h->avctx->coded_width,

                   h->height, h->avctx->coded_height,

                   h->current_slice + 1);

            return AVERROR_INVALIDDATA;

        }



        ff_h264_flush_change(h);



        if ((ret = get_pixel_format(h)) < 0)

            return ret;

        h->avctx->pix_fmt = ret;



        av_log(h->avctx, AV_LOG_INFO, "Reinit context to %dx%d, "

               "pix_fmt: %d\n", h->width, h->height, h->avctx->pix_fmt);



        if ((ret = h264_slice_header_init(h)) < 0) {

            av_log(h->avctx, AV_LOG_ERROR,

                   "h264_slice_header_init() failed\n");

            return ret;

        }

    }

    if (!h->context_initialized) {

        if (sl != h->slice_ctx) {

            av_log(h->avctx, AV_LOG_ERROR,

                   "Cannot (re-)initialize context during parallel decoding.\n");

            return AVERROR_PATCHWELCOME;

        }



        if ((ret = get_pixel_format(h)) < 0)

            return ret;

        h->avctx->pix_fmt = ret;



        if ((ret = h264_slice_header_init(h)) < 0) {

            av_log(h->avctx, AV_LOG_ERROR,

                   "h264_slice_header_init() failed\n");

            return ret;

        }

    }



    frame_num = get_bits(&sl->gb, sps->log2_max_frame_num);

    if (!h->setup_finished)

        h->poc.frame_num = frame_num;



    sl->mb_mbaff       = 0;



    last_pic_structure = h->picture_structure;

    last_pic_droppable = h->droppable;



    droppable = h->nal_ref_idc == 0;

    if (sps->frame_mbs_only_flag) {

        picture_structure = PICT_FRAME;

    } else {

        field_pic_flag = get_bits1(&sl->gb);

        if (field_pic_flag) {

            bottom_field_flag = get_bits1(&sl->gb);

            picture_structure = PICT_TOP_FIELD + bottom_field_flag;

        } else {

            picture_structure = PICT_FRAME;

            mb_aff_frame      = sps->mb_aff;

        }

    }

    if (!h->setup_finished) {

        h->droppable         = droppable;

        h->picture_structure = picture_structure;

        h->mb_aff_frame      = mb_aff_frame;

    }

    sl->mb_field_decoding_flag = h->picture_structure != PICT_FRAME;



    if (h->current_slice != 0) {

        if (last_pic_structure != picture_structure ||

            last_pic_droppable != droppable) {

            av_log(h->avctx, AV_LOG_ERROR,

                   "Changing field mode (%d -> %d) between slices is not allowed\n",

                   last_pic_structure, h->picture_structure);

            return AVERROR_INVALIDDATA;

        } else if (!h->cur_pic_ptr) {

            av_log(h->avctx, AV_LOG_ERROR,

                   "unset cur_pic_ptr on slice %d\n",

                   h->current_slice + 1);

            return AVERROR_INVALIDDATA;

        }

    } else {

        /* Shorten frame num gaps so we don't have to allocate reference

         * frames just to throw them away */

        if (h->poc.frame_num != h->poc.prev_frame_num) {

            int unwrap_prev_frame_num = h->poc.prev_frame_num;

            int max_frame_num         = 1 << sps->log2_max_frame_num;



            if (unwrap_prev_frame_num > h->poc.frame_num)

                unwrap_prev_frame_num -= max_frame_num;



            if ((h->poc.frame_num - unwrap_prev_frame_num) > sps->ref_frame_count) {

                unwrap_prev_frame_num = (h->poc.frame_num - sps->ref_frame_count) - 1;

                if (unwrap_prev_frame_num < 0)

                    unwrap_prev_frame_num += max_frame_num;



                h->poc.prev_frame_num = unwrap_prev_frame_num;

            }

        }



        /* See if we have a decoded first field looking for a pair...

         * Here, we're using that to see if we should mark previously

         * decode frames as "finished".

         * We have to do that before the "dummy" in-between frame allocation,

         * since that can modify s->current_picture_ptr. */

        if (h->first_field) {

            assert(h->cur_pic_ptr);

            assert(h->cur_pic_ptr->f->buf[0]);

            assert(h->cur_pic_ptr->reference != DELAYED_PIC_REF);



            /* figure out if we have a complementary field pair */

            if (!FIELD_PICTURE(h) || h->picture_structure == last_pic_structure) {

                /* Previous field is unmatched. Don't display it, but let it

                 * remain for reference if marked as such. */

                if (!last_pic_droppable && last_pic_structure != PICT_FRAME) {

                    ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX,

                                              last_pic_structure == PICT_TOP_FIELD);

                }

            } else {

                if (h->cur_pic_ptr->frame_num != h->poc.frame_num) {

                    /* This and previous field were reference, but had

                     * different frame_nums. Consider this field first in

                     * pair. Throw away previous field except for reference

                     * purposes. */

                    if (!last_pic_droppable && last_pic_structure != PICT_FRAME) {

                        ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX,

                                                  last_pic_structure == PICT_TOP_FIELD);

                    }

                } else {

                    /* Second field in complementary pair */

                    if (!((last_pic_structure   == PICT_TOP_FIELD &&

                           h->picture_structure == PICT_BOTTOM_FIELD) ||

                          (last_pic_structure   == PICT_BOTTOM_FIELD &&

                           h->picture_structure == PICT_TOP_FIELD))) {

                        av_log(h->avctx, AV_LOG_ERROR,

                               "Invalid field mode combination %d/%d\n",

                               last_pic_structure, h->picture_structure);

                        h->picture_structure = last_pic_structure;

                        h->droppable         = last_pic_droppable;

                        return AVERROR_INVALIDDATA;

                    } else if (last_pic_droppable != h->droppable) {

                        avpriv_request_sample(h->avctx,

                                              "Found reference and non-reference fields in the same frame, which");

                        h->picture_structure = last_pic_structure;

                        h->droppable         = last_pic_droppable;

                        return AVERROR_PATCHWELCOME;

                    }

                }

            }

        }



        while (h->poc.frame_num != h->poc.prev_frame_num &&

               h->poc.frame_num != (h->poc.prev_frame_num + 1) % (1 << sps->log2_max_frame_num)) {

            H264Picture *prev = h->short_ref_count ? h->short_ref[0] : NULL;

            av_log(h->avctx, AV_LOG_DEBUG, "Frame num gap %d %d\n",

                   h->poc.frame_num, h->poc.prev_frame_num);

            ret = initialize_cur_frame(h);

            if (ret < 0) {

                h->first_field = 0;

                return ret;

            }



            h->poc.prev_frame_num++;

            h->poc.prev_frame_num        %= 1 << sps->log2_max_frame_num;

            h->cur_pic_ptr->frame_num = h->poc.prev_frame_num;

            ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX, 0);

            ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX, 1);

            ret = ff_generate_sliding_window_mmcos(h, 1);

            if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))

                return ret;

            ret = ff_h264_execute_ref_pic_marking(h, h->mmco, h->mmco_index);

            if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))

                return ret;

            /* Error concealment: If a ref is missing, copy the previous ref

             * in its place.

             * FIXME: Avoiding a memcpy would be nice, but ref handling makes

             * many assumptions about there being no actual duplicates.

             * FIXME: This does not copy padding for out-of-frame motion

             * vectors.  Given we are concealing a lost frame, this probably

             * is not noticeable by comparison, but it should be fixed. */

            if (h->short_ref_count) {

                if (prev &&

                    h->short_ref[0]->f->width == prev->f->width &&

                    h->short_ref[0]->f->height == prev->f->height &&

                    h->short_ref[0]->f->format == prev->f->format) {

                    av_image_copy(h->short_ref[0]->f->data,

                                  h->short_ref[0]->f->linesize,

                                  (const uint8_t **)prev->f->data,

                                  prev->f->linesize,

                                  prev->f->format,

                                  h->mb_width  * 16,

                                  h->mb_height * 16);

                    h->short_ref[0]->poc = prev->poc + 2;

                }

                h->short_ref[0]->frame_num = h->poc.prev_frame_num;

            }

        }



        /* See if we have a decoded first field looking for a pair...

         * We're using that to see whether to continue decoding in that

         * frame, or to allocate a new one. */

        if (h->first_field) {

            assert(h->cur_pic_ptr);

            assert(h->cur_pic_ptr->f->buf[0]);

            assert(h->cur_pic_ptr->reference != DELAYED_PIC_REF);



            /* figure out if we have a complementary field pair */

            if (!FIELD_PICTURE(h) || h->picture_structure == last_pic_structure) {

                /* Previous field is unmatched. Don't display it, but let it

                 * remain for reference if marked as such. */

                h->cur_pic_ptr = NULL;

                h->first_field = FIELD_PICTURE(h);

            } else {

                if (h->cur_pic_ptr->frame_num != h->poc.frame_num) {

                    /* This and the previous field had different frame_nums.

                     * Consider this field first in pair. Throw away previous

                     * one except for reference purposes. */

                    h->first_field = 1;

                    h->cur_pic_ptr = NULL;

                } else {

                    /* Second field in complementary pair */

                    h->first_field = 0;

                }

            }

        } else {

            /* Frame or first field in a potentially complementary pair */

            h->first_field = FIELD_PICTURE(h);

        }



        if (!FIELD_PICTURE(h) || h->first_field) {

            if (h264_frame_start(h) < 0) {

                h->first_field = 0;

                return AVERROR_INVALIDDATA;

            }

        } else {

            release_unused_pictures(h, 0);

        }

    }



    assert(h->mb_num == h->mb_width * h->mb_height);

    if (first_mb_in_slice << FIELD_OR_MBAFF_PICTURE(h) >= h->mb_num ||

        first_mb_in_slice >= h->mb_num) {

        av_log(h->avctx, AV_LOG_ERROR, "first_mb_in_slice overflow\n");

        return AVERROR_INVALIDDATA;

    }

    sl->resync_mb_x = sl->mb_x =  first_mb_in_slice % h->mb_width;

    sl->resync_mb_y = sl->mb_y = (first_mb_in_slice / h->mb_width) <<

                                 FIELD_OR_MBAFF_PICTURE(h);

    if (h->picture_structure == PICT_BOTTOM_FIELD)

        sl->resync_mb_y = sl->mb_y = sl->mb_y + 1;

    assert(sl->mb_y < h->mb_height);



    if (h->picture_structure == PICT_FRAME) {

        h->curr_pic_num = h->poc.frame_num;

        h->max_pic_num  = 1 << sps->log2_max_frame_num;

    } else {

        h->curr_pic_num = 2 * h->poc.frame_num + 1;

        h->max_pic_num  = 1 << (sps->log2_max_frame_num + 1);

    }



    if (h->nal_unit_type == NAL_IDR_SLICE)

        get_ue_golomb(&sl->gb); /* idr_pic_id */



    if (sps->poc_type == 0) {

        int poc_lsb = get_bits(&sl->gb, sps->log2_max_poc_lsb);



        if (!h->setup_finished)

            h->poc.poc_lsb = poc_lsb;



        if (pps->pic_order_present == 1 && h->picture_structure == PICT_FRAME) {

            int delta_poc_bottom = get_se_golomb(&sl->gb);

            if (!h->setup_finished)

                h->poc.delta_poc_bottom = delta_poc_bottom;

        }

    }



    if (sps->poc_type == 1 && !sps->delta_pic_order_always_zero_flag) {

        int delta_poc = get_se_golomb(&sl->gb);



        if (!h->setup_finished)

            h->poc.delta_poc[0] = delta_poc;



        if (pps->pic_order_present == 1 && h->picture_structure == PICT_FRAME) {

            delta_poc = get_se_golomb(&sl->gb);



            if (!h->setup_finished)

                h->poc.delta_poc[1] = delta_poc;

        }

    }



    if (!h->setup_finished)

        ff_h264_init_poc(h->cur_pic_ptr->field_poc, &h->cur_pic_ptr->poc,

                         sps, &h->poc, h->picture_structure, h->nal_ref_idc);



    if (pps->redundant_pic_cnt_present)

        sl->redundant_pic_count = get_ue_golomb(&sl->gb);



    if (sl->slice_type_nos == AV_PICTURE_TYPE_B)

        sl->direct_spatial_mv_pred = get_bits1(&sl->gb);



    ret = ff_h264_parse_ref_count(&sl->list_count, sl->ref_count,

                                  &sl->gb, pps, sl->slice_type_nos,

                                  h->picture_structure);

    if (ret < 0)

        return ret;



    if (sl->slice_type_nos != AV_PICTURE_TYPE_I) {

       ret = ff_h264_decode_ref_pic_list_reordering(h, sl);

       if (ret < 0) {

           sl->ref_count[1] = sl->ref_count[0] = 0;

           return ret;

       }

    }



    sl->pwt.use_weight = 0;

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

        sl->pwt.luma_weight_flag[i]   = 0;

        sl->pwt.chroma_weight_flag[i] = 0;

    }

    if ((pps->weighted_pred && sl->slice_type_nos == AV_PICTURE_TYPE_P) ||

        (pps->weighted_bipred_idc == 1 &&

         sl->slice_type_nos == AV_PICTURE_TYPE_B))

        ff_h264_pred_weight_table(&sl->gb, sps, sl->ref_count,

                                  sl->slice_type_nos, &sl->pwt);



    // If frame-mt is enabled, only update mmco tables for the first slice

    // in a field. Subsequent slices can temporarily clobber h->mmco_index

    // or h->mmco, which will cause ref list mix-ups and decoding errors

    // further down the line. This may break decoding if the first slice is

    // corrupt, thus we only do this if frame-mt is enabled.

    if (h->nal_ref_idc) {

        ret = ff_h264_decode_ref_pic_marking(h, &sl->gb,

                                             !(h->avctx->active_thread_type & FF_THREAD_FRAME) ||

                                             h->current_slice == 0);

        if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))

            return AVERROR_INVALIDDATA;

    }



    if (sl->slice_type_nos != AV_PICTURE_TYPE_I && pps->cabac) {

        tmp = get_ue_golomb_31(&sl->gb);

        if (tmp > 2) {

            av_log(h->avctx, AV_LOG_ERROR, "cabac_init_idc %u overflow\n", tmp);

            return AVERROR_INVALIDDATA;

        }

        sl->cabac_init_idc = tmp;

    }



    sl->last_qscale_diff = 0;

    tmp = pps->init_qp + get_se_golomb(&sl->gb);

    if (tmp > 51 + 6 * (sps->bit_depth_luma - 8)) {

        av_log(h->avctx, AV_LOG_ERROR, "QP %u out of range\n", tmp);

        return AVERROR_INVALIDDATA;

    }

    sl->qscale       = tmp;

    sl->chroma_qp[0] = get_chroma_qp(h, 0, sl->qscale);

    sl->chroma_qp[1] = get_chroma_qp(h, 1, sl->qscale);

    // FIXME qscale / qp ... stuff

    if (sl->slice_type == AV_PICTURE_TYPE_SP)

        get_bits1(&sl->gb); /* sp_for_switch_flag */

    if (sl->slice_type == AV_PICTURE_TYPE_SP ||

        sl->slice_type == AV_PICTURE_TYPE_SI)

        get_se_golomb(&sl->gb); /* slice_qs_delta */



    sl->deblocking_filter     = 1;

    sl->slice_alpha_c0_offset = 0;

    sl->slice_beta_offset     = 0;

    if (pps->deblocking_filter_parameters_present) {

        tmp = get_ue_golomb_31(&sl->gb);

        if (tmp > 2) {

            av_log(h->avctx, AV_LOG_ERROR,

                   "deblocking_filter_idc %u out of range\n", tmp);

            return AVERROR_INVALIDDATA;

        }

        sl->deblocking_filter = tmp;

        if (sl->deblocking_filter < 2)

            sl->deblocking_filter ^= 1;  // 1<->0



        if (sl->deblocking_filter) {

            sl->slice_alpha_c0_offset = get_se_golomb(&sl->gb) * 2;

            sl->slice_beta_offset     = get_se_golomb(&sl->gb) * 2;

            if (sl->slice_alpha_c0_offset >  12 ||

                sl->slice_alpha_c0_offset < -12 ||

                sl->slice_beta_offset >  12     ||

                sl->slice_beta_offset < -12) {

                av_log(h->avctx, AV_LOG_ERROR,

                       "deblocking filter parameters %d %d out of range\n",

                       sl->slice_alpha_c0_offset, sl->slice_beta_offset);

                return AVERROR_INVALIDDATA;

            }

        }

    }



    return 0;

}

static int h264_slice_header_parse(H264Context *h, H264SliceContext *sl)

{

    const SPS *sps;

    const PPS *pps;

    unsigned int first_mb_in_slice;

    unsigned int pps_id;

    int ret;

    unsigned int slice_type, tmp, i;

    int last_pic_structure, last_pic_droppable;

    int needs_reinit = 0;

    int field_pic_flag, bottom_field_flag;

    int frame_num, droppable, picture_structure;

    int mb_aff_frame = 0;



    first_mb_in_slice = get_ue_golomb(&sl->gb);



    if (first_mb_in_slice == 0) { 

        if (h->current_slice && h->cur_pic_ptr && FIELD_PICTURE(h)) {

            ff_h264_field_end(h, sl, 1);

        }



        h->current_slice = 0;

        if (!h->first_field) {

            if (h->cur_pic_ptr && !h->droppable) {

                ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX,

                                          h->picture_structure == PICT_BOTTOM_FIELD);

            }

            h->cur_pic_ptr = NULL;

        }

    }



    slice_type = get_ue_golomb_31(&sl->gb);

    if (slice_type > 9) {

        av_log(h->avctx, AV_LOG_ERROR,

               "slice type %d too large at %d\n",

               slice_type, first_mb_in_slice);

        return AVERROR_INVALIDDATA;

    }

    if (slice_type > 4) {

        slice_type -= 5;

        sl->slice_type_fixed = 1;

    } else

        sl->slice_type_fixed = 0;



    slice_type         = ff_h264_golomb_to_pict_type[slice_type];

    sl->slice_type     = slice_type;

    sl->slice_type_nos = slice_type & 3;



    if (h->nal_unit_type  == NAL_IDR_SLICE &&

        sl->slice_type_nos != AV_PICTURE_TYPE_I) {

        av_log(h->avctx, AV_LOG_ERROR, "A non-intra slice in an IDR NAL unit.\n");

        return AVERROR_INVALIDDATA;

    }



    pps_id = get_ue_golomb(&sl->gb);

    if (pps_id >= MAX_PPS_COUNT) {

        av_log(h->avctx, AV_LOG_ERROR, "pps_id %u out of range\n", pps_id);

        return AVERROR_INVALIDDATA;

    }

    if (!h->ps.pps_list[pps_id]) {

        av_log(h->avctx, AV_LOG_ERROR,

               "non-existing PPS %u referenced\n",

               pps_id);

        return AVERROR_INVALIDDATA;

    }

    if (!h->setup_finished) {

        h->ps.pps = (const PPS*)h->ps.pps_list[pps_id]->data;

    } else if (h->ps.pps != (const PPS*)h->ps.pps_list[pps_id]->data) {

        av_log(h->avctx, AV_LOG_ERROR, "PPS changed between slices\n");

        return AVERROR_INVALIDDATA;

    }



    if (!h->ps.sps_list[h->ps.pps->sps_id]) {

        av_log(h->avctx, AV_LOG_ERROR,

               "non-existing SPS %u referenced\n",

               h->ps.pps->sps_id);

        return AVERROR_INVALIDDATA;

    }



    if (h->ps.sps != (const SPS*)h->ps.sps_list[h->ps.pps->sps_id]->data) {

        h->ps.sps = (SPS*)h->ps.sps_list[h->ps.pps->sps_id]->data;



        if (h->bit_depth_luma    != h->ps.sps->bit_depth_luma ||

            h->chroma_format_idc != h->ps.sps->chroma_format_idc)

            needs_reinit         = 1;

    }



    pps = h->ps.pps;

    sps = h->ps.sps;



    if (!h->setup_finished) {

        h->avctx->profile = ff_h264_get_profile(sps);

        h->avctx->level   = sps->level_idc;

        h->avctx->refs    = sps->ref_frame_count;



        if (h->mb_width  != sps->mb_width ||

            h->mb_height != sps->mb_height * (2 - sps->frame_mbs_only_flag))

            needs_reinit = 1;



        h->mb_width  = sps->mb_width;

        h->mb_height = sps->mb_height * (2 - sps->frame_mbs_only_flag);

        h->mb_num    = h->mb_width * h->mb_height;

        h->mb_stride = h->mb_width + 1;



        h->b_stride = h->mb_width * 4;



        h->chroma_y_shift = sps->chroma_format_idc <= 1; 



        h->width  = 16 * h->mb_width;

        h->height = 16 * h->mb_height;



        ret = init_dimensions(h);

        if (ret < 0)

            return ret;



        if (sps->video_signal_type_present_flag) {

            h->avctx->color_range = sps->full_range ? AVCOL_RANGE_JPEG

                : AVCOL_RANGE_MPEG;

            if (sps->colour_description_present_flag) {

                if (h->avctx->colorspace != sps->colorspace)

                    needs_reinit = 1;

                h->avctx->color_primaries = sps->color_primaries;

                h->avctx->color_trc       = sps->color_trc;

                h->avctx->colorspace      = sps->colorspace;

            }

        }

    }



    if (h->context_initialized && needs_reinit) {

        h->context_initialized = 0;

        if (sl != h->slice_ctx) {

            av_log(h->avctx, AV_LOG_ERROR,

                   "changing width %d -> %d / height %d -> %d on "

                   "slice %d\n",

                   h->width, h->avctx->coded_width,

                   h->height, h->avctx->coded_height,

                   h->current_slice + 1);

            return AVERROR_INVALIDDATA;

        }



        ff_h264_flush_change(h);



        if ((ret = get_pixel_format(h)) < 0)

            return ret;

        h->avctx->pix_fmt = ret;



        av_log(h->avctx, AV_LOG_INFO, "Reinit context to %dx%d, "

               "pix_fmt: %d\n", h->width, h->height, h->avctx->pix_fmt);



        if ((ret = h264_slice_header_init(h)) < 0) {

            av_log(h->avctx, AV_LOG_ERROR,

                   "h264_slice_header_init() failed\n");

            return ret;

        }

    }

    if (!h->context_initialized) {

        if (sl != h->slice_ctx) {

            av_log(h->avctx, AV_LOG_ERROR,

                   "Cannot (re-)initialize context during parallel decoding.\n");

            return AVERROR_PATCHWELCOME;

        }



        if ((ret = get_pixel_format(h)) < 0)

            return ret;

        h->avctx->pix_fmt = ret;



        if ((ret = h264_slice_header_init(h)) < 0) {

            av_log(h->avctx, AV_LOG_ERROR,

                   "h264_slice_header_init() failed\n");

            return ret;

        }

    }



    frame_num = get_bits(&sl->gb, sps->log2_max_frame_num);

    if (!h->setup_finished)

        h->poc.frame_num = frame_num;



    sl->mb_mbaff       = 0;



    last_pic_structure = h->picture_structure;

    last_pic_droppable = h->droppable;



    droppable = h->nal_ref_idc == 0;

    if (sps->frame_mbs_only_flag) {

        picture_structure = PICT_FRAME;

    } else {

        field_pic_flag = get_bits1(&sl->gb);

        if (field_pic_flag) {

            bottom_field_flag = get_bits1(&sl->gb);

            picture_structure = PICT_TOP_FIELD + bottom_field_flag;

        } else {

            picture_structure = PICT_FRAME;

            mb_aff_frame      = sps->mb_aff;

        }

    }

    if (!h->setup_finished) {

        h->droppable         = droppable;

        h->picture_structure = picture_structure;

        h->mb_aff_frame      = mb_aff_frame;

    }

    sl->mb_field_decoding_flag = h->picture_structure != PICT_FRAME;



    if (h->current_slice != 0) {

        if (last_pic_structure != picture_structure ||

            last_pic_droppable != droppable) {

            av_log(h->avctx, AV_LOG_ERROR,

                   "Changing field mode (%d -> %d) between slices is not allowed\n",

                   last_pic_structure, h->picture_structure);

            return AVERROR_INVALIDDATA;

        } else if (!h->cur_pic_ptr) {

            av_log(h->avctx, AV_LOG_ERROR,

                   "unset cur_pic_ptr on slice %d\n",

                   h->current_slice + 1);

            return AVERROR_INVALIDDATA;

        }

    } else {

        



        if (h->poc.frame_num != h->poc.prev_frame_num) {

            int unwrap_prev_frame_num = h->poc.prev_frame_num;

            int max_frame_num         = 1 << sps->log2_max_frame_num;



            if (unwrap_prev_frame_num > h->poc.frame_num)

                unwrap_prev_frame_num -= max_frame_num;



            if ((h->poc.frame_num - unwrap_prev_frame_num) > sps->ref_frame_count) {

                unwrap_prev_frame_num = (h->poc.frame_num - sps->ref_frame_count) - 1;

                if (unwrap_prev_frame_num < 0)

                    unwrap_prev_frame_num += max_frame_num;



                h->poc.prev_frame_num = unwrap_prev_frame_num;

            }

        }



        









        if (h->first_field) {

            assert(h->cur_pic_ptr);

            assert(h->cur_pic_ptr->f->buf[0]);

            assert(h->cur_pic_ptr->reference != DELAYED_PIC_REF);



            

            if (!FIELD_PICTURE(h) || h->picture_structure == last_pic_structure) {

                



                if (!last_pic_droppable && last_pic_structure != PICT_FRAME) {

                    ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX,

                                              last_pic_structure == PICT_TOP_FIELD);

                }

            } else {

                if (h->cur_pic_ptr->frame_num != h->poc.frame_num) {

                    







                    if (!last_pic_droppable && last_pic_structure != PICT_FRAME) {

                        ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX,

                                                  last_pic_structure == PICT_TOP_FIELD);

                    }

                } else {

                    

                    if (!((last_pic_structure   == PICT_TOP_FIELD &&

                           h->picture_structure == PICT_BOTTOM_FIELD) ||

                          (last_pic_structure   == PICT_BOTTOM_FIELD &&

                           h->picture_structure == PICT_TOP_FIELD))) {

                        av_log(h->avctx, AV_LOG_ERROR,

                               "Invalid field mode combination %d/%d\n",

                               last_pic_structure, h->picture_structure);

                        h->picture_structure = last_pic_structure;

                        h->droppable         = last_pic_droppable;

                        return AVERROR_INVALIDDATA;

                    } else if (last_pic_droppable != h->droppable) {

                        avpriv_request_sample(h->avctx,

                                              "Found reference and non-reference fields in the same frame, which");

                        h->picture_structure = last_pic_structure;

                        h->droppable         = last_pic_droppable;

                        return AVERROR_PATCHWELCOME;

                    }

                }

            }

        }



        while (h->poc.frame_num != h->poc.prev_frame_num &&

               h->poc.frame_num != (h->poc.prev_frame_num + 1) % (1 << sps->log2_max_frame_num)) {

            H264Picture *prev = h->short_ref_count ? h->short_ref[0] : NULL;

            av_log(h->avctx, AV_LOG_DEBUG, "Frame num gap %d %d\n",

                   h->poc.frame_num, h->poc.prev_frame_num);

            ret = initialize_cur_frame(h);

            if (ret < 0) {

                h->first_field = 0;

                return ret;

            }



            h->poc.prev_frame_num++;

            h->poc.prev_frame_num        %= 1 << sps->log2_max_frame_num;

            h->cur_pic_ptr->frame_num = h->poc.prev_frame_num;

            ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX, 0);

            ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX, 1);

            ret = ff_generate_sliding_window_mmcos(h, 1);

            if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))

                return ret;

            ret = ff_h264_execute_ref_pic_marking(h, h->mmco, h->mmco_index);

            if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))

                return ret;

            













            if (h->short_ref_count) {

                if (prev &&

                    h->short_ref[0]->f->width == prev->f->width &&

                    h->short_ref[0]->f->height == prev->f->height &&

                    h->short_ref[0]->f->format == prev->f->format) {

                    av_image_copy(h->short_ref[0]->f->data,

                                  h->short_ref[0]->f->linesize,

                                  (const uint8_t **)prev->f->data,

                                  prev->f->linesize,

                                  prev->f->format,

                                  h->mb_width  * 16,

                                  h->mb_height * 16);

                    h->short_ref[0]->poc = prev->poc + 2;

                }

                h->short_ref[0]->frame_num = h->poc.prev_frame_num;

            }

        }



        





        if (h->first_field) {

            assert(h->cur_pic_ptr);

            assert(h->cur_pic_ptr->f->buf[0]);

            assert(h->cur_pic_ptr->reference != DELAYED_PIC_REF);



            

            if (!FIELD_PICTURE(h) || h->picture_structure == last_pic_structure) {

                



                h->cur_pic_ptr = NULL;

                h->first_field = FIELD_PICTURE(h);

            } else {

                if (h->cur_pic_ptr->frame_num != h->poc.frame_num) {

                    





                    h->first_field = 1;

                    h->cur_pic_ptr = NULL;

                } else {

                    

                    h->first_field = 0;

                }

            }

        } else {

            

            h->first_field = FIELD_PICTURE(h);

        }



        if (!FIELD_PICTURE(h) || h->first_field) {

            if (h264_frame_start(h) < 0) {

                h->first_field = 0;

                return AVERROR_INVALIDDATA;

            }

        } else {

            release_unused_pictures(h, 0);

        }

    }



    assert(h->mb_num == h->mb_width * h->mb_height);

    if (first_mb_in_slice << FIELD_OR_MBAFF_PICTURE(h) >= h->mb_num ||

        first_mb_in_slice >= h->mb_num) {

        av_log(h->avctx, AV_LOG_ERROR, "first_mb_in_slice overflow\n");

        return AVERROR_INVALIDDATA;

    }

    sl->resync_mb_x = sl->mb_x =  first_mb_in_slice % h->mb_width;

    sl->resync_mb_y = sl->mb_y = (first_mb_in_slice / h->mb_width) <<

                                 FIELD_OR_MBAFF_PICTURE(h);

    if (h->picture_structure == PICT_BOTTOM_FIELD)

        sl->resync_mb_y = sl->mb_y = sl->mb_y + 1;

    assert(sl->mb_y < h->mb_height);



    if (h->picture_structure == PICT_FRAME) {

        h->curr_pic_num = h->poc.frame_num;

        h->max_pic_num  = 1 << sps->log2_max_frame_num;

    } else {

        h->curr_pic_num = 2 * h->poc.frame_num + 1;

        h->max_pic_num  = 1 << (sps->log2_max_frame_num + 1);

    }



    if (h->nal_unit_type == NAL_IDR_SLICE)

        get_ue_golomb(&sl->gb); 



    if (sps->poc_type == 0) {

        int poc_lsb = get_bits(&sl->gb, sps->log2_max_poc_lsb);



        if (!h->setup_finished)

            h->poc.poc_lsb = poc_lsb;



        if (pps->pic_order_present == 1 && h->picture_structure == PICT_FRAME) {

            int delta_poc_bottom = get_se_golomb(&sl->gb);

            if (!h->setup_finished)

                h->poc.delta_poc_bottom = delta_poc_bottom;

        }

    }



    if (sps->poc_type == 1 && !sps->delta_pic_order_always_zero_flag) {

        int delta_poc = get_se_golomb(&sl->gb);



        if (!h->setup_finished)

            h->poc.delta_poc[0] = delta_poc;



        if (pps->pic_order_present == 1 && h->picture_structure == PICT_FRAME) {

            delta_poc = get_se_golomb(&sl->gb);



            if (!h->setup_finished)

                h->poc.delta_poc[1] = delta_poc;

        }

    }



    if (!h->setup_finished)

        ff_h264_init_poc(h->cur_pic_ptr->field_poc, &h->cur_pic_ptr->poc,

                         sps, &h->poc, h->picture_structure, h->nal_ref_idc);



    if (pps->redundant_pic_cnt_present)

        sl->redundant_pic_count = get_ue_golomb(&sl->gb);



    if (sl->slice_type_nos == AV_PICTURE_TYPE_B)

        sl->direct_spatial_mv_pred = get_bits1(&sl->gb);



    ret = ff_h264_parse_ref_count(&sl->list_count, sl->ref_count,

                                  &sl->gb, pps, sl->slice_type_nos,

                                  h->picture_structure);

    if (ret < 0)

        return ret;



    if (sl->slice_type_nos != AV_PICTURE_TYPE_I) {

       ret = ff_h264_decode_ref_pic_list_reordering(h, sl);

       if (ret < 0) {

           sl->ref_count[1] = sl->ref_count[0] = 0;

           return ret;

       }

    }



    sl->pwt.use_weight = 0;

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

        sl->pwt.luma_weight_flag[i]   = 0;

        sl->pwt.chroma_weight_flag[i] = 0;

    }

    if ((pps->weighted_pred && sl->slice_type_nos == AV_PICTURE_TYPE_P) ||

        (pps->weighted_bipred_idc == 1 &&

         sl->slice_type_nos == AV_PICTURE_TYPE_B))

        ff_h264_pred_weight_table(&sl->gb, sps, sl->ref_count,

                                  sl->slice_type_nos, &sl->pwt);



    

    

    

    

    

    if (h->nal_ref_idc) {

        ret = ff_h264_decode_ref_pic_marking(h, &sl->gb,

                                             !(h->avctx->active_thread_type & FF_THREAD_FRAME) ||

                                             h->current_slice == 0);

        if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))

            return AVERROR_INVALIDDATA;

    }



    if (sl->slice_type_nos != AV_PICTURE_TYPE_I && pps->cabac) {

        tmp = get_ue_golomb_31(&sl->gb);

        if (tmp > 2) {

            av_log(h->avctx, AV_LOG_ERROR, "cabac_init_idc %u overflow\n", tmp);

            return AVERROR_INVALIDDATA;

        }

        sl->cabac_init_idc = tmp;

    }



    sl->last_qscale_diff = 0;

    tmp = pps->init_qp + get_se_golomb(&sl->gb);

    if (tmp > 51 + 6 * (sps->bit_depth_luma - 8)) {

        av_log(h->avctx, AV_LOG_ERROR, "QP %u out of range\n", tmp);

        return AVERROR_INVALIDDATA;

    }

    sl->qscale       = tmp;

    sl->chroma_qp[0] = get_chroma_qp(h, 0, sl->qscale);

    sl->chroma_qp[1] = get_chroma_qp(h, 1, sl->qscale);

    

    if (sl->slice_type == AV_PICTURE_TYPE_SP)

        get_bits1(&sl->gb); 

    if (sl->slice_type == AV_PICTURE_TYPE_SP ||

        sl->slice_type == AV_PICTURE_TYPE_SI)

        get_se_golomb(&sl->gb); 



    sl->deblocking_filter     = 1;

    sl->slice_alpha_c0_offset = 0;

    sl->slice_beta_offset     = 0;

    if (pps->deblocking_filter_parameters_present) {

        tmp = get_ue_golomb_31(&sl->gb);

        if (tmp > 2) {

            av_log(h->avctx, AV_LOG_ERROR,

                   "deblocking_filter_idc %u out of range\n", tmp);

            return AVERROR_INVALIDDATA;

        }

        sl->deblocking_filter = tmp;

        if (sl->deblocking_filter < 2)

            sl->deblocking_filter ^= 1;  



        if (sl->deblocking_filter) {

            sl->slice_alpha_c0_offset = get_se_golomb(&sl->gb) * 2;

            sl->slice_beta_offset     = get_se_golomb(&sl->gb) * 2;

            if (sl->slice_alpha_c0_offset >  12 ||

                sl->slice_alpha_c0_offset < -12 ||

                sl->slice_beta_offset >  12     ||

                sl->slice_beta_offset < -12) {

                av_log(h->avctx, AV_LOG_ERROR,

                       "deblocking filter parameters %d %d out of range\n",

                       sl->slice_alpha_c0_offset, sl->slice_beta_offset);

                return AVERROR_INVALIDDATA;

            }

        }

    }



    return 0;

}

static int FUNC_0(H264Context *VAR_0, H264SliceContext *VAR_1)

{

    const SPS *VAR_2;

    const PPS *VAR_3;

    unsigned int VAR_4;

    unsigned int VAR_5;

    int VAR_6;

    unsigned int VAR_7, VAR_8, VAR_9;

    int VAR_10, VAR_11;

    int VAR_12 = 0;

    int VAR_13, VAR_14;

    int VAR_15, VAR_16, VAR_17;

    int VAR_18 = 0;



    VAR_4 = get_ue_golomb(&VAR_1->gb);



    if (VAR_4 == 0) { 

        if (VAR_0->current_slice && VAR_0->cur_pic_ptr && FIELD_PICTURE(VAR_0)) {

            ff_h264_field_end(VAR_0, VAR_1, 1);

        }



        VAR_0->current_slice = 0;

        if (!VAR_0->first_field) {

            if (VAR_0->cur_pic_ptr && !VAR_0->VAR_16) {

                ff_thread_report_progress(&VAR_0->cur_pic_ptr->tf, INT_MAX,

                                          VAR_0->VAR_17 == PICT_BOTTOM_FIELD);

            }

            VAR_0->cur_pic_ptr = NULL;

        }

    }



    VAR_7 = get_ue_golomb_31(&VAR_1->gb);

    if (VAR_7 > 9) {

        av_log(VAR_0->avctx, AV_LOG_ERROR,

               "slice type %d too large at %d\n",

               VAR_7, VAR_4);

        return AVERROR_INVALIDDATA;

    }

    if (VAR_7 > 4) {

        VAR_7 -= 5;

        VAR_1->slice_type_fixed = 1;

    } else

        VAR_1->slice_type_fixed = 0;



    VAR_7         = ff_h264_golomb_to_pict_type[VAR_7];

    VAR_1->VAR_7     = VAR_7;

    VAR_1->slice_type_nos = VAR_7 & 3;



    if (VAR_0->nal_unit_type  == NAL_IDR_SLICE &&

        VAR_1->slice_type_nos != AV_PICTURE_TYPE_I) {

        av_log(VAR_0->avctx, AV_LOG_ERROR, "A non-intra slice in an IDR NAL unit.\n");

        return AVERROR_INVALIDDATA;

    }



    VAR_5 = get_ue_golomb(&VAR_1->gb);

    if (VAR_5 >= MAX_PPS_COUNT) {

        av_log(VAR_0->avctx, AV_LOG_ERROR, "VAR_5 %u out of range\n", VAR_5);

        return AVERROR_INVALIDDATA;

    }

    if (!VAR_0->ps.pps_list[VAR_5]) {

        av_log(VAR_0->avctx, AV_LOG_ERROR,

               "non-existing PPS %u referenced\n",

               VAR_5);

        return AVERROR_INVALIDDATA;

    }

    if (!VAR_0->setup_finished) {

        VAR_0->ps.VAR_3 = (const PPS*)VAR_0->ps.pps_list[VAR_5]->data;

    } else if (VAR_0->ps.VAR_3 != (const PPS*)VAR_0->ps.pps_list[VAR_5]->data) {

        av_log(VAR_0->avctx, AV_LOG_ERROR, "PPS changed between slices\n");

        return AVERROR_INVALIDDATA;

    }



    if (!VAR_0->ps.sps_list[VAR_0->ps.VAR_3->sps_id]) {

        av_log(VAR_0->avctx, AV_LOG_ERROR,

               "non-existing SPS %u referenced\n",

               VAR_0->ps.VAR_3->sps_id);

        return AVERROR_INVALIDDATA;

    }



    if (VAR_0->ps.VAR_2 != (const SPS*)VAR_0->ps.sps_list[VAR_0->ps.VAR_3->sps_id]->data) {

        VAR_0->ps.VAR_2 = (SPS*)VAR_0->ps.sps_list[VAR_0->ps.VAR_3->sps_id]->data;



        if (VAR_0->bit_depth_luma    != VAR_0->ps.VAR_2->bit_depth_luma ||

            VAR_0->chroma_format_idc != VAR_0->ps.VAR_2->chroma_format_idc)

            VAR_12         = 1;

    }



    VAR_3 = VAR_0->ps.VAR_3;

    VAR_2 = VAR_0->ps.VAR_2;



    if (!VAR_0->setup_finished) {

        VAR_0->avctx->profile = ff_h264_get_profile(VAR_2);

        VAR_0->avctx->level   = VAR_2->level_idc;

        VAR_0->avctx->refs    = VAR_2->ref_frame_count;



        if (VAR_0->mb_width  != VAR_2->mb_width ||

            VAR_0->mb_height != VAR_2->mb_height * (2 - VAR_2->frame_mbs_only_flag))

            VAR_12 = 1;



        VAR_0->mb_width  = VAR_2->mb_width;

        VAR_0->mb_height = VAR_2->mb_height * (2 - VAR_2->frame_mbs_only_flag);

        VAR_0->mb_num    = VAR_0->mb_width * VAR_0->mb_height;

        VAR_0->mb_stride = VAR_0->mb_width + 1;



        VAR_0->b_stride = VAR_0->mb_width * 4;



        VAR_0->chroma_y_shift = VAR_2->chroma_format_idc <= 1; 



        VAR_0->width  = 16 * VAR_0->mb_width;

        VAR_0->height = 16 * VAR_0->mb_height;



        VAR_6 = init_dimensions(VAR_0);

        if (VAR_6 < 0)

            return VAR_6;



        if (VAR_2->video_signal_type_present_flag) {

            VAR_0->avctx->color_range = VAR_2->full_range ? AVCOL_RANGE_JPEG

                : AVCOL_RANGE_MPEG;

            if (VAR_2->colour_description_present_flag) {

                if (VAR_0->avctx->colorspace != VAR_2->colorspace)

                    VAR_12 = 1;

                VAR_0->avctx->color_primaries = VAR_2->color_primaries;

                VAR_0->avctx->color_trc       = VAR_2->color_trc;

                VAR_0->avctx->colorspace      = VAR_2->colorspace;

            }

        }

    }



    if (VAR_0->context_initialized && VAR_12) {

        VAR_0->context_initialized = 0;

        if (VAR_1 != VAR_0->slice_ctx) {

            av_log(VAR_0->avctx, AV_LOG_ERROR,

                   "changing width %d -> %d / height %d -> %d on "

                   "slice %d\n",

                   VAR_0->width, VAR_0->avctx->coded_width,

                   VAR_0->height, VAR_0->avctx->coded_height,

                   VAR_0->current_slice + 1);

            return AVERROR_INVALIDDATA;

        }



        ff_h264_flush_change(VAR_0);



        if ((VAR_6 = get_pixel_format(VAR_0)) < 0)

            return VAR_6;

        VAR_0->avctx->pix_fmt = VAR_6;



        av_log(VAR_0->avctx, AV_LOG_INFO, "Reinit context to %dx%d, "

               "pix_fmt: %d\n", VAR_0->width, VAR_0->height, VAR_0->avctx->pix_fmt);



        if ((VAR_6 = h264_slice_header_init(VAR_0)) < 0) {

            av_log(VAR_0->avctx, AV_LOG_ERROR,

                   "h264_slice_header_init() failed\n");

            return VAR_6;

        }

    }

    if (!VAR_0->context_initialized) {

        if (VAR_1 != VAR_0->slice_ctx) {

            av_log(VAR_0->avctx, AV_LOG_ERROR,

                   "Cannot (re-)initialize context during parallel decoding.\n");

            return AVERROR_PATCHWELCOME;

        }



        if ((VAR_6 = get_pixel_format(VAR_0)) < 0)

            return VAR_6;

        VAR_0->avctx->pix_fmt = VAR_6;



        if ((VAR_6 = h264_slice_header_init(VAR_0)) < 0) {

            av_log(VAR_0->avctx, AV_LOG_ERROR,

                   "h264_slice_header_init() failed\n");

            return VAR_6;

        }

    }



    VAR_15 = get_bits(&VAR_1->gb, VAR_2->log2_max_frame_num);

    if (!VAR_0->setup_finished)

        VAR_0->poc.VAR_15 = VAR_15;



    VAR_1->mb_mbaff       = 0;



    VAR_10 = VAR_0->VAR_17;

    VAR_11 = VAR_0->VAR_16;



    VAR_16 = VAR_0->nal_ref_idc == 0;

    if (VAR_2->frame_mbs_only_flag) {

        VAR_17 = PICT_FRAME;

    } else {

        VAR_13 = get_bits1(&VAR_1->gb);

        if (VAR_13) {

            VAR_14 = get_bits1(&VAR_1->gb);

            VAR_17 = PICT_TOP_FIELD + VAR_14;

        } else {

            VAR_17 = PICT_FRAME;

            VAR_18      = VAR_2->mb_aff;

        }

    }

    if (!VAR_0->setup_finished) {

        VAR_0->VAR_16         = VAR_16;

        VAR_0->VAR_17 = VAR_17;

        VAR_0->VAR_18      = VAR_18;

    }

    VAR_1->mb_field_decoding_flag = VAR_0->VAR_17 != PICT_FRAME;



    if (VAR_0->current_slice != 0) {

        if (VAR_10 != VAR_17 ||

            VAR_11 != VAR_16) {

            av_log(VAR_0->avctx, AV_LOG_ERROR,

                   "Changing field mode (%d -> %d) between slices is not allowed\n",

                   VAR_10, VAR_0->VAR_17);

            return AVERROR_INVALIDDATA;

        } else if (!VAR_0->cur_pic_ptr) {

            av_log(VAR_0->avctx, AV_LOG_ERROR,

                   "unset cur_pic_ptr on slice %d\n",

                   VAR_0->current_slice + 1);

            return AVERROR_INVALIDDATA;

        }

    } else {

        



        if (VAR_0->poc.VAR_15 != VAR_0->poc.prev_frame_num) {

            int VAR_19 = VAR_0->poc.prev_frame_num;

            int VAR_20         = 1 << VAR_2->log2_max_frame_num;



            if (VAR_19 > VAR_0->poc.VAR_15)

                VAR_19 -= VAR_20;



            if ((VAR_0->poc.VAR_15 - VAR_19) > VAR_2->ref_frame_count) {

                VAR_19 = (VAR_0->poc.VAR_15 - VAR_2->ref_frame_count) - 1;

                if (VAR_19 < 0)

                    VAR_19 += VAR_20;



                VAR_0->poc.prev_frame_num = VAR_19;

            }

        }



        









        if (VAR_0->first_field) {

            assert(VAR_0->cur_pic_ptr);

            assert(VAR_0->cur_pic_ptr->f->buf[0]);

            assert(VAR_0->cur_pic_ptr->reference != DELAYED_PIC_REF);



            

            if (!FIELD_PICTURE(VAR_0) || VAR_0->VAR_17 == VAR_10) {

                



                if (!VAR_11 && VAR_10 != PICT_FRAME) {

                    ff_thread_report_progress(&VAR_0->cur_pic_ptr->tf, INT_MAX,

                                              VAR_10 == PICT_TOP_FIELD);

                }

            } else {

                if (VAR_0->cur_pic_ptr->VAR_15 != VAR_0->poc.VAR_15) {

                    







                    if (!VAR_11 && VAR_10 != PICT_FRAME) {

                        ff_thread_report_progress(&VAR_0->cur_pic_ptr->tf, INT_MAX,

                                                  VAR_10 == PICT_TOP_FIELD);

                    }

                } else {

                    

                    if (!((VAR_10   == PICT_TOP_FIELD &&

                           VAR_0->VAR_17 == PICT_BOTTOM_FIELD) ||

                          (VAR_10   == PICT_BOTTOM_FIELD &&

                           VAR_0->VAR_17 == PICT_TOP_FIELD))) {

                        av_log(VAR_0->avctx, AV_LOG_ERROR,

                               "Invalid field mode combination %d/%d\n",

                               VAR_10, VAR_0->VAR_17);

                        VAR_0->VAR_17 = VAR_10;

                        VAR_0->VAR_16         = VAR_11;

                        return AVERROR_INVALIDDATA;

                    } else if (VAR_11 != VAR_0->VAR_16) {

                        avpriv_request_sample(VAR_0->avctx,

                                              "Found reference and non-reference fields in the same frame, which");

                        VAR_0->VAR_17 = VAR_10;

                        VAR_0->VAR_16         = VAR_11;

                        return AVERROR_PATCHWELCOME;

                    }

                }

            }

        }



        while (VAR_0->poc.VAR_15 != VAR_0->poc.prev_frame_num &&

               VAR_0->poc.VAR_15 != (VAR_0->poc.prev_frame_num + 1) % (1 << VAR_2->log2_max_frame_num)) {

            H264Picture *prev = VAR_0->short_ref_count ? VAR_0->short_ref[0] : NULL;

            av_log(VAR_0->avctx, AV_LOG_DEBUG, "Frame num gap %d %d\n",

                   VAR_0->poc.VAR_15, VAR_0->poc.prev_frame_num);

            VAR_6 = initialize_cur_frame(VAR_0);

            if (VAR_6 < 0) {

                VAR_0->first_field = 0;

                return VAR_6;

            }



            VAR_0->poc.prev_frame_num++;

            VAR_0->poc.prev_frame_num        %= 1 << VAR_2->log2_max_frame_num;

            VAR_0->cur_pic_ptr->VAR_15 = VAR_0->poc.prev_frame_num;

            ff_thread_report_progress(&VAR_0->cur_pic_ptr->tf, INT_MAX, 0);

            ff_thread_report_progress(&VAR_0->cur_pic_ptr->tf, INT_MAX, 1);

            VAR_6 = ff_generate_sliding_window_mmcos(VAR_0, 1);

            if (VAR_6 < 0 && (VAR_0->avctx->err_recognition & AV_EF_EXPLODE))

                return VAR_6;

            VAR_6 = ff_h264_execute_ref_pic_marking(VAR_0, VAR_0->mmco, VAR_0->mmco_index);

            if (VAR_6 < 0 && (VAR_0->avctx->err_recognition & AV_EF_EXPLODE))

                return VAR_6;

            













            if (VAR_0->short_ref_count) {

                if (prev &&

                    VAR_0->short_ref[0]->f->width == prev->f->width &&

                    VAR_0->short_ref[0]->f->height == prev->f->height &&

                    VAR_0->short_ref[0]->f->format == prev->f->format) {

                    av_image_copy(VAR_0->short_ref[0]->f->data,

                                  VAR_0->short_ref[0]->f->linesize,

                                  (const uint8_t **)prev->f->data,

                                  prev->f->linesize,

                                  prev->f->format,

                                  VAR_0->mb_width  * 16,

                                  VAR_0->mb_height * 16);

                    VAR_0->short_ref[0]->poc = prev->poc + 2;

                }

                VAR_0->short_ref[0]->VAR_15 = VAR_0->poc.prev_frame_num;

            }

        }



        





        if (VAR_0->first_field) {

            assert(VAR_0->cur_pic_ptr);

            assert(VAR_0->cur_pic_ptr->f->buf[0]);

            assert(VAR_0->cur_pic_ptr->reference != DELAYED_PIC_REF);



            

            if (!FIELD_PICTURE(VAR_0) || VAR_0->VAR_17 == VAR_10) {

                



                VAR_0->cur_pic_ptr = NULL;

                VAR_0->first_field = FIELD_PICTURE(VAR_0);

            } else {

                if (VAR_0->cur_pic_ptr->VAR_15 != VAR_0->poc.VAR_15) {

                    





                    VAR_0->first_field = 1;

                    VAR_0->cur_pic_ptr = NULL;

                } else {

                    

                    VAR_0->first_field = 0;

                }

            }

        } else {

            

            VAR_0->first_field = FIELD_PICTURE(VAR_0);

        }



        if (!FIELD_PICTURE(VAR_0) || VAR_0->first_field) {

            if (h264_frame_start(VAR_0) < 0) {

                VAR_0->first_field = 0;

                return AVERROR_INVALIDDATA;

            }

        } else {

            release_unused_pictures(VAR_0, 0);

        }

    }



    assert(VAR_0->mb_num == VAR_0->mb_width * VAR_0->mb_height);

    if (VAR_4 << FIELD_OR_MBAFF_PICTURE(VAR_0) >= VAR_0->mb_num ||

        VAR_4 >= VAR_0->mb_num) {

        av_log(VAR_0->avctx, AV_LOG_ERROR, "VAR_4 overflow\n");

        return AVERROR_INVALIDDATA;

    }

    VAR_1->resync_mb_x = VAR_1->mb_x =  VAR_4 % VAR_0->mb_width;

    VAR_1->resync_mb_y = VAR_1->mb_y = (VAR_4 / VAR_0->mb_width) <<

                                 FIELD_OR_MBAFF_PICTURE(VAR_0);

    if (VAR_0->VAR_17 == PICT_BOTTOM_FIELD)

        VAR_1->resync_mb_y = VAR_1->mb_y = VAR_1->mb_y + 1;

    assert(VAR_1->mb_y < VAR_0->mb_height);



    if (VAR_0->VAR_17 == PICT_FRAME) {

        VAR_0->curr_pic_num = VAR_0->poc.VAR_15;

        VAR_0->max_pic_num  = 1 << VAR_2->log2_max_frame_num;

    } else {

        VAR_0->curr_pic_num = 2 * VAR_0->poc.VAR_15 + 1;

        VAR_0->max_pic_num  = 1 << (VAR_2->log2_max_frame_num + 1);

    }



    if (VAR_0->nal_unit_type == NAL_IDR_SLICE)

        get_ue_golomb(&VAR_1->gb); 



    if (VAR_2->poc_type == 0) {

        int VAR_21 = get_bits(&VAR_1->gb, VAR_2->log2_max_poc_lsb);



        if (!VAR_0->setup_finished)

            VAR_0->poc.VAR_21 = VAR_21;



        if (VAR_3->pic_order_present == 1 && VAR_0->VAR_17 == PICT_FRAME) {

            int VAR_22 = get_se_golomb(&VAR_1->gb);

            if (!VAR_0->setup_finished)

                VAR_0->poc.VAR_22 = VAR_22;

        }

    }



    if (VAR_2->poc_type == 1 && !VAR_2->delta_pic_order_always_zero_flag) {

        int VAR_23 = get_se_golomb(&VAR_1->gb);



        if (!VAR_0->setup_finished)

            VAR_0->poc.VAR_23[0] = VAR_23;



        if (VAR_3->pic_order_present == 1 && VAR_0->VAR_17 == PICT_FRAME) {

            VAR_23 = get_se_golomb(&VAR_1->gb);



            if (!VAR_0->setup_finished)

                VAR_0->poc.VAR_23[1] = VAR_23;

        }

    }



    if (!VAR_0->setup_finished)

        ff_h264_init_poc(VAR_0->cur_pic_ptr->field_poc, &VAR_0->cur_pic_ptr->poc,

                         VAR_2, &VAR_0->poc, VAR_0->VAR_17, VAR_0->nal_ref_idc);



    if (VAR_3->redundant_pic_cnt_present)

        VAR_1->redundant_pic_count = get_ue_golomb(&VAR_1->gb);



    if (VAR_1->slice_type_nos == AV_PICTURE_TYPE_B)

        VAR_1->direct_spatial_mv_pred = get_bits1(&VAR_1->gb);



    VAR_6 = ff_h264_parse_ref_count(&VAR_1->list_count, VAR_1->ref_count,

                                  &VAR_1->gb, VAR_3, VAR_1->slice_type_nos,

                                  VAR_0->VAR_17);

    if (VAR_6 < 0)

        return VAR_6;



    if (VAR_1->slice_type_nos != AV_PICTURE_TYPE_I) {

       VAR_6 = ff_h264_decode_ref_pic_list_reordering(VAR_0, VAR_1);

       if (VAR_6 < 0) {

           VAR_1->ref_count[1] = VAR_1->ref_count[0] = 0;

           return VAR_6;

       }

    }



    VAR_1->pwt.use_weight = 0;

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

        VAR_1->pwt.luma_weight_flag[VAR_9]   = 0;

        VAR_1->pwt.chroma_weight_flag[VAR_9] = 0;

    }

    if ((VAR_3->weighted_pred && VAR_1->slice_type_nos == AV_PICTURE_TYPE_P) ||

        (VAR_3->weighted_bipred_idc == 1 &&

         VAR_1->slice_type_nos == AV_PICTURE_TYPE_B))

        ff_h264_pred_weight_table(&VAR_1->gb, VAR_2, VAR_1->ref_count,

                                  VAR_1->slice_type_nos, &VAR_1->pwt);



    

    

    

    

    

    if (VAR_0->nal_ref_idc) {

        VAR_6 = ff_h264_decode_ref_pic_marking(VAR_0, &VAR_1->gb,

                                             !(VAR_0->avctx->active_thread_type & FF_THREAD_FRAME) ||

                                             VAR_0->current_slice == 0);

        if (VAR_6 < 0 && (VAR_0->avctx->err_recognition & AV_EF_EXPLODE))

            return AVERROR_INVALIDDATA;

    }



    if (VAR_1->slice_type_nos != AV_PICTURE_TYPE_I && VAR_3->cabac) {

        VAR_8 = get_ue_golomb_31(&VAR_1->gb);

        if (VAR_8 > 2) {

            av_log(VAR_0->avctx, AV_LOG_ERROR, "cabac_init_idc %u overflow\n", VAR_8);

            return AVERROR_INVALIDDATA;

        }

        VAR_1->cabac_init_idc = VAR_8;

    }



    VAR_1->last_qscale_diff = 0;

    VAR_8 = VAR_3->init_qp + get_se_golomb(&VAR_1->gb);

    if (VAR_8 > 51 + 6 * (VAR_2->bit_depth_luma - 8)) {

        av_log(VAR_0->avctx, AV_LOG_ERROR, "QP %u out of range\n", VAR_8);

        return AVERROR_INVALIDDATA;

    }

    VAR_1->qscale       = VAR_8;

    VAR_1->chroma_qp[0] = get_chroma_qp(VAR_0, 0, VAR_1->qscale);

    VAR_1->chroma_qp[1] = get_chroma_qp(VAR_0, 1, VAR_1->qscale);

    

    if (VAR_1->VAR_7 == AV_PICTURE_TYPE_SP)

        get_bits1(&VAR_1->gb); 

    if (VAR_1->VAR_7 == AV_PICTURE_TYPE_SP ||

        VAR_1->VAR_7 == AV_PICTURE_TYPE_SI)

        get_se_golomb(&VAR_1->gb); 



    VAR_1->deblocking_filter     = 1;

    VAR_1->slice_alpha_c0_offset = 0;

    VAR_1->slice_beta_offset     = 0;

    if (VAR_3->deblocking_filter_parameters_present) {

        VAR_8 = get_ue_golomb_31(&VAR_1->gb);

        if (VAR_8 > 2) {

            av_log(VAR_0->avctx, AV_LOG_ERROR,

                   "deblocking_filter_idc %u out of range\n", VAR_8);

            return AVERROR_INVALIDDATA;

        }

        VAR_1->deblocking_filter = VAR_8;

        if (VAR_1->deblocking_filter < 2)

            VAR_1->deblocking_filter ^= 1;  



        if (VAR_1->deblocking_filter) {

            VAR_1->slice_alpha_c0_offset = get_se_golomb(&VAR_1->gb) * 2;

            VAR_1->slice_beta_offset     = get_se_golomb(&VAR_1->gb) * 2;

            if (VAR_1->slice_alpha_c0_offset >  12 ||

                VAR_1->slice_alpha_c0_offset < -12 ||

                VAR_1->slice_beta_offset >  12     ||

                VAR_1->slice_beta_offset < -12) {

                av_log(VAR_0->avctx, AV_LOG_ERROR,

                       "deblocking filter parameters %d %d out of range\n",

                       VAR_1->slice_alpha_c0_offset, VAR_1->slice_beta_offset);

                return AVERROR_INVALIDDATA;

            }

        }

    }



    return 0;

}

static int FUNC_0(H264Context *VAR_0, H264SliceContext *VAR_1)
{ const SPS *VAR_2; const PPS *VAR_3; unsigned int VAR_4; unsigned int VAR_5; int VAR_6; unsigned int VAR_7, VAR_8, VAR_9; int VAR_10, VAR_11; int VAR_12 = 0; int VAR_13, VAR_14; int VAR_15, VAR_16, VAR_17; int VAR_18 = 0; VAR_4 = get_ue_golomb(&VAR_1->gb); if (VAR_4 == 0) { if (VAR_0->current_slice && VAR_0->cur_pic_ptr && FIELD_PICTURE(VAR_0)) { ff_h264_field_end(VAR_0, VAR_1, 1); } VAR_0->current_slice = 0; if (!VAR_0->first_field) { if (VAR_0->cur_pic_ptr && !VAR_0->VAR_16) { ff_thread_report_progress(&VAR_0->cur_pic_ptr->tf, INT_MAX,
VAR_0->VAR_17 == PICT_BOTTOM_FIELD); } VAR_0->cur_pic_ptr = NULL; } } VAR_7 = get_ue_golomb_31(&VAR_1->gb); if (VAR_7 > 9) { av_log(VAR_0->avctx, AV_LOG_ERROR,
"slice type %d too large at %d\n",
VAR_7, VAR_4); return AVERROR_INVALIDDATA; } if (VAR_7 > 4) { VAR_7 -= 5; VAR_1->slice_type_fixed = 1; } else VAR_1->slice_type_fixed = 0; VAR_7         = ff_h264_golomb_to_pict_type[VAR_7]; VAR_1->VAR_7     = VAR_7; VAR_1->slice_type_nos = VAR_7 & 3; if (VAR_0->nal_unit_type  == NAL_IDR_SLICE &&
VAR_1->slice_type_nos != AV_PICTURE_TYPE_I) { av_log(VAR_0->avctx, AV_LOG_ERROR, "A non-intra slice in an IDR NAL unit.\n"); return AVERROR_INVALIDDATA; } VAR_5 = get_ue_golomb(&VAR_1->gb); if (VAR_5 >= MAX_PPS_COUNT) { av_log(VAR_0->avctx, AV_LOG_ERROR, "VAR_5 %u out of range\n", VAR_5); return AVERROR_INVALIDDATA; } if (!VAR_0->ps.pps_list[VAR_5]) { av_log(VAR_0->avctx, AV_LOG_ERROR,
"non-existing PPS %u referenced\n",
VAR_5); return AVERROR_INVALIDDATA; } if (!VAR_0->setup_finished) { VAR_0->ps.VAR_3 = (const PPS*)VAR_0->ps.pps_list[VAR_5]->data; } else if (VAR_0->ps.VAR_3 != (const PPS*)VAR_0->ps.pps_list[VAR_5]->data) { av_log(VAR_0->avctx, AV_LOG_ERROR, "PPS changed between slices\n"); return AVERROR_INVALIDDATA; } if (!VAR_0->ps.sps_list[VAR_0->ps.VAR_3->sps_id]) { av_log(VAR_0->avctx, AV_LOG_ERROR,
"non-existing SPS %u referenced\n",
VAR_0->ps.VAR_3->sps_id); return AVERROR_INVALIDDATA; } if (VAR_0->ps.VAR_2 != (const SPS*)VAR_0->ps.sps_list[VAR_0->ps.VAR_3->sps_id]->data) { VAR_0->ps.VAR_2 = (SPS*)VAR_0->ps.sps_list[VAR_0->ps.VAR_3->sps_id]->data; if (VAR_0->bit_depth_luma    != VAR_0->ps.VAR_2->bit_depth_luma ||
VAR_0->chroma_format_idc != VAR_0->ps.VAR_2->chroma_format_idc)
VAR_12         = 1; } VAR_3 = VAR_0->ps.VAR_3; VAR_2 = VAR_0->ps.VAR_2; if (!VAR_0->setup_finished) { VAR_0->avctx->profile = ff_h264_get_profile(VAR_2); VAR_0->avctx->level   = VAR_2->level_idc; VAR_0->avctx->refs    = VAR_2->ref_frame_count; if (VAR_0->mb_width  != VAR_2->mb_width ||
VAR_0->mb_height != VAR_2->mb_height * (2 - VAR_2->frame_mbs_only_flag))
VAR_12 = 1; VAR_0->mb_width  = VAR_2->mb_width; VAR_0->mb_height = VAR_2->mb_height * (2 - VAR_2->frame_mbs_only_flag); VAR_0->mb_num    = VAR_0->mb_width * VAR_0->mb_height; VAR_0->mb_stride = VAR_0->mb_width + 1; VAR_0->b_stride = VAR_0->mb_width * 4; VAR_0->chroma_y_shift = VAR_2->chroma_format_idc <= 1; VAR_0->width  = 16 * VAR_0->mb_width; VAR_0->height = 16 * VAR_0->mb_height; VAR_6 = init_dimensions(VAR_0); if (VAR_6 < 0)
return VAR_6; if (VAR_2->video_signal_type_present_flag) { VAR_0->avctx->color_range = VAR_2->full_range ? AVCOL_RANGE_JPEG
: AVCOL_RANGE_MPEG; if (VAR_2->colour_description_present_flag) { if (VAR_0->avctx->colorspace != VAR_2->colorspace)
VAR_12 = 1; VAR_0->avctx->color_primaries = VAR_2->color_primaries; VAR_0->avctx->color_trc       = VAR_2->color_trc; VAR_0->avctx->colorspace      = VAR_2->colorspace; } } } if (VAR_0->context_initialized && VAR_12) { VAR_0->context_initialized = 0; if (VAR_1 != VAR_0->slice_ctx) { av_log(VAR_0->avctx, AV_LOG_ERROR,
"changing width %d -> %d / height %d -> %d on "
"slice %d\n",
VAR_0->width, VAR_0->avctx->coded_width,
VAR_0->height, VAR_0->avctx->coded_height,
VAR_0->current_slice + 1); return AVERROR_INVALIDDATA; } ff_h264_flush_change(VAR_0); if ((VAR_6 = get_pixel_format(VAR_0)) < 0)
return VAR_6; VAR_0->avctx->pix_fmt = VAR_6; av_log(VAR_0->avctx, AV_LOG_INFO, "Reinit context to %dx%d, "
"pix_fmt: %d\n", VAR_0->width, VAR_0->height, VAR_0->avctx->pix_fmt); if ((VAR_6 = h264_slice_header_init(VAR_0)) < 0) { av_log(VAR_0->avctx, AV_LOG_ERROR,
"h264_slice_header_init() failed\n"); return VAR_6; } } if (!VAR_0->context_initialized) { if (VAR_1 != VAR_0->slice_ctx) { av_log(VAR_0->avctx, AV_LOG_ERROR,
"Cannot (re-)initialize context during parallel decoding.\n"); return AVERROR_PATCHWELCOME; } if ((VAR_6 = get_pixel_format(VAR_0)) < 0)
return VAR_6; VAR_0->avctx->pix_fmt = VAR_6; if ((VAR_6 = h264_slice_header_init(VAR_0)) < 0) { av_log(VAR_0->avctx, AV_LOG_ERROR,
"h264_slice_header_init() failed\n"); return VAR_6; } } VAR_15 = get_bits(&VAR_1->gb, VAR_2->log2_max_frame_num); if (!VAR_0->setup_finished)
VAR_0->poc.VAR_15 = VAR_15; VAR_1->mb_mbaff       = 0; VAR_10 = VAR_0->VAR_17; VAR_11 = VAR_0->VAR_16; VAR_16 = VAR_0->nal_ref_idc == 0; if (VAR_2->frame_mbs_only_flag) { VAR_17 = PICT_FRAME; } else { VAR_13 = get_bits1(&VAR_1->gb); if (VAR_13) { VAR_14 = get_bits1(&VAR_1->gb); VAR_17 = PICT_TOP_FIELD + VAR_14; } else { VAR_17 = PICT_FRAME; VAR_18      = VAR_2->mb_aff; } } if (!VAR_0->setup_finished) { VAR_0->VAR_16         = VAR_16; VAR_0->VAR_17 = VAR_17; VAR_0->VAR_18      = VAR_18; } VAR_1->mb_field_decoding_flag = VAR_0->VAR_17 != PICT_FRAME; if (VAR_0->current_slice != 0) { if (VAR_10 != VAR_17 ||
VAR_11 != VAR_16) { av_log(VAR_0->avctx, AV_LOG_ERROR,
"Changing field mode (%d -> %d) between slices is not allowed\n",
VAR_10, VAR_0->VAR_17); return AVERROR_INVALIDDATA; } else if (!VAR_0->cur_pic_ptr) { av_log(VAR_0->avctx, AV_LOG_ERROR,
"unset cur_pic_ptr on slice %d\n",
VAR_0->current_slice + 1); return AVERROR_INVALIDDATA; } } else { if (VAR_0->poc.VAR_15 != VAR_0->poc.prev_frame_num) { int VAR_19 = VAR_0->poc.prev_frame_num; int VAR_20         = 1 << VAR_2->log2_max_frame_num; if (VAR_19 > VAR_0->poc.VAR_15)
VAR_19 -= VAR_20; if ((VAR_0->poc.VAR_15 - VAR_19) > VAR_2->ref_frame_count) { VAR_19 = (VAR_0->poc.VAR_15 - VAR_2->ref_frame_count) - 1; if (VAR_19 < 0)
VAR_19 += VAR_20; VAR_0->poc.prev_frame_num = VAR_19; } } if (VAR_0->first_field) { assert(VAR_0->cur_pic_ptr); assert(VAR_0->cur_pic_ptr->f->buf[0]); assert(VAR_0->cur_pic_ptr->reference != DELAYED_PIC_REF); if (!FIELD_PICTURE(VAR_0) || VAR_0->VAR_17 == VAR_10) { if (!VAR_11 && VAR_10 != PICT_FRAME) { ff_thread_report_progress(&VAR_0->cur_pic_ptr->tf, INT_MAX,
VAR_10 == PICT_TOP_FIELD); } } else { if (VAR_0->cur_pic_ptr->VAR_15 != VAR_0->poc.VAR_15) { if (!VAR_11 && VAR_10 != PICT_FRAME) { ff_thread_report_progress(&VAR_0->cur_pic_ptr->tf, INT_MAX,
VAR_10 == PICT_TOP_FIELD); } } else { if (!((VAR_10   == PICT_TOP_FIELD &&
VAR_0->VAR_17 == PICT_BOTTOM_FIELD) ||
(VAR_10   == PICT_BOTTOM_FIELD &&
VAR_0->VAR_17 == PICT_TOP_FIELD))) { av_log(VAR_0->avctx, AV_LOG_ERROR,
"Invalid field mode combination %d/%d\n",
VAR_10, VAR_0->VAR_17); VAR_0->VAR_17 = VAR_10; VAR_0->VAR_16         = VAR_11; return AVERROR_INVALIDDATA; } else if (VAR_11 != VAR_0->VAR_16) { avpriv_request_sample(VAR_0->avctx,
"Found reference and non-reference fields in the same frame, which"); VAR_0->VAR_17 = VAR_10; VAR_0->VAR_16         = VAR_11; return AVERROR_PATCHWELCOME; } } } } while (VAR_0->poc.VAR_15 != VAR_0->poc.prev_frame_num &&
VAR_0->poc.VAR_15 != (VAR_0->poc.prev_frame_num + 1) % (1 << VAR_2->log2_max_frame_num)) { H264Picture *prev = VAR_0->short_ref_count ? VAR_0->short_ref[0] : NULL; av_log(VAR_0->avctx, AV_LOG_DEBUG, "Frame num gap %d %d\n",
VAR_0->poc.VAR_15, VAR_0->poc.prev_frame_num); VAR_6 = initialize_cur_frame(VAR_0); if (VAR_6 < 0) { VAR_0->first_field = 0; return VAR_6; } VAR_0->poc.prev_frame_num++; VAR_0->poc.prev_frame_num        %= 1 << VAR_2->log2_max_frame_num; VAR_0->cur_pic_ptr->VAR_15 = VAR_0->poc.prev_frame_num; ff_thread_report_progress(&VAR_0->cur_pic_ptr->tf, INT_MAX, 0); ff_thread_report_progress(&VAR_0->cur_pic_ptr->tf, INT_MAX, 1); VAR_6 = ff_generate_sliding_window_mmcos(VAR_0, 1); if (VAR_6 < 0 && (VAR_0->avctx->err_recognition & AV_EF_EXPLODE))
return VAR_6; VAR_6 = ff_h264_execute_ref_pic_marking(VAR_0, VAR_0->mmco, VAR_0->mmco_index); if (VAR_6 < 0 && (VAR_0->avctx->err_recognition & AV_EF_EXPLODE))
return VAR_6; if (VAR_0->short_ref_count) { if (prev &&
VAR_0->short_ref[0]->f->width == prev->f->width &&
VAR_0->short_ref[0]->f->height == prev->f->height &&
VAR_0->short_ref[0]->f->format == prev->f->format) { av_image_copy(VAR_0->short_ref[0]->f->data,
VAR_0->short_ref[0]->f->linesize,
(const uint8_t **)prev->f->data,
prev->f->linesize,
prev->f->format,
VAR_0->mb_width  * 16,
VAR_0->mb_height * 16); VAR_0->short_ref[0]->poc = prev->poc + 2; } VAR_0->short_ref[0]->VAR_15 = VAR_0->poc.prev_frame_num; } } if (VAR_0->first_field) { assert(VAR_0->cur_pic_ptr); assert(VAR_0->cur_pic_ptr->f->buf[0]); assert(VAR_0->cur_pic_ptr->reference != DELAYED_PIC_REF); if (!FIELD_PICTURE(VAR_0) || VAR_0->VAR_17 == VAR_10) { VAR_0->cur_pic_ptr = NULL; VAR_0->first_field = FIELD_PICTURE(VAR_0); } else { if (VAR_0->cur_pic_ptr->VAR_15 != VAR_0->poc.VAR_15) { VAR_0->first_field = 1; VAR_0->cur_pic_ptr = NULL; } else { VAR_0->first_field = 0; } } } else { VAR_0->first_field = FIELD_PICTURE(VAR_0); } if (!FIELD_PICTURE(VAR_0) || VAR_0->first_field) { if (h264_frame_start(VAR_0) < 0) { VAR_0->first_field = 0; return AVERROR_INVALIDDATA; } } else { release_unused_pictures(VAR_0, 0); } } assert(VAR_0->mb_num == VAR_0->mb_width * VAR_0->mb_height); if (VAR_4 << FIELD_OR_MBAFF_PICTURE(VAR_0) >= VAR_0->mb_num ||
VAR_4 >= VAR_0->mb_num) { av_log(VAR_0->avctx, AV_LOG_ERROR, "VAR_4 overflow\n"); return AVERROR_INVALIDDATA; } VAR_1->resync_mb_x = VAR_1->mb_x =  VAR_4 % VAR_0->mb_width; VAR_1->resync_mb_y = VAR_1->mb_y = (VAR_4 / VAR_0->mb_width) <<
FIELD_OR_MBAFF_PICTURE(VAR_0); if (VAR_0->VAR_17 == PICT_BOTTOM_FIELD)
VAR_1->resync_mb_y = VAR_1->mb_y = VAR_1->mb_y + 1; assert(VAR_1->mb_y < VAR_0->mb_height); if (VAR_0->VAR_17 == PICT_FRAME) { VAR_0->curr_pic_num = VAR_0->poc.VAR_15; VAR_0->max_pic_num  = 1 << VAR_2->log2_max_frame_num; } else { VAR_0->curr_pic_num = 2 * VAR_0->poc.VAR_15 + 1; VAR_0->max_pic_num  = 1 << (VAR_2->log2_max_frame_num + 1); } if (VAR_0->nal_unit_type == NAL_IDR_SLICE)
get_ue_golomb(&VAR_1->gb); if (VAR_2->poc_type == 0) { int VAR_21 = get_bits(&VAR_1->gb, VAR_2->log2_max_poc_lsb); if (!VAR_0->setup_finished)
VAR_0->poc.VAR_21 = VAR_21; if (VAR_3->pic_order_present == 1 && VAR_0->VAR_17 == PICT_FRAME) { int VAR_22 = get_se_golomb(&VAR_1->gb); if (!VAR_0->setup_finished)
VAR_0->poc.VAR_22 = VAR_22; } } if (VAR_2->poc_type == 1 && !VAR_2->delta_pic_order_always_zero_flag) { int VAR_23 = get_se_golomb(&VAR_1->gb); if (!VAR_0->setup_finished)
VAR_0->poc.VAR_23[0] = VAR_23; if (VAR_3->pic_order_present == 1 && VAR_0->VAR_17 == PICT_FRAME) { VAR_23 = get_se_golomb(&VAR_1->gb); if (!VAR_0->setup_finished)
VAR_0->poc.VAR_23[1] = VAR_23; } } if (!VAR_0->setup_finished)
ff_h264_init_poc(VAR_0->cur_pic_ptr->field_poc, &VAR_0->cur_pic_ptr->poc,
VAR_2, &VAR_0->poc, VAR_0->VAR_17, VAR_0->nal_ref_idc); if (VAR_3->redundant_pic_cnt_present)
VAR_1->redundant_pic_count = get_ue_golomb(&VAR_1->gb); if (VAR_1->slice_type_nos == AV_PICTURE_TYPE_B)
VAR_1->direct_spatial_mv_pred = get_bits1(&VAR_1->gb); VAR_6 = ff_h264_parse_ref_count(&VAR_1->list_count, VAR_1->ref_count,
&VAR_1->gb, VAR_3, VAR_1->slice_type_nos,
VAR_0->VAR_17); if (VAR_6 < 0)
return VAR_6; if (VAR_1->slice_type_nos != AV_PICTURE_TYPE_I) { VAR_6 = ff_h264_decode_ref_pic_list_reordering(VAR_0, VAR_1); if (VAR_6 < 0) { VAR_1->ref_count[1] = VAR_1->ref_count[0] = 0; return VAR_6; } } VAR_1->pwt.use_weight = 0; for (VAR_9 = 0; VAR_9 < 2; VAR_9++) { VAR_1->pwt.luma_weight_flag[VAR_9]   = 0; VAR_1->pwt.chroma_weight_flag[VAR_9] = 0; } if ((VAR_3->weighted_pred && VAR_1->slice_type_nos == AV_PICTURE_TYPE_P) ||
(VAR_3->weighted_bipred_idc == 1 &&
VAR_1->slice_type_nos == AV_PICTURE_TYPE_B))
ff_h264_pred_weight_table(&VAR_1->gb, VAR_2, VAR_1->ref_count,
VAR_1->slice_type_nos, &VAR_1->pwt); if (VAR_0->nal_ref_idc) { VAR_6 = ff_h264_decode_ref_pic_marking(VAR_0, &VAR_1->gb,
!(VAR_0->avctx->active_thread_type & FF_THREAD_FRAME) ||
VAR_0->current_slice == 0); if (VAR_6 < 0 && (VAR_0->avctx->err_recognition & AV_EF_EXPLODE))
return AVERROR_INVALIDDATA; } if (VAR_1->slice_type_nos != AV_PICTURE_TYPE_I && VAR_3->cabac) { VAR_8 = get_ue_golomb_31(&VAR_1->gb); if (VAR_8 > 2) { av_log(VAR_0->avctx, AV_LOG_ERROR, "cabac_init_idc %u overflow\n", VAR_8); return AVERROR_INVALIDDATA; } VAR_1->cabac_init_idc = VAR_8; } VAR_1->last_qscale_diff = 0; VAR_8 = VAR_3->init_qp + get_se_golomb(&VAR_1->gb); if (VAR_8 > 51 + 6 * (VAR_2->bit_depth_luma - 8)) { av_log(VAR_0->avctx, AV_LOG_ERROR, "QP %u out of range\n", VAR_8); return AVERROR_INVALIDDATA; } VAR_1->qscale       = VAR_8; VAR_1->chroma_qp[0] = get_chroma_qp(VAR_0, 0, VAR_1->qscale); VAR_1->chroma_qp[1] = get_chroma_qp(VAR_0, 1, VAR_1->qscale); if (VAR_1->VAR_7 == AV_PICTURE_TYPE_SP)
get_bits1(&VAR_1->gb); if (VAR_1->VAR_7 == AV_PICTURE_TYPE_SP ||
VAR_1->VAR_7 == AV_PICTURE_TYPE_SI)
get_se_golomb(&VAR_1->gb); VAR_1->deblocking_filter     = 1; VAR_1->slice_alpha_c0_offset = 0; VAR_1->slice_beta_offset     = 0; if (VAR_3->deblocking_filter_parameters_present) { VAR_8 = get_ue_golomb_31(&VAR_1->gb); if (VAR_8 > 2) { av_log(VAR_0->avctx, AV_LOG_ERROR,
"deblocking_filter_idc %u out of range\n", VAR_8); return AVERROR_INVALIDDATA; } VAR_1->deblocking_filter = VAR_8; if (VAR_1->deblocking_filter < 2)
VAR_1->deblocking_filter ^= 1; if (VAR_1->deblocking_filter) { VAR_1->slice_alpha_c0_offset = get_se_golomb(&VAR_1->gb) * 2; VAR_1->slice_beta_offset     = get_se_golomb(&VAR_1->gb) * 2; if (VAR_1->slice_alpha_c0_offset >  12 ||
VAR_1->slice_alpha_c0_offset < -12 ||
VAR_1->slice_beta_offset >  12     ||
VAR_1->slice_beta_offset < -12) { av_log(VAR_0->avctx, AV_LOG_ERROR,
"deblocking filter parameters %d %d out of range\n",
VAR_1->slice_alpha_c0_offset, VAR_1->slice_beta_offset); return AVERROR_INVALIDDATA; } } } return 0; }