int ff_h263_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,

                         AVPacket *avpkt)

{

    const uint8_t *buf = avpkt->data;

    int buf_size       = avpkt->size;

    MpegEncContext *s  = avctx->priv_data;

    int ret;

    int slice_ret = 0;

    AVFrame *pict = data;



    s->flags  = avctx->flags;

    s->flags2 = avctx->flags2;



    /* no supplementary picture */

    if (buf_size == 0) {

        /* special case for last picture */

        if (s->low_delay == 0 && s->next_picture_ptr) {

            if ((ret = av_frame_ref(pict, &s->next_picture_ptr->f)) < 0)

                return ret;

            s->next_picture_ptr = NULL;



            *got_frame = 1;

        }



        return 0;

    }



    if (s->flags & CODEC_FLAG_TRUNCATED) {

        int next;



        if (CONFIG_MPEG4_DECODER && s->codec_id == AV_CODEC_ID_MPEG4) {

            next = ff_mpeg4_find_frame_end(&s->parse_context, buf, buf_size);

        } else if (CONFIG_H263_DECODER && s->codec_id == AV_CODEC_ID_H263) {

            next = ff_h263_find_frame_end(&s->parse_context, buf, buf_size);

        } else if (CONFIG_H263P_DECODER && s->codec_id == AV_CODEC_ID_H263P) {

            next = ff_h263_find_frame_end(&s->parse_context, buf, buf_size);

        } else {

            av_log(s->avctx, AV_LOG_ERROR,

                   "this codec does not support truncated bitstreams\n");

            return AVERROR(ENOSYS);

        }



        if (ff_combine_frame(&s->parse_context, next, (const uint8_t **)&buf,

                             &buf_size) < 0)

            return buf_size;

    }



retry:

    if (s->divx_packed && s->bitstream_buffer_size) {

        int i;

        for(i=0; i < buf_size-3; i++) {

            if (buf[i]==0 && buf[i+1]==0 && buf[i+2]==1) {

                if (buf[i+3]==0xB0) {

                    av_log(s->avctx, AV_LOG_WARNING, "Discarding excessive bitstream in packed xvid\n");

                    s->bitstream_buffer_size = 0;

                }

                break;

            }

        }

    }



    if (s->bitstream_buffer_size && (s->divx_packed || buf_size < 20)) // divx 5.01+/xvid frame reorder

        ret = init_get_bits8(&s->gb, s->bitstream_buffer,

                             s->bitstream_buffer_size);

    else

        ret = init_get_bits8(&s->gb, buf, buf_size);



    s->bitstream_buffer_size = 0;

    if (ret < 0)

        return ret;



    if (!s->context_initialized)

        // we need the idct permutaton for reading a custom matrix

        if ((ret = ff_MPV_common_init(s)) < 0)

            return ret;



    /* We need to set current_picture_ptr before reading the header,

     * otherwise we cannot store anyting in there */

    if (s->current_picture_ptr == NULL || s->current_picture_ptr->f.data[0]) {

        int i = ff_find_unused_picture(s, 0);

        if (i < 0)

            return i;

        s->current_picture_ptr = &s->picture[i];

    }



    /* let's go :-) */

    if (CONFIG_WMV2_DECODER && s->msmpeg4_version == 5) {

        ret = ff_wmv2_decode_picture_header(s);

    } else if (CONFIG_MSMPEG4_DECODER && s->msmpeg4_version) {

        ret = ff_msmpeg4_decode_picture_header(s);

    } else if (CONFIG_MPEG4_DECODER && avctx->codec_id == AV_CODEC_ID_MPEG4) {

        if (s->avctx->extradata_size && s->picture_number == 0) {

            GetBitContext gb;



            if (init_get_bits8(&gb, s->avctx->extradata, s->avctx->extradata_size) >= 0 )

                ff_mpeg4_decode_picture_header(avctx->priv_data, &gb);

        }

        ret = ff_mpeg4_decode_picture_header(avctx->priv_data, &s->gb);

    } else if (CONFIG_H263I_DECODER && s->codec_id == AV_CODEC_ID_H263I) {

        ret = ff_intel_h263_decode_picture_header(s);

    } else if (CONFIG_FLV_DECODER && s->h263_flv) {

        ret = ff_flv_decode_picture_header(s);

    } else {

        ret = ff_h263_decode_picture_header(s);

    }



    if (ret < 0 || ret == FRAME_SKIPPED) {

        if (   s->width  != avctx->coded_width

            || s->height != avctx->coded_height) {

                av_log(s->avctx, AV_LOG_WARNING, "Reverting picture dimensions change due to header decoding failure\n");

                s->width = avctx->coded_width;

                s->height= avctx->coded_height;

        }

    }

    if (ret == FRAME_SKIPPED)

        return get_consumed_bytes(s, buf_size);



    /* skip if the header was thrashed */

    if (ret < 0) {

        av_log(s->avctx, AV_LOG_ERROR, "header damaged\n");

        return ret;

    }



    avctx->has_b_frames = !s->low_delay;



    if (ff_mpeg4_workaround_bugs(avctx) == 1)

        goto retry;



    /* After H263 & mpeg4 header decode we have the height, width,

     * and other parameters. So then we could init the picture.

     * FIXME: By the way H263 decoder is evolving it should have

     * an H263EncContext */

    if (s->width  != avctx->coded_width  ||

        s->height != avctx->coded_height ||

        s->context_reinit) {

        /* H.263 could change picture size any time */

        s->context_reinit = 0;



        ret = ff_set_dimensions(avctx, s->width, s->height);

        if (ret < 0)

            return ret;



        if ((ret = ff_MPV_common_frame_size_change(s)))

            return ret;

    }



    if (s->codec_id == AV_CODEC_ID_H263  ||

        s->codec_id == AV_CODEC_ID_H263P ||

        s->codec_id == AV_CODEC_ID_H263I)

        s->gob_index = ff_h263_get_gob_height(s);



    // for skipping the frame

    s->current_picture.f.pict_type = s->pict_type;

    s->current_picture.f.key_frame = s->pict_type == AV_PICTURE_TYPE_I;



    /* skip B-frames if we don't have reference frames */

    if (s->last_picture_ptr == NULL &&

        (s->pict_type == AV_PICTURE_TYPE_B || s->droppable))

        return get_consumed_bytes(s, buf_size);

    if ((avctx->skip_frame >= AVDISCARD_NONREF &&

         s->pict_type == AV_PICTURE_TYPE_B)    ||

        (avctx->skip_frame >= AVDISCARD_NONKEY &&

         s->pict_type != AV_PICTURE_TYPE_I)    ||

        avctx->skip_frame >= AVDISCARD_ALL)

        return get_consumed_bytes(s, buf_size);



    if (s->next_p_frame_damaged) {

        if (s->pict_type == AV_PICTURE_TYPE_B)

            return get_consumed_bytes(s, buf_size);

        else

            s->next_p_frame_damaged = 0;

    }



    if ((!s->no_rounding) || s->pict_type == AV_PICTURE_TYPE_B) {

        s->me.qpel_put = s->dsp.put_qpel_pixels_tab;

        s->me.qpel_avg = s->dsp.avg_qpel_pixels_tab;

    } else {

        s->me.qpel_put = s->dsp.put_no_rnd_qpel_pixels_tab;

        s->me.qpel_avg = s->dsp.avg_qpel_pixels_tab;

    }



    if ((ret = ff_MPV_frame_start(s, avctx)) < 0)

        return ret;



    if (!s->divx_packed && !avctx->hwaccel)

        ff_thread_finish_setup(avctx);



    if (CONFIG_MPEG4_VDPAU_DECODER && (s->avctx->codec->capabilities & CODEC_CAP_HWACCEL_VDPAU)) {

        ff_vdpau_mpeg4_decode_picture(s, s->gb.buffer, s->gb.buffer_end - s->gb.buffer);

        goto frame_end;

    }



    if (avctx->hwaccel) {

        ret = avctx->hwaccel->start_frame(avctx, s->gb.buffer,

                                          s->gb.buffer_end - s->gb.buffer);

        if (ret < 0 )

            return ret;

    }



    ff_mpeg_er_frame_start(s);



    /* the second part of the wmv2 header contains the MB skip bits which

     * are stored in current_picture->mb_type which is not available before

     * ff_MPV_frame_start() */

    if (CONFIG_WMV2_DECODER && s->msmpeg4_version == 5) {

        ret = ff_wmv2_decode_secondary_picture_header(s);

        if (ret < 0)

            return ret;

        if (ret == 1)

            goto frame_end;

    }



    /* decode each macroblock */

    s->mb_x = 0;

    s->mb_y = 0;



    slice_ret = decode_slice(s);

    while (s->mb_y < s->mb_height) {

        if (s->msmpeg4_version) {

            if (s->slice_height == 0 || s->mb_x != 0 ||

                (s->mb_y % s->slice_height) != 0 || get_bits_left(&s->gb) < 0)

                break;

        } else {

            int prev_x = s->mb_x, prev_y = s->mb_y;

            if (ff_h263_resync(s) < 0)

                break;

            if (prev_y * s->mb_width + prev_x < s->mb_y * s->mb_width + s->mb_x)

                s->er.error_occurred = 1;

        }



        if (s->msmpeg4_version < 4 && s->h263_pred)

            ff_mpeg4_clean_buffers(s);



        if (decode_slice(s) < 0)

            slice_ret = AVERROR_INVALIDDATA;

    }



    if (s->msmpeg4_version && s->msmpeg4_version < 4 &&

        s->pict_type == AV_PICTURE_TYPE_I)

        if (!CONFIG_MSMPEG4_DECODER ||

            ff_msmpeg4_decode_ext_header(s, buf_size) < 0)

            s->er.error_status_table[s->mb_num - 1] = ER_MB_ERROR;



    av_assert1(s->bitstream_buffer_size == 0);

frame_end:

    ff_er_frame_end(&s->er);



    if (avctx->hwaccel) {

        ret = avctx->hwaccel->end_frame(avctx);

        if (ret < 0)

            return ret;

    }



    ff_MPV_frame_end(s);



    /* divx 5.01+ bitstream reorder stuff */

    /* Since this clobbers the input buffer and hwaccel codecs still need the

     * data during hwaccel->end_frame we should not do this any earlier */

    if (s->codec_id == AV_CODEC_ID_MPEG4 && s->divx_packed) {

        int current_pos     = s->gb.buffer == s->bitstream_buffer ? 0 : (get_bits_count(&s->gb) >> 3);

        int startcode_found = 0;



        if (buf_size - current_pos > 7) {

            int i;

            for (i = current_pos; i < buf_size - 4; i++)

                if (buf[i]     == 0 &&

                    buf[i + 1] == 0 &&

                    buf[i + 2] == 1 &&

                    buf[i + 3] == 0xB6) {

                    startcode_found = !(buf[i + 4] & 0x40);

                    break;

                }

        }



        if (startcode_found) {

            av_fast_malloc(&s->bitstream_buffer,

                           &s->allocated_bitstream_buffer_size,

                           buf_size - current_pos +

                           FF_INPUT_BUFFER_PADDING_SIZE);

            if (!s->bitstream_buffer)

                return AVERROR(ENOMEM);

            memcpy(s->bitstream_buffer, buf + current_pos,

                   buf_size - current_pos);

            s->bitstream_buffer_size = buf_size - current_pos;

        }

    }



    if (!s->divx_packed && avctx->hwaccel)

        ff_thread_finish_setup(avctx);



    av_assert1(s->current_picture.f.pict_type == s->current_picture_ptr->f.pict_type);

    av_assert1(s->current_picture.f.pict_type == s->pict_type);

    if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {

        if ((ret = av_frame_ref(pict, &s->current_picture_ptr->f)) < 0)

            return ret;

        ff_print_debug_info(s, s->current_picture_ptr, pict);

        ff_mpv_export_qp_table(s, pict, s->current_picture_ptr, FF_QSCALE_TYPE_MPEG1);

    } else if (s->last_picture_ptr != NULL) {

        if ((ret = av_frame_ref(pict, &s->last_picture_ptr->f)) < 0)

            return ret;

        ff_print_debug_info(s, s->last_picture_ptr, pict);

        ff_mpv_export_qp_table(s, pict, s->last_picture_ptr, FF_QSCALE_TYPE_MPEG1);

    }



    if (s->last_picture_ptr || s->low_delay) {

        if (   pict->format == AV_PIX_FMT_YUV420P

            && (s->codec_tag == AV_RL32("GEOV") || s->codec_tag == AV_RL32("GEOX"))) {

            int x, y, p;

            av_frame_make_writable(pict);

            for (p=0; p<3; p++) {

                int w = FF_CEIL_RSHIFT(pict-> width, !!p);

                int h = FF_CEIL_RSHIFT(pict->height, !!p);

                int linesize = pict->linesize[p];

                for (y=0; y<(h>>1); y++)

                    for (x=0; x<w; x++)

                        FFSWAP(int,

                               pict->data[p][x + y*linesize],

                               pict->data[p][x + (h-1-y)*linesize]);

            }

        }

        *got_frame = 1;

    }



    if (slice_ret < 0 && (avctx->err_recognition & AV_EF_EXPLODE))

        return ret;

    else

        return get_consumed_bytes(s, buf_size);

}

