av_cold int ff_mpv_common_init(MpegEncContext *s)

{

    int i;

    int nb_slices = (HAVE_THREADS &&

                     s->avctx->active_thread_type & FF_THREAD_SLICE) ?

                    s->avctx->thread_count : 1;



    if (s->encoding && s->avctx->slices)

        nb_slices = s->avctx->slices;



    if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)

        s->mb_height = (s->height + 31) / 32 * 2;

    else

        s->mb_height = (s->height + 15) / 16;



    if (s->avctx->pix_fmt == AV_PIX_FMT_NONE) {

        av_log(s->avctx, AV_LOG_ERROR,

               "decoding to AV_PIX_FMT_NONE is not supported.\n");

        return -1;

    }



    if (nb_slices > MAX_THREADS || (nb_slices > s->mb_height && s->mb_height)) {

        int max_slices;

        if (s->mb_height)

            max_slices = FFMIN(MAX_THREADS, s->mb_height);

        else

            max_slices = MAX_THREADS;

        av_log(s->avctx, AV_LOG_WARNING, "too many threads/slices (%d),"

               " reducing to %d\n", nb_slices, max_slices);

        nb_slices = max_slices;

    }



    if ((s->width || s->height) &&

        av_image_check_size(s->width, s->height, 0, s->avctx))

        return -1;



    dct_init(s);



    /* set chroma shifts */

    avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,

                                  &s->chroma_x_shift,

                                  &s->chroma_y_shift);





    FF_ALLOCZ_OR_GOTO(s->avctx, s->picture,

                      MAX_PICTURE_COUNT * sizeof(Picture), fail);

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

        s->picture[i].f = av_frame_alloc();

        if (!s->picture[i].f)

            goto fail;

    }

    memset(&s->next_picture, 0, sizeof(s->next_picture));

    memset(&s->last_picture, 0, sizeof(s->last_picture));

    memset(&s->current_picture, 0, sizeof(s->current_picture));

    memset(&s->new_picture, 0, sizeof(s->new_picture));

    s->next_picture.f = av_frame_alloc();

    if (!s->next_picture.f)

        goto fail;

    s->last_picture.f = av_frame_alloc();

    if (!s->last_picture.f)

        goto fail;

    s->current_picture.f = av_frame_alloc();

    if (!s->current_picture.f)

        goto fail;

    s->new_picture.f = av_frame_alloc();

    if (!s->new_picture.f)

        goto fail;



        if (init_context_frame(s))

            goto fail;



        s->parse_context.state = -1;



        s->context_initialized = 1;

        memset(s->thread_context, 0, sizeof(s->thread_context));

        s->thread_context[0]   = s;



//     if (s->width && s->height) {

        if (nb_slices > 1) {

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

                if (i) {

                    s->thread_context[i] = av_memdup(s, sizeof(MpegEncContext));

                    if (!s->thread_context[i])

                        goto fail;

                }

                if (init_duplicate_context(s->thread_context[i]) < 0)

                    goto fail;

                    s->thread_context[i]->start_mb_y =

                        (s->mb_height * (i) + nb_slices / 2) / nb_slices;

                    s->thread_context[i]->end_mb_y   =

                        (s->mb_height * (i + 1) + nb_slices / 2) / nb_slices;

            }

        } else {

            if (init_duplicate_context(s) < 0)

                goto fail;

            s->start_mb_y = 0;

            s->end_mb_y   = s->mb_height;

        }

        s->slice_context_count = nb_slices;

//     }



    return 0;

 fail:

    ff_mpv_common_end(s);

    return -1;

}

av_cold int ff_mpv_common_init(MpegEncContext *s)