int ff_h263_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,

                         AVPacket *avpkt)

{

    const uint8_t *buf = avpkt->data;

    int buf_size       = avpkt->size;

    MpegEncContext *s  = avctx->priv_data;

    int ret;

    int slice_ret = 0;

    AVFrame *pict = data;



    s->flags  = avctx->flags;

    s->flags2 = avctx->flags2;



    

    if (buf_size == 0) {

        

        if (s->low_delay == 0 && s->next_picture_ptr) {

            if ((ret = av_frame_ref(pict, &s->next_picture_ptr->f)) < 0)

                return ret;

            s->next_picture_ptr = NULL;



            *got_frame = 1;

        }



        return 0;

    }



    if (s->flags & CODEC_FLAG_TRUNCATED) {

        int next;



        if (CONFIG_MPEG4_DECODER && s->codec_id == AV_CODEC_ID_MPEG4) {

            next = ff_mpeg4_find_frame_end(&s->parse_context, buf, buf_size);

        } else if (CONFIG_H263_DECODER && s->codec_id == AV_CODEC_ID_H263) {

            next = ff_h263_find_frame_end(&s->parse_context, buf, buf_size);

        } else if (CONFIG_H263P_DECODER && s->codec_id == AV_CODEC_ID_H263P) {

            next = ff_h263_find_frame_end(&s->parse_context, buf, buf_size);

        } else {

            av_log(s->avctx, AV_LOG_ERROR,

                   "this codec does not support truncated bitstreams\n");

            return AVERROR(ENOSYS);

        }



        if (ff_combine_frame(&s->parse_context, next, (const uint8_t **)&buf,

                             &buf_size) < 0)

            return buf_size;

    }



retry:

    if (s->divx_packed && s->bitstream_buffer_size) {

        int i;

        for(i=0; i < buf_size-3; i++) {

            if (buf[i]==0 && buf[i+1]==0 && buf[i+2]==1) {

                if (buf[i+3]==0xB0) {

                    av_log(s->avctx, AV_LOG_WARNING, "Discarding excessive bitstream in packed xvid\n");

                    s->bitstream_buffer_size = 0;

                }

                break;

            }

        }

    }



    if (s->bitstream_buffer_size && (s->divx_packed || buf_size < 20)) 

        ret = init_get_bits8(&s->gb, s->bitstream_buffer,

                             s->bitstream_buffer_size);

    else

        ret = init_get_bits8(&s->gb, buf, buf_size);



    s->bitstream_buffer_size = 0;

    if (ret < 0)

        return ret;



    if (!s->context_initialized)

        

        if ((ret = ff_MPV_common_init(s)) < 0)

            return ret;



    



    if (s->current_picture_ptr == NULL || s->current_picture_ptr->f.data[0]) {

        int i = ff_find_unused_picture(s, 0);

        if (i < 0)

            return i;

        s->current_picture_ptr = &s->picture[i];

    }



    

    if (CONFIG_WMV2_DECODER && s->msmpeg4_version == 5) {

        ret = ff_wmv2_decode_picture_header(s);

    } else if (CONFIG_MSMPEG4_DECODER && s->msmpeg4_version) {

        ret = ff_msmpeg4_decode_picture_header(s);

    } else if (CONFIG_MPEG4_DECODER && avctx->codec_id == AV_CODEC_ID_MPEG4) {

        if (s->avctx->extradata_size && s->picture_number == 0) {

            GetBitContext gb;



            if (init_get_bits8(&gb, s->avctx->extradata, s->avctx->extradata_size) >= 0 )

                ff_mpeg4_decode_picture_header(avctx->priv_data, &gb);

        }

        ret = ff_mpeg4_decode_picture_header(avctx->priv_data, &s->gb);

    } else if (CONFIG_H263I_DECODER && s->codec_id == AV_CODEC_ID_H263I) {

        ret = ff_intel_h263_decode_picture_header(s);

    } else if (CONFIG_FLV_DECODER && s->h263_flv) {

        ret = ff_flv_decode_picture_header(s);

    } else {

        ret = ff_h263_decode_picture_header(s);

    }



    if (ret < 0 || ret == FRAME_SKIPPED) {

        if (   s->width  != avctx->coded_width

            || s->height != avctx->coded_height) {

                av_log(s->avctx, AV_LOG_WARNING, "Reverting picture dimensions change due to header decoding failure\n");

                s->width = avctx->coded_width;

                s->height= avctx->coded_height;

        }

    }

    if (ret == FRAME_SKIPPED)

        return get_consumed_bytes(s, buf_size);



    

    if (ret < 0) {

        av_log(s->avctx, AV_LOG_ERROR, "header damaged\n");

        return ret;

    }



    avctx->has_b_frames = !s->low_delay;



    if (ff_mpeg4_workaround_bugs(avctx) == 1)

        goto retry;



    







    if (s->width  != avctx->coded_width  ||

        s->height != avctx->coded_height ||

        s->context_reinit) {

        

        s->context_reinit = 0;



        ret = ff_set_dimensions(avctx, s->width, s->height);

        if (ret < 0)

            return ret;



        if ((ret = ff_MPV_common_frame_size_change(s)))

            return ret;

    }



    if (s->codec_id == AV_CODEC_ID_H263  ||

        s->codec_id == AV_CODEC_ID_H263P ||

        s->codec_id == AV_CODEC_ID_H263I)

        s->gob_index = ff_h263_get_gob_height(s);



    

    s->current_picture.f.pict_type = s->pict_type;

    s->current_picture.f.key_frame = s->pict_type == AV_PICTURE_TYPE_I;



    

    if (s->last_picture_ptr == NULL &&

        (s->pict_type == AV_PICTURE_TYPE_B || s->droppable))

        return get_consumed_bytes(s, buf_size);

    if ((avctx->skip_frame >= AVDISCARD_NONREF &&

         s->pict_type == AV_PICTURE_TYPE_B)    ||

        (avctx->skip_frame >= AVDISCARD_NONKEY &&

         s->pict_type != AV_PICTURE_TYPE_I)    ||

        avctx->skip_frame >= AVDISCARD_ALL)

        return get_consumed_bytes(s, buf_size);



    if (s->next_p_frame_damaged) {

        if (s->pict_type == AV_PICTURE_TYPE_B)

            return get_consumed_bytes(s, buf_size);

        else

            s->next_p_frame_damaged = 0;

    }



    if ((!s->no_rounding) || s->pict_type == AV_PICTURE_TYPE_B) {

        s->me.qpel_put = s->dsp.put_qpel_pixels_tab;

        s->me.qpel_avg = s->dsp.avg_qpel_pixels_tab;

    } else {

        s->me.qpel_put = s->dsp.put_no_rnd_qpel_pixels_tab;

        s->me.qpel_avg = s->dsp.avg_qpel_pixels_tab;

    }



    if ((ret = ff_MPV_frame_start(s, avctx)) < 0)

        return ret;



    if (!s->divx_packed && !avctx->hwaccel)

        ff_thread_finish_setup(avctx);



    if (CONFIG_MPEG4_VDPAU_DECODER && (s->avctx->codec->capabilities & CODEC_CAP_HWACCEL_VDPAU)) {

        ff_vdpau_mpeg4_decode_picture(s, s->gb.buffer, s->gb.buffer_end - s->gb.buffer);

        goto frame_end;

    }



    if (avctx->hwaccel) {

        ret = avctx->hwaccel->start_frame(avctx, s->gb.buffer,

                                          s->gb.buffer_end - s->gb.buffer);

        if (ret < 0 )

            return ret;

    }



    ff_mpeg_er_frame_start(s);



    





    if (CONFIG_WMV2_DECODER && s->msmpeg4_version == 5) {

        ret = ff_wmv2_decode_secondary_picture_header(s);

        if (ret < 0)

            return ret;

        if (ret == 1)

            goto frame_end;

    }



    

    s->mb_x = 0;

    s->mb_y = 0;



    slice_ret = decode_slice(s);

    while (s->mb_y < s->mb_height) {

        if (s->msmpeg4_version) {

            if (s->slice_height == 0 || s->mb_x != 0 ||

                (s->mb_y % s->slice_height) != 0 || get_bits_left(&s->gb) < 0)

                break;

        } else {

            int prev_x = s->mb_x, prev_y = s->mb_y;

            if (ff_h263_resync(s) < 0)

                break;

            if (prev_y * s->mb_width + prev_x < s->mb_y * s->mb_width + s->mb_x)

                s->er.error_occurred = 1;

        }



        if (s->msmpeg4_version < 4 && s->h263_pred)

            ff_mpeg4_clean_buffers(s);



        if (decode_slice(s) < 0)

            slice_ret = AVERROR_INVALIDDATA;

    }



    if (s->msmpeg4_version && s->msmpeg4_version < 4 &&

        s->pict_type == AV_PICTURE_TYPE_I)

        if (!CONFIG_MSMPEG4_DECODER ||

            ff_msmpeg4_decode_ext_header(s, buf_size) < 0)

            s->er.error_status_table[s->mb_num - 1] = ER_MB_ERROR;



    av_assert1(s->bitstream_buffer_size == 0);

frame_end:

    ff_er_frame_end(&s->er);



    if (avctx->hwaccel) {

        ret = avctx->hwaccel->end_frame(avctx);

        if (ret < 0)

            return ret;

    }



    ff_MPV_frame_end(s);



    

    



    if (s->codec_id == AV_CODEC_ID_MPEG4 && s->divx_packed) {

        int current_pos     = s->gb.buffer == s->bitstream_buffer ? 0 : (get_bits_count(&s->gb) >> 3);

        int startcode_found = 0;



        if (buf_size - current_pos > 7) {

            int i;

            for (i = current_pos; i < buf_size - 4; i++)

                if (buf[i]     == 0 &&

                    buf[i + 1] == 0 &&

                    buf[i + 2] == 1 &&

                    buf[i + 3] == 0xB6) {

                    startcode_found = !(buf[i + 4] & 0x40);

                    break;

                }

        }



        if (startcode_found) {

            av_fast_malloc(&s->bitstream_buffer,

                           &s->allocated_bitstream_buffer_size,

                           buf_size - current_pos +

                           FF_INPUT_BUFFER_PADDING_SIZE);

            if (!s->bitstream_buffer)

                return AVERROR(ENOMEM);

            memcpy(s->bitstream_buffer, buf + current_pos,

                   buf_size - current_pos);

            s->bitstream_buffer_size = buf_size - current_pos;

        }

    }



    if (!s->divx_packed && avctx->hwaccel)

        ff_thread_finish_setup(avctx);



    av_assert1(s->current_picture.f.pict_type == s->current_picture_ptr->f.pict_type);

    av_assert1(s->current_picture.f.pict_type == s->pict_type);

    if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {

        if ((ret = av_frame_ref(pict, &s->current_picture_ptr->f)) < 0)

            return ret;

        ff_print_debug_info(s, s->current_picture_ptr, pict);

        ff_mpv_export_qp_table(s, pict, s->current_picture_ptr, FF_QSCALE_TYPE_MPEG1);

    } else if (s->last_picture_ptr != NULL) {

        if ((ret = av_frame_ref(pict, &s->last_picture_ptr->f)) < 0)

            return ret;

        ff_print_debug_info(s, s->last_picture_ptr, pict);

        ff_mpv_export_qp_table(s, pict, s->last_picture_ptr, FF_QSCALE_TYPE_MPEG1);

    }



    if (s->last_picture_ptr || s->low_delay) {

        if (   pict->format == AV_PIX_FMT_YUV420P

            && (s->codec_tag == AV_RL32("GEOV") || s->codec_tag == AV_RL32("GEOX"))) {

            int x, y, p;

            av_frame_make_writable(pict);

            for (p=0; p<3; p++) {

                int w = FF_CEIL_RSHIFT(pict-> width, !!p);

                int h = FF_CEIL_RSHIFT(pict->height, !!p);

                int linesize = pict->linesize[p];

                for (y=0; y<(h>>1); y++)

                    for (x=0; x<w; x++)

                        FFSWAP(int,

                               pict->data[p][x + y*linesize],

                               pict->data[p][x + (h-1-y)*linesize]);

            }

        }

        *got_frame = 1;

    }



    if (slice_ret < 0 && (avctx->err_recognition & AV_EF_EXPLODE))

        return ret;

    else

        return get_consumed_bytes(s, buf_size);

}