{

    int i;

    int nb_slices = (HAVE_THREADS &&

                     s->avctx->active_thread_type & FF_THREAD_SLICE) ?

                    s->avctx->thread_count : 1;



    if (s->encoding && s->avctx->slices)

        nb_slices = s->avctx->slices;



    if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)

        s->mb_height = (s->height + 31) / 32 * 2;

    else

        s->mb_height = (s->height + 15) / 16;



    if (s->avctx->pix_fmt == AV_PIX_FMT_NONE) {

        av_log(s->avctx, AV_LOG_ERROR,

               "decoding to AV_PIX_FMT_NONE is not supported.\n");

        return -1;

    }



    if (nb_slices > MAX_THREADS || (nb_slices > s->mb_height && s->mb_height)) {

        int max_slices;

        if (s->mb_height)

            max_slices = FFMIN(MAX_THREADS, s->mb_height);

        else

            max_slices = MAX_THREADS;

        av_log(s->avctx, AV_LOG_WARNING, "too many threads/slices (%d),"

               " reducing to %d\n", nb_slices, max_slices);

        nb_slices = max_slices;

    }



    if ((s->width || s->height) &&

        av_image_check_size(s->width, s->height, 0, s->avctx))

        return -1;



    dct_init(s);



    

    avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,

                                  &s->chroma_x_shift,

                                  &s->chroma_y_shift);





    FF_ALLOCZ_OR_GOTO(s->avctx, s->picture,

                      MAX_PICTURE_COUNT * sizeof(Picture), fail);

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

        s->picture[i].f = av_frame_alloc();

        if (!s->picture[i].f)

            goto fail;

    }

    memset(&s->next_picture, 0, sizeof(s->next_picture));

    memset(&s->last_picture, 0, sizeof(s->last_picture));

    memset(&s->current_picture, 0, sizeof(s->current_picture));

    memset(&s->new_picture, 0, sizeof(s->new_picture));

    s->next_picture.f = av_frame_alloc();

    if (!s->next_picture.f)

        goto fail;

    s->last_picture.f = av_frame_alloc();

    if (!s->last_picture.f)

        goto fail;

    s->current_picture.f = av_frame_alloc();

    if (!s->current_picture.f)

        goto fail;

    s->new_picture.f = av_frame_alloc();

    if (!s->new_picture.f)

        goto fail;



        if (init_context_frame(s))

            goto fail;



        s->parse_context.state = -1;



        s->context_initialized = 1;

        memset(s->thread_context, 0, sizeof(s->thread_context));

        s->thread_context[0]   = s;





        if (nb_slices > 1) {

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

                if (i) {

                    s->thread_context[i] = av_memdup(s, sizeof(MpegEncContext));

                    if (!s->thread_context[i])

                        goto fail;

                }

                if (init_duplicate_context(s->thread_context[i]) < 0)

                    goto fail;

                    s->thread_context[i]->start_mb_y =

                        (s->mb_height * (i) + nb_slices / 2) / nb_slices;

                    s->thread_context[i]->end_mb_y   =

                        (s->mb_height * (i + 1) + nb_slices / 2) / nb_slices;

            }

        } else {

            if (init_duplicate_context(s) < 0)

                goto fail;

            s->start_mb_y = 0;

            s->end_mb_y   = s->mb_height;

        }

        s->slice_context_count = nb_slices;





    return 0;

 fail:

    ff_mpv_common_end(s);

    return -1;

}

    memset(&s->next_picture, 0, sizeof(s->next_picture));     memset(&s->last_picture, 0, sizeof(s->last_picture));     memset(&s->current_picture, 0, sizeof(s->current_picture));     memset(&s->new_picture, 0, sizeof(s->new_picture));
av_cold int FUNC_0(MpegEncContext *s)

{

    int VAR_0;

    int VAR_1 = (HAVE_THREADS &&

                     s->avctx->active_thread_type & FF_THREAD_SLICE) ?

                    s->avctx->thread_count : 1;



    if (s->encoding && s->avctx->slices)

        VAR_1 = s->avctx->slices;



    if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)

        s->mb_height = (s->height + 31) / 32 * 2;

    else

        s->mb_height = (s->height + 15) / 16;



    if (s->avctx->pix_fmt == AV_PIX_FMT_NONE) {

        av_log(s->avctx, AV_LOG_ERROR,

               "decoding to AV_PIX_FMT_NONE is not supported.\n");

        return -1;

    }



    if (VAR_1 > MAX_THREADS || (VAR_1 > s->mb_height && s->mb_height)) {

        int VAR_2;

        if (s->mb_height)

            VAR_2 = FFMIN(MAX_THREADS, s->mb_height);

        else

            VAR_2 = MAX_THREADS;

        av_log(s->avctx, AV_LOG_WARNING, "too many threads/slices (%d),"

               " reducing to %d\n", VAR_1, VAR_2);

        VAR_1 = VAR_2;

    }



    if ((s->width || s->height) &&

        av_image_check_size(s->width, s->height, 0, s->avctx))

        return -1;



    dct_init(s);



    

    avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,

                                  &s->chroma_x_shift,

                                  &s->chroma_y_shift);





    FF_ALLOCZ_OR_GOTO(s->avctx, s->picture,

                      MAX_PICTURE_COUNT * sizeof(Picture), fail);

    for (VAR_0 = 0; VAR_0 < MAX_PICTURE_COUNT; VAR_0++) {

        s->picture[VAR_0].f = av_frame_alloc();

        if (!s->picture[VAR_0].f)

            goto fail;

    }

    memset(&s->next_picture, 0, sizeof(s->next_picture));

    memset(&s->last_picture, 0, sizeof(s->last_picture));

    memset(&s->current_picture, 0, sizeof(s->current_picture));

    memset(&s->new_picture, 0, sizeof(s->new_picture));

    s->next_picture.f = av_frame_alloc();

    if (!s->next_picture.f)

        goto fail;

    s->last_picture.f = av_frame_alloc();

    if (!s->last_picture.f)

        goto fail;

    s->current_picture.f = av_frame_alloc();

    if (!s->current_picture.f)

        goto fail;

    s->new_picture.f = av_frame_alloc();

    if (!s->new_picture.f)

        goto fail;



        if (init_context_frame(s))

            goto fail;



        s->parse_context.state = -1;



        s->context_initialized = 1;

        memset(s->thread_context, 0, sizeof(s->thread_context));

        s->thread_context[0]   = s;





        if (VAR_1 > 1) {

            for (VAR_0 = 0; VAR_0 < VAR_1; VAR_0++) {

                if (VAR_0) {

                    s->thread_context[VAR_0] = av_memdup(s, sizeof(MpegEncContext));

                    if (!s->thread_context[VAR_0])

                        goto fail;

                }

                if (init_duplicate_context(s->thread_context[VAR_0]) < 0)

                    goto fail;

                    s->thread_context[VAR_0]->start_mb_y =

                        (s->mb_height * (VAR_0) + VAR_1 / 2) / VAR_1;

                    s->thread_context[VAR_0]->end_mb_y   =

                        (s->mb_height * (VAR_0 + 1) + VAR_1 / 2) / VAR_1;

            }

        } else {

            if (init_duplicate_context(s) < 0)

                goto fail;

            s->start_mb_y = 0;

            s->end_mb_y   = s->mb_height;

        }

        s->slice_context_count = VAR_1;





    return 0;

 fail:

    ff_mpv_common_end(s);

    return -1;

}