int FUNC_0(AVCodecContext *VAR_0, void *VAR_1, int *VAR_2,

                         AVPacket *VAR_3)

{

    const uint8_t *VAR_4 = VAR_3->VAR_1;

    int VAR_5       = VAR_3->size;

    MpegEncContext *s  = VAR_0->priv_data;

    int VAR_6;

    int VAR_7 = 0;

    AVFrame *pict = VAR_1;



    s->flags  = VAR_0->flags;

    s->flags2 = VAR_0->flags2;



    

    if (VAR_5 == 0) {

        

        if (s->low_delay == 0 && s->next_picture_ptr) {

            if ((VAR_6 = av_frame_ref(pict, &s->next_picture_ptr->f)) < 0)

                return VAR_6;

            s->next_picture_ptr = NULL;



            *VAR_2 = 1;

        }



        return 0;

    }



    if (s->flags & CODEC_FLAG_TRUNCATED) {

        int VAR_8;



        if (CONFIG_MPEG4_DECODER && s->codec_id == AV_CODEC_ID_MPEG4) {

            VAR_8 = ff_mpeg4_find_frame_end(&s->parse_context, VAR_4, VAR_5);

        } else if (CONFIG_H263_DECODER && s->codec_id == AV_CODEC_ID_H263) {

            VAR_8 = ff_h263_find_frame_end(&s->parse_context, VAR_4, VAR_5);

        } else if (CONFIG_H263P_DECODER && s->codec_id == AV_CODEC_ID_H263P) {

            VAR_8 = ff_h263_find_frame_end(&s->parse_context, VAR_4, VAR_5);

        } else {

            av_log(s->VAR_0, AV_LOG_ERROR,

                   "this codec does not support truncated bitstreams\n");

            return AVERROR(ENOSYS);

        }



        if (ff_combine_frame(&s->parse_context, VAR_8, (const uint8_t **)&VAR_4,

                             &VAR_5) < 0)

            return VAR_5;

    }



retry:

    if (s->divx_packed && s->bitstream_buffer_size) {

        int VAR_14;

        for(VAR_14=0; VAR_14 < VAR_5-3; VAR_14++) {

            if (VAR_4[VAR_14]==0 && VAR_4[VAR_14+1]==0 && VAR_4[VAR_14+2]==1) {

                if (VAR_4[VAR_14+3]==0xB0) {

                    av_log(s->VAR_0, AV_LOG_WARNING, "Discarding excessive bitstream in packed xvid\n");

                    s->bitstream_buffer_size = 0;

                }

                break;

            }

        }

    }



    if (s->bitstream_buffer_size && (s->divx_packed || VAR_5 < 20)) 

        VAR_6 = init_get_bits8(&s->gb, s->bitstream_buffer,

                             s->bitstream_buffer_size);

    else

        VAR_6 = init_get_bits8(&s->gb, VAR_4, VAR_5);



    s->bitstream_buffer_size = 0;

    if (VAR_6 < 0)

        return VAR_6;



    if (!s->context_initialized)

        

        if ((VAR_6 = ff_MPV_common_init(s)) < 0)

            return VAR_6;



    



    if (s->current_picture_ptr == NULL || s->current_picture_ptr->f.VAR_1[0]) {

        int VAR_14 = ff_find_unused_picture(s, 0);

        if (VAR_14 < 0)

            return VAR_14;

        s->current_picture_ptr = &s->picture[VAR_14];

    }



    

    if (CONFIG_WMV2_DECODER && s->msmpeg4_version == 5) {

        VAR_6 = ff_wmv2_decode_picture_header(s);

    } else if (CONFIG_MSMPEG4_DECODER && s->msmpeg4_version) {

        VAR_6 = ff_msmpeg4_decode_picture_header(s);

    } else if (CONFIG_MPEG4_DECODER && VAR_0->codec_id == AV_CODEC_ID_MPEG4) {

        if (s->VAR_0->extradata_size && s->picture_number == 0) {

            GetBitContext gb;



            if (init_get_bits8(&gb, s->VAR_0->extradata, s->VAR_0->extradata_size) >= 0 )

                ff_mpeg4_decode_picture_header(VAR_0->priv_data, &gb);

        }

        VAR_6 = ff_mpeg4_decode_picture_header(VAR_0->priv_data, &s->gb);

    } else if (CONFIG_H263I_DECODER && s->codec_id == AV_CODEC_ID_H263I) {

        VAR_6 = ff_intel_h263_decode_picture_header(s);

    } else if (CONFIG_FLV_DECODER && s->h263_flv) {

        VAR_6 = ff_flv_decode_picture_header(s);

    } else {

        VAR_6 = ff_h263_decode_picture_header(s);

    }



    if (VAR_6 < 0 || VAR_6 == FRAME_SKIPPED) {

        if (   s->width  != VAR_0->coded_width

            || s->height != VAR_0->coded_height) {

                av_log(s->VAR_0, AV_LOG_WARNING, "Reverting picture dimensions change due to header decoding failure\n");

                s->width = VAR_0->coded_width;

                s->height= VAR_0->coded_height;

        }

    }

    if (VAR_6 == FRAME_SKIPPED)

        return get_consumed_bytes(s, VAR_5);



    

    if (VAR_6 < 0) {

        av_log(s->VAR_0, AV_LOG_ERROR, "header damaged\n");

        return VAR_6;

    }



    VAR_0->has_b_frames = !s->low_delay;



    if (ff_mpeg4_workaround_bugs(VAR_0) == 1)

        goto retry;



    







    if (s->width  != VAR_0->coded_width  ||

        s->height != VAR_0->coded_height ||

        s->context_reinit) {

        

        s->context_reinit = 0;



        VAR_6 = ff_set_dimensions(VAR_0, s->width, s->height);

        if (VAR_6 < 0)

            return VAR_6;



        if ((VAR_6 = ff_MPV_common_frame_size_change(s)))

            return VAR_6;

    }



    if (s->codec_id == AV_CODEC_ID_H263  ||

        s->codec_id == AV_CODEC_ID_H263P ||

        s->codec_id == AV_CODEC_ID_H263I)

        s->gob_index = ff_h263_get_gob_height(s);



    

    s->current_picture.f.pict_type = s->pict_type;

    s->current_picture.f.key_frame = s->pict_type == AV_PICTURE_TYPE_I;



    

    if (s->last_picture_ptr == NULL &&

        (s->pict_type == AV_PICTURE_TYPE_B || s->droppable))

        return get_consumed_bytes(s, VAR_5);

    if ((VAR_0->skip_frame >= AVDISCARD_NONREF &&

         s->pict_type == AV_PICTURE_TYPE_B)    ||

        (VAR_0->skip_frame >= AVDISCARD_NONKEY &&

         s->pict_type != AV_PICTURE_TYPE_I)    ||

        VAR_0->skip_frame >= AVDISCARD_ALL)

        return get_consumed_bytes(s, VAR_5);



    if (s->next_p_frame_damaged) {

        if (s->pict_type == AV_PICTURE_TYPE_B)

            return get_consumed_bytes(s, VAR_5);

        else

            s->next_p_frame_damaged = 0;

    }



    if ((!s->no_rounding) || s->pict_type == AV_PICTURE_TYPE_B) {

        s->me.qpel_put = s->dsp.put_qpel_pixels_tab;

        s->me.qpel_avg = s->dsp.avg_qpel_pixels_tab;

    } else {

        s->me.qpel_put = s->dsp.put_no_rnd_qpel_pixels_tab;

        s->me.qpel_avg = s->dsp.avg_qpel_pixels_tab;

    }



    if ((VAR_6 = ff_MPV_frame_start(s, VAR_0)) < 0)

        return VAR_6;



    if (!s->divx_packed && !VAR_0->hwaccel)

        ff_thread_finish_setup(VAR_0);



    if (CONFIG_MPEG4_VDPAU_DECODER && (s->VAR_0->codec->capabilities & CODEC_CAP_HWACCEL_VDPAU)) {

        ff_vdpau_mpeg4_decode_picture(s, s->gb.buffer, s->gb.buffer_end - s->gb.buffer);

        goto frame_end;

    }



    if (VAR_0->hwaccel) {

        VAR_6 = VAR_0->hwaccel->start_frame(VAR_0, s->gb.buffer,

                                          s->gb.buffer_end - s->gb.buffer);

        if (VAR_6 < 0 )

            return VAR_6;

    }



    ff_mpeg_er_frame_start(s);



    





    if (CONFIG_WMV2_DECODER && s->msmpeg4_version == 5) {

        VAR_6 = ff_wmv2_decode_secondary_picture_header(s);

        if (VAR_6 < 0)

            return VAR_6;

        if (VAR_6 == 1)

            goto frame_end;

    }



    

    s->mb_x = 0;

    s->mb_y = 0;



    VAR_7 = decode_slice(s);

    while (s->mb_y < s->mb_height) {

        if (s->msmpeg4_version) {

            if (s->slice_height == 0 || s->mb_x != 0 ||

                (s->mb_y % s->slice_height) != 0 || get_bits_left(&s->gb) < 0)

                break;

        } else {

            int VAR_10 = s->mb_x, VAR_11 = s->mb_y;

            if (ff_h263_resync(s) < 0)

                break;

            if (VAR_11 * s->mb_width + VAR_10 < s->mb_y * s->mb_width + s->mb_x)

                s->er.error_occurred = 1;

        }



        if (s->msmpeg4_version < 4 && s->h263_pred)

            ff_mpeg4_clean_buffers(s);



        if (decode_slice(s) < 0)

            VAR_7 = AVERROR_INVALIDDATA;

    }



    if (s->msmpeg4_version && s->msmpeg4_version < 4 &&

        s->pict_type == AV_PICTURE_TYPE_I)

        if (!CONFIG_MSMPEG4_DECODER ||

            ff_msmpeg4_decode_ext_header(s, VAR_5) < 0)

            s->er.error_status_table[s->mb_num - 1] = ER_MB_ERROR;



    av_assert1(s->bitstream_buffer_size == 0);

frame_end:

    ff_er_frame_end(&s->er);



    if (VAR_0->hwaccel) {

        VAR_6 = VAR_0->hwaccel->end_frame(VAR_0);

        if (VAR_6 < 0)

            return VAR_6;

    }



    ff_MPV_frame_end(s);



    

    



    if (s->codec_id == AV_CODEC_ID_MPEG4 && s->divx_packed) {

        int VAR_12     = s->gb.buffer == s->bitstream_buffer ? 0 : (get_bits_count(&s->gb) >> 3);

        int VAR_13 = 0;



        if (VAR_5 - VAR_12 > 7) {

            int VAR_14;

            for (VAR_14 = VAR_12; VAR_14 < VAR_5 - 4; VAR_14++)

                if (VAR_4[VAR_14]     == 0 &&

                    VAR_4[VAR_14 + 1] == 0 &&

                    VAR_4[VAR_14 + 2] == 1 &&

                    VAR_4[VAR_14 + 3] == 0xB6) {

                    VAR_13 = !(VAR_4[VAR_14 + 4] & 0x40);

                    break;

                }

        }



        if (VAR_13) {

            av_fast_malloc(&s->bitstream_buffer,

                           &s->allocated_bitstream_buffer_size,

                           VAR_5 - VAR_12 +

                           FF_INPUT_BUFFER_PADDING_SIZE);

            if (!s->bitstream_buffer)

                return AVERROR(ENOMEM);

            memcpy(s->bitstream_buffer, VAR_4 + VAR_12,

                   VAR_5 - VAR_12);

            s->bitstream_buffer_size = VAR_5 - VAR_12;

        }

    }



    if (!s->divx_packed && VAR_0->hwaccel)

        ff_thread_finish_setup(VAR_0);



    av_assert1(s->current_picture.f.pict_type == s->current_picture_ptr->f.pict_type);

    av_assert1(s->current_picture.f.pict_type == s->pict_type);

    if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {

        if ((VAR_6 = av_frame_ref(pict, &s->current_picture_ptr->f)) < 0)

            return VAR_6;

        ff_print_debug_info(s, s->current_picture_ptr, pict);

        ff_mpv_export_qp_table(s, pict, s->current_picture_ptr, FF_QSCALE_TYPE_MPEG1);

    } else if (s->last_picture_ptr != NULL) {

        if ((VAR_6 = av_frame_ref(pict, &s->last_picture_ptr->f)) < 0)

            return VAR_6;

        ff_print_debug_info(s, s->last_picture_ptr, pict);

        ff_mpv_export_qp_table(s, pict, s->last_picture_ptr, FF_QSCALE_TYPE_MPEG1);

    }



    if (s->last_picture_ptr || s->low_delay) {

        if (   pict->format == AV_PIX_FMT_YUV420P

            && (s->codec_tag == AV_RL32("GEOV") || s->codec_tag == AV_RL32("GEOX"))) {

            int VAR_14, VAR_15, VAR_16;

            av_frame_make_writable(pict);

            for (VAR_16=0; VAR_16<3; VAR_16++) {

                int VAR_17 = FF_CEIL_RSHIFT(pict-> width, !!VAR_16);

                int VAR_18 = FF_CEIL_RSHIFT(pict->height, !!VAR_16);

                int VAR_19 = pict->VAR_19[VAR_16];

                for (VAR_15=0; VAR_15<(VAR_18>>1); VAR_15++)

                    for (VAR_14=0; VAR_14<VAR_17; VAR_14++)

                        FFSWAP(int,

                               pict->VAR_1[VAR_16][VAR_14 + VAR_15*VAR_19],

                               pict->VAR_1[VAR_16][VAR_14 + (VAR_18-1-VAR_15)*VAR_19]);

            }

        }

        *VAR_2 = 1;

    }



    if (VAR_7 < 0 && (VAR_0->err_recognition & AV_EF_EXPLODE))

        return VAR_6;

    else

        return get_consumed_bytes(s, VAR_5);

}