av_cold int FUNC_0(MpegEncContext *s)
{ int VAR_0; int VAR_1 = (HAVE_THREADS &&
s->avctx->active_thread_type & FF_THREAD_SLICE) ?
s->avctx->thread_count : 1; if (s->encoding && s->avctx->slices)
VAR_1 = s->avctx->slices; if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
s->mb_height = (s->height + 31) / 32 * 2; else
s->mb_height = (s->height + 15) / 16; if (s->avctx->pix_fmt == AV_PIX_FMT_NONE) { av_log(s->avctx, AV_LOG_ERROR,
"decoding to AV_PIX_FMT_NONE is not supported.\n"); return -1; } if (VAR_1 > MAX_THREADS || (VAR_1 > s->mb_height && s->mb_height)) { int VAR_2; if (s->mb_height)
VAR_2 = FFMIN(MAX_THREADS, s->mb_height); else
VAR_2 = MAX_THREADS; av_log(s->avctx, AV_LOG_WARNING, "too many threads/slices (%d),"
" reducing to %d\n", VAR_1, VAR_2); VAR_1 = VAR_2; } if ((s->width || s->height) &&
av_image_check_size(s->width, s->height, 0, s->avctx))
return -1; dct_init(s); avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,
&s->chroma_x_shift,
&s->chroma_y_shift); FF_ALLOCZ_OR_GOTO(s->avctx, s->picture,
MAX_PICTURE_COUNT * sizeof(Picture), fail); for (VAR_0 = 0; VAR_0 < MAX_PICTURE_COUNT; VAR_0++) { s->picture[VAR_0].f = av_frame_alloc(); if (!s->picture[VAR_0].f)
goto fail; } memset(&s->next_picture, 0, sizeof(s->next_picture)); memset(&s->last_picture, 0, sizeof(s->last_picture)); memset(&s->current_picture, 0, sizeof(s->current_picture)); memset(&s->new_picture, 0, sizeof(s->new_picture)); s->next_picture.f = av_frame_alloc(); if (!s->next_picture.f)
goto fail; s->last_picture.f = av_frame_alloc(); if (!s->last_picture.f)
goto fail; s->current_picture.f = av_frame_alloc(); if (!s->current_picture.f)
goto fail; s->new_picture.f = av_frame_alloc(); if (!s->new_picture.f)
goto fail; if (init_context_frame(s))
goto fail; s->parse_context.state = -1; s->context_initialized = 1; memset(s->thread_context, 0, sizeof(s->thread_context)); s->thread_context[0]   = s; if (VAR_1 > 1) { for (VAR_0 = 0; VAR_0 < VAR_1; VAR_0++) { if (VAR_0) { s->thread_context[VAR_0] = av_memdup(s, sizeof(MpegEncContext)); if (!s->thread_context[VAR_0])
goto fail; } if (init_duplicate_context(s->thread_context[VAR_0]) < 0)
goto fail; s->thread_context[VAR_0]->start_mb_y =
(s->mb_height * (VAR_0) + VAR_1 / 2) / VAR_1; s->thread_context[VAR_0]->end_mb_y   =
(s->mb_height * (VAR_0 + 1) + VAR_1 / 2) / VAR_1; } } else { if (init_duplicate_context(s) < 0)
goto fail; s->start_mb_y = 0; s->end_mb_y   = s->mb_height; } s->slice_context_count = VAR_1; return 0; fail:
ff_mpv_common_end(s); return -1; }