int FUNC_0(AVCodecContext *VAR_0, void *VAR_1, int *VAR_2,
AVPacket *VAR_3)
{ const uint8_t *VAR_4 = VAR_3->VAR_1; int VAR_5       = VAR_3->size; MpegEncContext *s  = VAR_0->priv_data; int VAR_6; int VAR_7 = 0; AVFrame *pict = VAR_1; s->flags  = VAR_0->flags; s->flags2 = VAR_0->flags2; if (VAR_5 == 0) { if (s->low_delay == 0 && s->next_picture_ptr) { if ((VAR_6 = av_frame_ref(pict, &s->next_picture_ptr->f)) < 0)
return VAR_6; s->next_picture_ptr = NULL; *VAR_2 = 1; } return 0; } if (s->flags & CODEC_FLAG_TRUNCATED) { int VAR_8; if (CONFIG_MPEG4_DECODER && s->codec_id == AV_CODEC_ID_MPEG4) { VAR_8 = ff_mpeg4_find_frame_end(&s->parse_context, VAR_4, VAR_5); } else if (CONFIG_H263_DECODER && s->codec_id == AV_CODEC_ID_H263) { VAR_8 = ff_h263_find_frame_end(&s->parse_context, VAR_4, VAR_5); } else if (CONFIG_H263P_DECODER && s->codec_id == AV_CODEC_ID_H263P) { VAR_8 = ff_h263_find_frame_end(&s->parse_context, VAR_4, VAR_5); } else { av_log(s->VAR_0, AV_LOG_ERROR,
"this codec does not support truncated bitstreams\n"); return AVERROR(ENOSYS); } if (ff_combine_frame(&s->parse_context, VAR_8, (const uint8_t **)&VAR_4,
&VAR_5) < 0)
return VAR_5; } retry:
if (s->divx_packed && s->bitstream_buffer_size) { int VAR_14; for(VAR_14=0; VAR_14 < VAR_5-3; VAR_14++) { if (VAR_4[VAR_14]==0 && VAR_4[VAR_14+1]==0 && VAR_4[VAR_14+2]==1) { if (VAR_4[VAR_14+3]==0xB0) { av_log(s->VAR_0, AV_LOG_WARNING, "Discarding excessive bitstream in packed xvid\n"); s->bitstream_buffer_size = 0; } break; } } } if (s->bitstream_buffer_size && (s->divx_packed || VAR_5 < 20))
VAR_6 = init_get_bits8(&s->gb, s->bitstream_buffer,
s->bitstream_buffer_size); else
VAR_6 = init_get_bits8(&s->gb, VAR_4, VAR_5); s->bitstream_buffer_size = 0; if (VAR_6 < 0)
return VAR_6; if (!s->context_initialized)
if ((VAR_6 = ff_MPV_common_init(s)) < 0)
return VAR_6; if (s->current_picture_ptr == NULL || s->current_picture_ptr->f.VAR_1[0]) { int VAR_14 = ff_find_unused_picture(s, 0); if (VAR_14 < 0)
return VAR_14; s->current_picture_ptr = &s->picture[VAR_14]; } if (CONFIG_WMV2_DECODER && s->msmpeg4_version == 5) { VAR_6 = ff_wmv2_decode_picture_header(s); } else if (CONFIG_MSMPEG4_DECODER && s->msmpeg4_version) { VAR_6 = ff_msmpeg4_decode_picture_header(s); } else if (CONFIG_MPEG4_DECODER && VAR_0->codec_id == AV_CODEC_ID_MPEG4) { if (s->VAR_0->extradata_size && s->picture_number == 0) { GetBitContext gb; if (init_get_bits8(&gb, s->VAR_0->extradata, s->VAR_0->extradata_size) >= 0 )
ff_mpeg4_decode_picture_header(VAR_0->priv_data, &gb); } VAR_6 = ff_mpeg4_decode_picture_header(VAR_0->priv_data, &s->gb); } else if (CONFIG_H263I_DECODER && s->codec_id == AV_CODEC_ID_H263I) { VAR_6 = ff_intel_h263_decode_picture_header(s); } else if (CONFIG_FLV_DECODER && s->h263_flv) { VAR_6 = ff_flv_decode_picture_header(s); } else { VAR_6 = ff_h263_decode_picture_header(s); } if (VAR_6 < 0 || VAR_6 == FRAME_SKIPPED) { if (   s->width  != VAR_0->coded_width
|| s->height != VAR_0->coded_height) { av_log(s->VAR_0, AV_LOG_WARNING, "Reverting picture dimensions change due to header decoding failure\n"); s->width = VAR_0->coded_width; s->height= VAR_0->coded_height; } } if (VAR_6 == FRAME_SKIPPED)
return get_consumed_bytes(s, VAR_5); if (VAR_6 < 0) { av_log(s->VAR_0, AV_LOG_ERROR, "header damaged\n"); return VAR_6; } VAR_0->has_b_frames = !s->low_delay; if (ff_mpeg4_workaround_bugs(VAR_0) == 1)
goto retry; if (s->width  != VAR_0->coded_width  ||
s->height != VAR_0->coded_height ||
s->context_reinit) { s->context_reinit = 0; VAR_6 = ff_set_dimensions(VAR_0, s->width, s->height); if (VAR_6 < 0)
return VAR_6; if ((VAR_6 = ff_MPV_common_frame_size_change(s)))
return VAR_6; } if (s->codec_id == AV_CODEC_ID_H263  ||
s->codec_id == AV_CODEC_ID_H263P ||
s->codec_id == AV_CODEC_ID_H263I)
s->gob_index = ff_h263_get_gob_height(s); s->current_picture.f.pict_type = s->pict_type; s->current_picture.f.key_frame = s->pict_type == AV_PICTURE_TYPE_I; if (s->last_picture_ptr == NULL &&
(s->pict_type == AV_PICTURE_TYPE_B || s->droppable))
return get_consumed_bytes(s, VAR_5); if ((VAR_0->skip_frame >= AVDISCARD_NONREF &&
s->pict_type == AV_PICTURE_TYPE_B)    ||
(VAR_0->skip_frame >= AVDISCARD_NONKEY &&
s->pict_type != AV_PICTURE_TYPE_I)    ||
VAR_0->skip_frame >= AVDISCARD_ALL)
return get_consumed_bytes(s, VAR_5); if (s->next_p_frame_damaged) { if (s->pict_type == AV_PICTURE_TYPE_B)
return get_consumed_bytes(s, VAR_5); else
s->next_p_frame_damaged = 0; } if ((!s->no_rounding) || s->pict_type == AV_PICTURE_TYPE_B) { s->me.qpel_put = s->dsp.put_qpel_pixels_tab; s->me.qpel_avg = s->dsp.avg_qpel_pixels_tab; } else { s->me.qpel_put = s->dsp.put_no_rnd_qpel_pixels_tab; s->me.qpel_avg = s->dsp.avg_qpel_pixels_tab; } if ((VAR_6 = ff_MPV_frame_start(s, VAR_0)) < 0)
return VAR_6; if (!s->divx_packed && !VAR_0->hwaccel)
ff_thread_finish_setup(VAR_0); if (CONFIG_MPEG4_VDPAU_DECODER && (s->VAR_0->codec->capabilities & CODEC_CAP_HWACCEL_VDPAU)) { ff_vdpau_mpeg4_decode_picture(s, s->gb.buffer, s->gb.buffer_end - s->gb.buffer); goto frame_end; } if (VAR_0->hwaccel) { VAR_6 = VAR_0->hwaccel->start_frame(VAR_0, s->gb.buffer,
s->gb.buffer_end - s->gb.buffer); if (VAR_6 < 0 )
return VAR_6; } ff_mpeg_er_frame_start(s); if (CONFIG_WMV2_DECODER && s->msmpeg4_version == 5) { VAR_6 = ff_wmv2_decode_secondary_picture_header(s); if (VAR_6 < 0)
return VAR_6; if (VAR_6 == 1)
goto frame_end; } s->mb_x = 0; s->mb_y = 0; VAR_7 = decode_slice(s); while (s->mb_y < s->mb_height) { if (s->msmpeg4_version) { if (s->slice_height == 0 || s->mb_x != 0 ||
(s->mb_y % s->slice_height) != 0 || get_bits_left(&s->gb) < 0)
break; } else { int VAR_10 = s->mb_x, VAR_11 = s->mb_y; if (ff_h263_resync(s) < 0)
break; if (VAR_11 * s->mb_width + VAR_10 < s->mb_y * s->mb_width + s->mb_x)
s->er.error_occurred = 1; } if (s->msmpeg4_version < 4 && s->h263_pred)
ff_mpeg4_clean_buffers(s); if (decode_slice(s) < 0)
VAR_7 = AVERROR_INVALIDDATA; } if (s->msmpeg4_version && s->msmpeg4_version < 4 &&
s->pict_type == AV_PICTURE_TYPE_I)
if (!CONFIG_MSMPEG4_DECODER ||
ff_msmpeg4_decode_ext_header(s, VAR_5) < 0)
s->er.error_status_table[s->mb_num - 1] = ER_MB_ERROR; av_assert1(s->bitstream_buffer_size == 0); frame_end:
ff_er_frame_end(&s->er); if (VAR_0->hwaccel) { VAR_6 = VAR_0->hwaccel->end_frame(VAR_0); if (VAR_6 < 0)
return VAR_6; } ff_MPV_frame_end(s); if (s->codec_id == AV_CODEC_ID_MPEG4 && s->divx_packed) { int VAR_12     = s->gb.buffer == s->bitstream_buffer ? 0 : (get_bits_count(&s->gb) >> 3); int VAR_13 = 0; if (VAR_5 - VAR_12 > 7) { int VAR_14; for (VAR_14 = VAR_12; VAR_14 < VAR_5 - 4; VAR_14++) if (VAR_4[VAR_14]     == 0 &&
VAR_4[VAR_14 + 1] == 0 &&
VAR_4[VAR_14 + 2] == 1 &&
VAR_4[VAR_14 + 3] == 0xB6) { VAR_13 = !(VAR_4[VAR_14 + 4] & 0x40); break; } } if (VAR_13) { av_fast_malloc(&s->bitstream_buffer,
&s->allocated_bitstream_buffer_size,
VAR_5 - VAR_12 +
FF_INPUT_BUFFER_PADDING_SIZE); if (!s->bitstream_buffer)
return AVERROR(ENOMEM); memcpy(s->bitstream_buffer, VAR_4 + VAR_12,
VAR_5 - VAR_12); s->bitstream_buffer_size = VAR_5 - VAR_12; } } if (!s->divx_packed && VAR_0->hwaccel)
ff_thread_finish_setup(VAR_0); av_assert1(s->current_picture.f.pict_type == s->current_picture_ptr->f.pict_type); av_assert1(s->current_picture.f.pict_type == s->pict_type); if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) { if ((VAR_6 = av_frame_ref(pict, &s->current_picture_ptr->f)) < 0)
return VAR_6; ff_print_debug_info(s, s->current_picture_ptr, pict); ff_mpv_export_qp_table(s, pict, s->current_picture_ptr, FF_QSCALE_TYPE_MPEG1); } else if (s->last_picture_ptr != NULL) { if ((VAR_6 = av_frame_ref(pict, &s->last_picture_ptr->f)) < 0)
return VAR_6; ff_print_debug_info(s, s->last_picture_ptr, pict); ff_mpv_export_qp_table(s, pict, s->last_picture_ptr, FF_QSCALE_TYPE_MPEG1); } if (s->last_picture_ptr || s->low_delay) { if (   pict->format == AV_PIX_FMT_YUV420P
&& (s->codec_tag == AV_RL32("GEOV") || s->codec_tag == AV_RL32("GEOX"))) { int VAR_14, VAR_15, VAR_16; av_frame_make_writable(pict); for (VAR_16=0; VAR_16<3; VAR_16++) { int VAR_17 = FF_CEIL_RSHIFT(pict-> width, !!VAR_16); int VAR_18 = FF_CEIL_RSHIFT(pict->height, !!VAR_16); int VAR_19 = pict->VAR_19[VAR_16]; for (VAR_15=0; VAR_15<(VAR_18>>1); VAR_15++) for (VAR_14=0; VAR_14<VAR_17; VAR_14++) FFSWAP(int,
pict->VAR_1[VAR_16][VAR_14 + VAR_15*VAR_19],
pict->VAR_1[VAR_16][VAR_14 + (VAR_18-1-VAR_15)*VAR_19]); } } *VAR_2 = 1; } if (VAR_7 < 0 && (VAR_0->err_recognition & AV_EF_EXPLODE))
return VAR_6; else
return get_consumed_bytes(s, VAR_5); }