static av_cold int encode_init(AVCodecContext *avctx)

{

    FFV1Context *s = avctx->priv_data;

    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);

    int i, j, k, m, ret;



    if ((ret = ff_ffv1_common_init(avctx)) < 0)

        return ret;



    s->version = 0;



    if ((avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) ||

        avctx->slices > 1)

        s->version = FFMAX(s->version, 2);



    // Unspecified level & slices, we choose version 1.2+ to ensure multithreaded decodability

    if (avctx->slices == 0 && avctx->level < 0 && avctx->width * avctx->height > 720*576)

        s->version = FFMAX(s->version, 2);



    if (avctx->level <= 0 && s->version == 2) {

        s->version = 3;

    }

    if (avctx->level >= 0 && avctx->level <= 4) {

        if (avctx->level < s->version) {

            av_log(avctx, AV_LOG_ERROR, "Version %d needed for requested features but %d requested\n", s->version, avctx->level);

            return AVERROR(EINVAL);

        }

        s->version = avctx->level;

    }



    if (s->ec < 0) {

        s->ec = (s->version >= 3);

    }



    if ((s->version == 2 || s->version>3) && avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {

        av_log(avctx, AV_LOG_ERROR, "Version 2 needed for requested features but version 2 is experimental and not enabled\n");

        return AVERROR_INVALIDDATA;

    }



#if FF_API_CODER_TYPE

FF_DISABLE_DEPRECATION_WARNINGS

    if (avctx->coder_type != -1)

        s->ac = avctx->coder_type > 0 ? AC_RANGE_CUSTOM_TAB : AC_GOLOMB_RICE;

    else

FF_ENABLE_DEPRECATION_WARNINGS

#endif

    if (s->ac == 1) // Compatbility with common command line usage

        s->ac = AC_RANGE_CUSTOM_TAB;

    else if (s->ac == AC_RANGE_DEFAULT_TAB_FORCE)

        s->ac = AC_RANGE_DEFAULT_TAB;



    s->plane_count = 3;

    switch(avctx->pix_fmt) {

    case AV_PIX_FMT_YUV444P9:

    case AV_PIX_FMT_YUV422P9:

    case AV_PIX_FMT_YUV420P9:

    case AV_PIX_FMT_YUVA444P9:

    case AV_PIX_FMT_YUVA422P9:

    case AV_PIX_FMT_YUVA420P9:

        if (!avctx->bits_per_raw_sample)

            s->bits_per_raw_sample = 9;

    case AV_PIX_FMT_GRAY10:

    case AV_PIX_FMT_YUV444P10:

    case AV_PIX_FMT_YUV420P10:

    case AV_PIX_FMT_YUV422P10:

    case AV_PIX_FMT_YUVA444P10:

    case AV_PIX_FMT_YUVA422P10:

    case AV_PIX_FMT_YUVA420P10:

        if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)

            s->bits_per_raw_sample = 10;

    case AV_PIX_FMT_GRAY12:

    case AV_PIX_FMT_YUV444P12:

    case AV_PIX_FMT_YUV420P12:

    case AV_PIX_FMT_YUV422P12:

        s->packed_at_lsb = 1;

        if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)

            s->bits_per_raw_sample = 12;

    case AV_PIX_FMT_GRAY16:

    case AV_PIX_FMT_YUV444P16:

    case AV_PIX_FMT_YUV422P16:

    case AV_PIX_FMT_YUV420P16:

    case AV_PIX_FMT_YUVA444P16:

    case AV_PIX_FMT_YUVA422P16:

    case AV_PIX_FMT_YUVA420P16:

        if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) {

            s->bits_per_raw_sample = 16;

        } else if (!s->bits_per_raw_sample) {

            s->bits_per_raw_sample = avctx->bits_per_raw_sample;

        }

        if (s->bits_per_raw_sample <= 8) {

            av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");

            return AVERROR_INVALIDDATA;

        }

        s->version = FFMAX(s->version, 1);

    case AV_PIX_FMT_GRAY8:

    case AV_PIX_FMT_YA8:

    case AV_PIX_FMT_YUV444P:

    case AV_PIX_FMT_YUV440P:

    case AV_PIX_FMT_YUV422P:

    case AV_PIX_FMT_YUV420P:

    case AV_PIX_FMT_YUV411P:

    case AV_PIX_FMT_YUV410P:

    case AV_PIX_FMT_YUVA444P:

    case AV_PIX_FMT_YUVA422P:

    case AV_PIX_FMT_YUVA420P:

        s->chroma_planes = desc->nb_components < 3 ? 0 : 1;

        s->colorspace = 0;

        s->transparency = desc->nb_components == 4 || desc->nb_components == 2;

        if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)

            s->bits_per_raw_sample = 8;

        else if (!s->bits_per_raw_sample)

            s->bits_per_raw_sample = 8;

        break;

    case AV_PIX_FMT_RGB32:

        s->colorspace = 1;

        s->transparency = 1;

        s->chroma_planes = 1;

        s->bits_per_raw_sample = 8;

        break;

    case AV_PIX_FMT_RGB48:

        s->colorspace = 1;

        s->chroma_planes = 1;

        s->bits_per_raw_sample = 16;

        s->use32bit = 1;

        s->version = FFMAX(s->version, 1);

        if (avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {

            av_log(avctx, AV_LOG_ERROR, "16bit RGB is experimental and under development, only use it for experiments\n");

            return AVERROR_INVALIDDATA;

        }

        break;

    case AV_PIX_FMT_0RGB32:

        s->colorspace = 1;

        s->chroma_planes = 1;

        s->bits_per_raw_sample = 8;

        break;

    case AV_PIX_FMT_GBRP9:

        if (!avctx->bits_per_raw_sample)

            s->bits_per_raw_sample = 9;

    case AV_PIX_FMT_GBRP10:

        if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)

            s->bits_per_raw_sample = 10;

    case AV_PIX_FMT_GBRP12:

        if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)

            s->bits_per_raw_sample = 12;

    case AV_PIX_FMT_GBRP14:

        if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)

            s->bits_per_raw_sample = 14;

    case AV_PIX_FMT_GBRP16:

        if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)

            s->bits_per_raw_sample = 16;

        else if (!s->bits_per_raw_sample)

            s->bits_per_raw_sample = avctx->bits_per_raw_sample;

        s->colorspace = 1;

        s->chroma_planes = 1;

        if (s->bits_per_raw_sample >= 16) {

            s->use32bit = 1;

            if (avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {

                av_log(avctx, AV_LOG_ERROR, "16bit RGB is experimental and under development, only use it for experiments\n");

                return AVERROR_INVALIDDATA;

            }

        }

        s->version = FFMAX(s->version, 1);

        break;

    default:

        av_log(avctx, AV_LOG_ERROR, "format not supported\n");

        return AVERROR(ENOSYS);

    }

    av_assert0(s->bits_per_raw_sample >= 8);



    if (s->bits_per_raw_sample > 8) {

        if (s->ac == AC_GOLOMB_RICE) {

            av_log(avctx, AV_LOG_INFO,

                    "bits_per_raw_sample > 8, forcing range coder\n");

            s->ac = AC_RANGE_CUSTOM_TAB;

        }

    }

    if (s->transparency) {

        av_log(avctx, AV_LOG_WARNING, "Storing alpha plane, this will require a recent FFV1 decoder to playback!\n");

    }

#if FF_API_PRIVATE_OPT

FF_DISABLE_DEPRECATION_WARNINGS

    if (avctx->context_model)

        s->context_model = avctx->context_model;

    if (avctx->context_model > 1U) {

        av_log(avctx, AV_LOG_ERROR, "Invalid context model %d, valid values are 0 and 1\n", avctx->context_model);

        return AVERROR(EINVAL);

    }

FF_ENABLE_DEPRECATION_WARNINGS

#endif



    if (s->ac == AC_RANGE_CUSTOM_TAB) {

        for (i = 1; i < 256; i++)

            s->state_transition[i] = ver2_state[i];

    } else {

        RangeCoder c;

        ff_build_rac_states(&c, 0.05 * (1LL << 32), 256 - 8);

        for (i = 1; i < 256; i++)

            s->state_transition[i] = c.one_state[i];

    }



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

        s->quant_table_count = 2;

        if (s->bits_per_raw_sample <= 8) {

            s->quant_tables[0][0][i]=           quant11[i];

            s->quant_tables[0][1][i]=        11*quant11[i];

            s->quant_tables[0][2][i]=     11*11*quant11[i];

            s->quant_tables[1][0][i]=           quant11[i];

            s->quant_tables[1][1][i]=        11*quant11[i];

            s->quant_tables[1][2][i]=     11*11*quant5 [i];

            s->quant_tables[1][3][i]=   5*11*11*quant5 [i];

            s->quant_tables[1][4][i]= 5*5*11*11*quant5 [i];

        } else {

            s->quant_tables[0][0][i]=           quant9_10bit[i];

            s->quant_tables[0][1][i]=        11*quant9_10bit[i];

            s->quant_tables[0][2][i]=     11*11*quant9_10bit[i];

            s->quant_tables[1][0][i]=           quant9_10bit[i];

            s->quant_tables[1][1][i]=        11*quant9_10bit[i];

            s->quant_tables[1][2][i]=     11*11*quant5_10bit[i];

            s->quant_tables[1][3][i]=   5*11*11*quant5_10bit[i];

            s->quant_tables[1][4][i]= 5*5*11*11*quant5_10bit[i];

        }

    }

    s->context_count[0] = (11 * 11 * 11        + 1) / 2;

    s->context_count[1] = (11 * 11 * 5 * 5 * 5 + 1) / 2;

    memcpy(s->quant_table, s->quant_tables[s->context_model],

           sizeof(s->quant_table));



    for (i = 0; i < s->plane_count; i++) {

        PlaneContext *const p = &s->plane[i];



        memcpy(p->quant_table, s->quant_table, sizeof(p->quant_table));

        p->quant_table_index = s->context_model;

        p->context_count     = s->context_count[p->quant_table_index];

    }



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

        return ret;



#if FF_API_CODED_FRAME

FF_DISABLE_DEPRECATION_WARNINGS

    avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;

FF_ENABLE_DEPRECATION_WARNINGS

#endif



    if (!s->transparency)

        s->plane_count = 2;

    if (!s->chroma_planes && s->version > 3)

        s->plane_count--;



    avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);

    s->picture_number = 0;



    if (avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) {

        for (i = 0; i < s->quant_table_count; i++) {

            s->rc_stat2[i] = av_mallocz(s->context_count[i] *

                                        sizeof(*s->rc_stat2[i]));

            if (!s->rc_stat2[i])

                return AVERROR(ENOMEM);

        }

    }

    if (avctx->stats_in) {

        char *p = avctx->stats_in;

        uint8_t (*best_state)[256] = av_malloc_array(256, 256);

        int gob_count = 0;

        char *next;

        if (!best_state)

            return AVERROR(ENOMEM);



        av_assert0(s->version >= 2);



        for (;;) {

            for (j = 0; j < 256; j++)

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

                    s->rc_stat[j][i] = strtol(p, &next, 0);

                    if (next == p) {

                        av_log(avctx, AV_LOG_ERROR,

                               "2Pass file invalid at %d %d [%s]\n", j, i, p);

                        av_freep(&best_state);

                        return AVERROR_INVALIDDATA;

                    }

                    p = next;

                }

            for (i = 0; i < s->quant_table_count; i++)

                for (j = 0; j < s->context_count[i]; j++) {

                    for (k = 0; k < 32; k++)

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

                            s->rc_stat2[i][j][k][m] = strtol(p, &next, 0);

                            if (next == p) {

                                av_log(avctx, AV_LOG_ERROR,

                                       "2Pass file invalid at %d %d %d %d [%s]\n",

                                       i, j, k, m, p);

                                av_freep(&best_state);

                                return AVERROR_INVALIDDATA;

                            }

                            p = next;

                        }

                }

            gob_count = strtol(p, &next, 0);

            if (next == p || gob_count <= 0) {

                av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");

                av_freep(&best_state);

                return AVERROR_INVALIDDATA;

            }

            p = next;

            while (*p == '\n' || *p == ' ')

                p++;

            if (p[0] == 0)

                break;

        }

        if (s->ac == AC_RANGE_CUSTOM_TAB)

            sort_stt(s, s->state_transition);



        find_best_state(best_state, s->state_transition);



        for (i = 0; i < s->quant_table_count; i++) {

            for (k = 0; k < 32; k++) {

                double a=0, b=0;

                int jp = 0;

                for (j = 0; j < s->context_count[i]; j++) {

                    double p = 128;

                    if (s->rc_stat2[i][j][k][0] + s->rc_stat2[i][j][k][1] > 200 && j || a+b > 200) {

                        if (a+b)

                            p = 256.0 * b / (a + b);

                        s->initial_states[i][jp][k] =

                            best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];

                        for(jp++; jp<j; jp++)

                            s->initial_states[i][jp][k] = s->initial_states[i][jp-1][k];

                        a=b=0;

                    }

                    a += s->rc_stat2[i][j][k][0];

                    b += s->rc_stat2[i][j][k][1];

                    if (a+b) {

                        p = 256.0 * b / (a + b);

                    }

                    s->initial_states[i][j][k] =

                        best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];

                }

            }

        }

        av_freep(&best_state);

    }



    if (s->version > 1) {

        int plane_count = 1 + 2*s->chroma_planes + s->transparency;

        s->num_v_slices = (avctx->width > 352 || avctx->height > 288 || !avctx->slices) ? 2 : 1;



        if (avctx->height < 5)

            s->num_v_slices = 1;



        for (; s->num_v_slices < 32; s->num_v_slices++) {

            for (s->num_h_slices = s->num_v_slices; s->num_h_slices < 2*s->num_v_slices; s->num_h_slices++) {

                int maxw = (avctx->width  + s->num_h_slices - 1) / s->num_h_slices;

                int maxh = (avctx->height + s->num_v_slices - 1) / s->num_v_slices;

                if (s->num_h_slices > avctx->width || s->num_v_slices > avctx->height)

                    continue;

                if (maxw * maxh * (int64_t)(s->bits_per_raw_sample+1) * plane_count > 8<<24)

                    continue;

                if (avctx->slices == s->num_h_slices * s->num_v_slices && avctx->slices <= MAX_SLICES || !avctx->slices)

                    goto slices_ok;

            }

        }

        av_log(avctx, AV_LOG_ERROR,

               "Unsupported number %d of slices requested, please specify a "

               "supported number with -slices (ex:4,6,9,12,16, ...)\n",

               avctx->slices);

        return AVERROR(ENOSYS);

slices_ok:

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

            return ret;

    }



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

        return ret;

    s->slice_count = s->max_slice_count;

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

        return ret;



#define STATS_OUT_SIZE 1024 * 1024 * 6

    if (avctx->flags & AV_CODEC_FLAG_PASS1) {

        avctx->stats_out = av_mallocz(STATS_OUT_SIZE);

        if (!avctx->stats_out)

            return AVERROR(ENOMEM);

        for (i = 0; i < s->quant_table_count; i++)

            for (j = 0; j < s->max_slice_count; j++) {

                FFV1Context *sf = s->slice_context[j];

                av_assert0(!sf->rc_stat2[i]);

                sf->rc_stat2[i] = av_mallocz(s->context_count[i] *

                                             sizeof(*sf->rc_stat2[i]));

                if (!sf->rc_stat2[i])

                    return AVERROR(ENOMEM);

            }

    }



    return 0;

}

static av_cold int encode_init(AVCodecContext *avctx)

{

    FFV1Context *s = avctx->priv_data;

    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);

    int i, j, k, m, ret;



    if ((ret = ff_ffv1_common_init(avctx)) < 0)

        return ret;



    s->version = 0;



    if ((avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) ||

        avctx->slices > 1)

        s->version = FFMAX(s->version, 2);



    

    if (avctx->slices == 0 && avctx->level < 0 && avctx->width * avctx->height > 720*576)

        s->version = FFMAX(s->version, 2);



    if (avctx->level <= 0 && s->version == 2) {

        s->version = 3;

    }

    if (avctx->level >= 0 && avctx->level <= 4) {

        if (avctx->level < s->version) {

            av_log(avctx, AV_LOG_ERROR, "Version %d needed for requested features but %d requested\n", s->version, avctx->level);

            return AVERROR(EINVAL);

        }

        s->version = avctx->level;

    }



    if (s->ec < 0) {

        s->ec = (s->version >= 3);

    }



    if ((s->version == 2 || s->version>3) && avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {

        av_log(avctx, AV_LOG_ERROR, "Version 2 needed for requested features but version 2 is experimental and not enabled\n");

        return AVERROR_INVALIDDATA;

    }



#if FF_API_CODER_TYPE

FF_DISABLE_DEPRECATION_WARNINGS

    if (avctx->coder_type != -1)

        s->ac = avctx->coder_type > 0 ? AC_RANGE_CUSTOM_TAB : AC_GOLOMB_RICE;

    else

FF_ENABLE_DEPRECATION_WARNINGS

#endif

    if (s->ac == 1) 

        s->ac = AC_RANGE_CUSTOM_TAB;

    else if (s->ac == AC_RANGE_DEFAULT_TAB_FORCE)

        s->ac = AC_RANGE_DEFAULT_TAB;



    s->plane_count = 3;

    switch(avctx->pix_fmt) {

    case AV_PIX_FMT_YUV444P9:

    case AV_PIX_FMT_YUV422P9:

    case AV_PIX_FMT_YUV420P9:

    case AV_PIX_FMT_YUVA444P9:

    case AV_PIX_FMT_YUVA422P9:

    case AV_PIX_FMT_YUVA420P9:

        if (!avctx->bits_per_raw_sample)

            s->bits_per_raw_sample = 9;

    case AV_PIX_FMT_GRAY10:

    case AV_PIX_FMT_YUV444P10:

    case AV_PIX_FMT_YUV420P10:

    case AV_PIX_FMT_YUV422P10:

    case AV_PIX_FMT_YUVA444P10:

    case AV_PIX_FMT_YUVA422P10:

    case AV_PIX_FMT_YUVA420P10:

        if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)

            s->bits_per_raw_sample = 10;

    case AV_PIX_FMT_GRAY12:

    case AV_PIX_FMT_YUV444P12:

    case AV_PIX_FMT_YUV420P12:

    case AV_PIX_FMT_YUV422P12:

        s->packed_at_lsb = 1;

        if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)

            s->bits_per_raw_sample = 12;

    case AV_PIX_FMT_GRAY16:

    case AV_PIX_FMT_YUV444P16:

    case AV_PIX_FMT_YUV422P16:

    case AV_PIX_FMT_YUV420P16:

    case AV_PIX_FMT_YUVA444P16:

    case AV_PIX_FMT_YUVA422P16:

    case AV_PIX_FMT_YUVA420P16:

        if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) {

            s->bits_per_raw_sample = 16;

        } else if (!s->bits_per_raw_sample) {

            s->bits_per_raw_sample = avctx->bits_per_raw_sample;

        }

        if (s->bits_per_raw_sample <= 8) {

            av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");

            return AVERROR_INVALIDDATA;

        }

        s->version = FFMAX(s->version, 1);

    case AV_PIX_FMT_GRAY8:

    case AV_PIX_FMT_YA8:

    case AV_PIX_FMT_YUV444P:

    case AV_PIX_FMT_YUV440P:

    case AV_PIX_FMT_YUV422P:

    case AV_PIX_FMT_YUV420P:

    case AV_PIX_FMT_YUV411P:

    case AV_PIX_FMT_YUV410P:

    case AV_PIX_FMT_YUVA444P:

    case AV_PIX_FMT_YUVA422P:

    case AV_PIX_FMT_YUVA420P:

        s->chroma_planes = desc->nb_components < 3 ? 0 : 1;

        s->colorspace = 0;

        s->transparency = desc->nb_components == 4 || desc->nb_components == 2;

        if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)

            s->bits_per_raw_sample = 8;

        else if (!s->bits_per_raw_sample)

            s->bits_per_raw_sample = 8;

        break;

    case AV_PIX_FMT_RGB32:

        s->colorspace = 1;

        s->transparency = 1;

        s->chroma_planes = 1;

        s->bits_per_raw_sample = 8;

        break;

    case AV_PIX_FMT_RGB48:

        s->colorspace = 1;

        s->chroma_planes = 1;

        s->bits_per_raw_sample = 16;

        s->use32bit = 1;

        s->version = FFMAX(s->version, 1);

        if (avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {

            av_log(avctx, AV_LOG_ERROR, "16bit RGB is experimental and under development, only use it for experiments\n");

            return AVERROR_INVALIDDATA;

        }

        break;

    case AV_PIX_FMT_0RGB32:

        s->colorspace = 1;

        s->chroma_planes = 1;

        s->bits_per_raw_sample = 8;

        break;

    case AV_PIX_FMT_GBRP9:

        if (!avctx->bits_per_raw_sample)

            s->bits_per_raw_sample = 9;

    case AV_PIX_FMT_GBRP10:

        if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)

            s->bits_per_raw_sample = 10;

    case AV_PIX_FMT_GBRP12:

        if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)

            s->bits_per_raw_sample = 12;

    case AV_PIX_FMT_GBRP14:

        if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)

            s->bits_per_raw_sample = 14;

    case AV_PIX_FMT_GBRP16:

        if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)

            s->bits_per_raw_sample = 16;

        else if (!s->bits_per_raw_sample)

            s->bits_per_raw_sample = avctx->bits_per_raw_sample;

        s->colorspace = 1;

        s->chroma_planes = 1;

        if (s->bits_per_raw_sample >= 16) {

            s->use32bit = 1;

            if (avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {

                av_log(avctx, AV_LOG_ERROR, "16bit RGB is experimental and under development, only use it for experiments\n");

                return AVERROR_INVALIDDATA;

            }

        }

        s->version = FFMAX(s->version, 1);

        break;

    default:

        av_log(avctx, AV_LOG_ERROR, "format not supported\n");

        return AVERROR(ENOSYS);

    }

    av_assert0(s->bits_per_raw_sample >= 8);



    if (s->bits_per_raw_sample > 8) {

        if (s->ac == AC_GOLOMB_RICE) {

            av_log(avctx, AV_LOG_INFO,

                    "bits_per_raw_sample > 8, forcing range coder\n");

            s->ac = AC_RANGE_CUSTOM_TAB;

        }

    }

    if (s->transparency) {

        av_log(avctx, AV_LOG_WARNING, "Storing alpha plane, this will require a recent FFV1 decoder to playback!\n");

    }

#if FF_API_PRIVATE_OPT

FF_DISABLE_DEPRECATION_WARNINGS

    if (avctx->context_model)

        s->context_model = avctx->context_model;

    if (avctx->context_model > 1U) {

        av_log(avctx, AV_LOG_ERROR, "Invalid context model %d, valid values are 0 and 1\n", avctx->context_model);

        return AVERROR(EINVAL);

    }

FF_ENABLE_DEPRECATION_WARNINGS

#endif



    if (s->ac == AC_RANGE_CUSTOM_TAB) {

        for (i = 1; i < 256; i++)

            s->state_transition[i] = ver2_state[i];

    } else {

        RangeCoder c;

        ff_build_rac_states(&c, 0.05 * (1LL << 32), 256 - 8);

        for (i = 1; i < 256; i++)

            s->state_transition[i] = c.one_state[i];

    }



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

        s->quant_table_count = 2;

        if (s->bits_per_raw_sample <= 8) {

            s->quant_tables[0][0][i]=           quant11[i];

            s->quant_tables[0][1][i]=        11*quant11[i];

            s->quant_tables[0][2][i]=     11*11*quant11[i];

            s->quant_tables[1][0][i]=           quant11[i];

            s->quant_tables[1][1][i]=        11*quant11[i];

            s->quant_tables[1][2][i]=     11*11*quant5 [i];

            s->quant_tables[1][3][i]=   5*11*11*quant5 [i];

            s->quant_tables[1][4][i]= 5*5*11*11*quant5 [i];

        } else {

            s->quant_tables[0][0][i]=           quant9_10bit[i];

            s->quant_tables[0][1][i]=        11*quant9_10bit[i];

            s->quant_tables[0][2][i]=     11*11*quant9_10bit[i];

            s->quant_tables[1][0][i]=           quant9_10bit[i];

            s->quant_tables[1][1][i]=        11*quant9_10bit[i];

            s->quant_tables[1][2][i]=     11*11*quant5_10bit[i];

            s->quant_tables[1][3][i]=   5*11*11*quant5_10bit[i];

            s->quant_tables[1][4][i]= 5*5*11*11*quant5_10bit[i];

        }

    }

    s->context_count[0] = (11 * 11 * 11        + 1) / 2;

    s->context_count[1] = (11 * 11 * 5 * 5 * 5 + 1) / 2;

    memcpy(s->quant_table, s->quant_tables[s->context_model],

           sizeof(s->quant_table));



    for (i = 0; i < s->plane_count; i++) {

        PlaneContext *const p = &s->plane[i];



        memcpy(p->quant_table, s->quant_table, sizeof(p->quant_table));

        p->quant_table_index = s->context_model;

        p->context_count     = s->context_count[p->quant_table_index];

    }



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

        return ret;



#if FF_API_CODED_FRAME

FF_DISABLE_DEPRECATION_WARNINGS

    avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;

FF_ENABLE_DEPRECATION_WARNINGS

#endif



    if (!s->transparency)

        s->plane_count = 2;

    if (!s->chroma_planes && s->version > 3)

        s->plane_count--;



    avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);

    s->picture_number = 0;



    if (avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) {

        for (i = 0; i < s->quant_table_count; i++) {

            s->rc_stat2[i] = av_mallocz(s->context_count[i] *

                                        sizeof(*s->rc_stat2[i]));

            if (!s->rc_stat2[i])

                return AVERROR(ENOMEM);

        }

    }

    if (avctx->stats_in) {

        char *p = avctx->stats_in;

        uint8_t (*best_state)[256] = av_malloc_array(256, 256);

        int gob_count = 0;

        char *next;

        if (!best_state)

            return AVERROR(ENOMEM);



        av_assert0(s->version >= 2);



        for (;;) {

            for (j = 0; j < 256; j++)

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

                    s->rc_stat[j][i] = strtol(p, &next, 0);

                    if (next == p) {

                        av_log(avctx, AV_LOG_ERROR,

                               "2Pass file invalid at %d %d [%s]\n", j, i, p);

                        av_freep(&best_state);

                        return AVERROR_INVALIDDATA;

                    }

                    p = next;

                }

            for (i = 0; i < s->quant_table_count; i++)

                for (j = 0; j < s->context_count[i]; j++) {

                    for (k = 0; k < 32; k++)

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

                            s->rc_stat2[i][j][k][m] = strtol(p, &next, 0);

                            if (next == p) {

                                av_log(avctx, AV_LOG_ERROR,

                                       "2Pass file invalid at %d %d %d %d [%s]\n",

                                       i, j, k, m, p);

                                av_freep(&best_state);

                                return AVERROR_INVALIDDATA;

                            }

                            p = next;

                        }

                }

            gob_count = strtol(p, &next, 0);

            if (next == p || gob_count <= 0) {

                av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");

                av_freep(&best_state);

                return AVERROR_INVALIDDATA;

            }

            p = next;

            while (*p == '\n' || *p == ' ')

                p++;

            if (p[0] == 0)

                break;

        }

        if (s->ac == AC_RANGE_CUSTOM_TAB)

            sort_stt(s, s->state_transition);



        find_best_state(best_state, s->state_transition);



        for (i = 0; i < s->quant_table_count; i++) {

            for (k = 0; k < 32; k++) {

                double a=0, b=0;

                int jp = 0;

                for (j = 0; j < s->context_count[i]; j++) {

                    double p = 128;

                    if (s->rc_stat2[i][j][k][0] + s->rc_stat2[i][j][k][1] > 200 && j || a+b > 200) {

                        if (a+b)

                            p = 256.0 * b / (a + b);

                        s->initial_states[i][jp][k] =

                            best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];

                        for(jp++; jp<j; jp++)

                            s->initial_states[i][jp][k] = s->initial_states[i][jp-1][k];

                        a=b=0;

                    }

                    a += s->rc_stat2[i][j][k][0];

                    b += s->rc_stat2[i][j][k][1];

                    if (a+b) {

                        p = 256.0 * b / (a + b);

                    }

                    s->initial_states[i][j][k] =

                        best_state[av_clip(round(p), 1, 255)][av_clip_uint8((a + b) / gob_count)];

                }

            }

        }

        av_freep(&best_state);

    }



    if (s->version > 1) {

        int plane_count = 1 + 2*s->chroma_planes + s->transparency;

        s->num_v_slices = (avctx->width > 352 || avctx->height > 288 || !avctx->slices) ? 2 : 1;



        if (avctx->height < 5)

            s->num_v_slices = 1;



        for (; s->num_v_slices < 32; s->num_v_slices++) {

            for (s->num_h_slices = s->num_v_slices; s->num_h_slices < 2*s->num_v_slices; s->num_h_slices++) {

                int maxw = (avctx->width  + s->num_h_slices - 1) / s->num_h_slices;

                int maxh = (avctx->height + s->num_v_slices - 1) / s->num_v_slices;

                if (s->num_h_slices > avctx->width || s->num_v_slices > avctx->height)

                    continue;

                if (maxw * maxh * (int64_t)(s->bits_per_raw_sample+1) * plane_count > 8<<24)

                    continue;

                if (avctx->slices == s->num_h_slices * s->num_v_slices && avctx->slices <= MAX_SLICES || !avctx->slices)

                    goto slices_ok;

            }

        }

        av_log(avctx, AV_LOG_ERROR,

               "Unsupported number %d of slices requested, please specify a "

               "supported number with -slices (ex:4,6,9,12,16, ...)\n",

               avctx->slices);

        return AVERROR(ENOSYS);

slices_ok:

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

            return ret;

    }



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

        return ret;

    s->slice_count = s->max_slice_count;

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

        return ret;



#define STATS_OUT_SIZE 1024 * 1024 * 6

    if (avctx->flags & AV_CODEC_FLAG_PASS1) {

        avctx->stats_out = av_mallocz(STATS_OUT_SIZE);

        if (!avctx->stats_out)

            return AVERROR(ENOMEM);

        for (i = 0; i < s->quant_table_count; i++)

            for (j = 0; j < s->max_slice_count; j++) {

                FFV1Context *sf = s->slice_context[j];

                av_assert0(!sf->rc_stat2[i]);

                sf->rc_stat2[i] = av_mallocz(s->context_count[i] *

                                             sizeof(*sf->rc_stat2[i]));

                if (!sf->rc_stat2[i])

                    return AVERROR(ENOMEM);

            }

    }



    return 0;

}

static av_cold int FUNC_0(AVCodecContext *avctx)

{

    FFV1Context *s = avctx->priv_data;

    const AVPixFmtDescriptor *VAR_0 = av_pix_fmt_desc_get(avctx->pix_fmt);

    int VAR_1, VAR_2, VAR_3, VAR_4, VAR_5;



    if ((VAR_5 = ff_ffv1_common_init(avctx)) < 0)

        return VAR_5;



    s->version = 0;



    if ((avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) ||

        avctx->slices > 1)

        s->version = FFMAX(s->version, 2);



    

    if (avctx->slices == 0 && avctx->level < 0 && avctx->width * avctx->height > 720*576)

        s->version = FFMAX(s->version, 2);



    if (avctx->level <= 0 && s->version == 2) {

        s->version = 3;

    }

    if (avctx->level >= 0 && avctx->level <= 4) {

        if (avctx->level < s->version) {

            av_log(avctx, AV_LOG_ERROR, "Version %d needed for requested features but %d requested\n", s->version, avctx->level);

            return AVERROR(EINVAL);

        }

        s->version = avctx->level;

    }



    if (s->ec < 0) {

        s->ec = (s->version >= 3);

    }



    if ((s->version == 2 || s->version>3) && avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {

        av_log(avctx, AV_LOG_ERROR, "Version 2 needed for requested features but version 2 is experimental and not enabled\n");

        return AVERROR_INVALIDDATA;

    }



#if FF_API_CODER_TYPE

FF_DISABLE_DEPRECATION_WARNINGS

    if (avctx->coder_type != -1)

        s->ac = avctx->coder_type > 0 ? AC_RANGE_CUSTOM_TAB : AC_GOLOMB_RICE;

    else

FF_ENABLE_DEPRECATION_WARNINGS

#endif

    if (s->ac == 1) 

        s->ac = AC_RANGE_CUSTOM_TAB;

    else if (s->ac == AC_RANGE_DEFAULT_TAB_FORCE)

        s->ac = AC_RANGE_DEFAULT_TAB;



    s->VAR_9 = 3;

    switch(avctx->pix_fmt) {

    case AV_PIX_FMT_YUV444P9:

    case AV_PIX_FMT_YUV422P9:

    case AV_PIX_FMT_YUV420P9:

    case AV_PIX_FMT_YUVA444P9:

    case AV_PIX_FMT_YUVA422P9:

    case AV_PIX_FMT_YUVA420P9:

        if (!avctx->bits_per_raw_sample)

            s->bits_per_raw_sample = 9;

    case AV_PIX_FMT_GRAY10:

    case AV_PIX_FMT_YUV444P10:

    case AV_PIX_FMT_YUV420P10:

    case AV_PIX_FMT_YUV422P10:

    case AV_PIX_FMT_YUVA444P10:

    case AV_PIX_FMT_YUVA422P10:

    case AV_PIX_FMT_YUVA420P10:

        if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)

            s->bits_per_raw_sample = 10;

    case AV_PIX_FMT_GRAY12:

    case AV_PIX_FMT_YUV444P12:

    case AV_PIX_FMT_YUV420P12:

    case AV_PIX_FMT_YUV422P12:

        s->packed_at_lsb = 1;

        if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)

            s->bits_per_raw_sample = 12;

    case AV_PIX_FMT_GRAY16:

    case AV_PIX_FMT_YUV444P16:

    case AV_PIX_FMT_YUV422P16:

    case AV_PIX_FMT_YUV420P16:

    case AV_PIX_FMT_YUVA444P16:

    case AV_PIX_FMT_YUVA422P16:

    case AV_PIX_FMT_YUVA420P16:

        if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) {

            s->bits_per_raw_sample = 16;

        } else if (!s->bits_per_raw_sample) {

            s->bits_per_raw_sample = avctx->bits_per_raw_sample;

        }

        if (s->bits_per_raw_sample <= 8) {

            av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");

            return AVERROR_INVALIDDATA;

        }

        s->version = FFMAX(s->version, 1);

    case AV_PIX_FMT_GRAY8:

    case AV_PIX_FMT_YA8:

    case AV_PIX_FMT_YUV444P:

    case AV_PIX_FMT_YUV440P:

    case AV_PIX_FMT_YUV422P:

    case AV_PIX_FMT_YUV420P:

    case AV_PIX_FMT_YUV411P:

    case AV_PIX_FMT_YUV410P:

    case AV_PIX_FMT_YUVA444P:

    case AV_PIX_FMT_YUVA422P:

    case AV_PIX_FMT_YUVA420P:

        s->chroma_planes = VAR_0->nb_components < 3 ? 0 : 1;

        s->colorspace = 0;

        s->transparency = VAR_0->nb_components == 4 || VAR_0->nb_components == 2;

        if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)

            s->bits_per_raw_sample = 8;

        else if (!s->bits_per_raw_sample)

            s->bits_per_raw_sample = 8;

        break;

    case AV_PIX_FMT_RGB32:

        s->colorspace = 1;

        s->transparency = 1;

        s->chroma_planes = 1;

        s->bits_per_raw_sample = 8;

        break;

    case AV_PIX_FMT_RGB48:

        s->colorspace = 1;

        s->chroma_planes = 1;

        s->bits_per_raw_sample = 16;

        s->use32bit = 1;

        s->version = FFMAX(s->version, 1);

        if (avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {

            av_log(avctx, AV_LOG_ERROR, "16bit RGB is experimental and under development, only use it for experiments\n");

            return AVERROR_INVALIDDATA;

        }

        break;

    case AV_PIX_FMT_0RGB32:

        s->colorspace = 1;

        s->chroma_planes = 1;

        s->bits_per_raw_sample = 8;

        break;

    case AV_PIX_FMT_GBRP9:

        if (!avctx->bits_per_raw_sample)

            s->bits_per_raw_sample = 9;

    case AV_PIX_FMT_GBRP10:

        if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)

            s->bits_per_raw_sample = 10;

    case AV_PIX_FMT_GBRP12:

        if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)

            s->bits_per_raw_sample = 12;

    case AV_PIX_FMT_GBRP14:

        if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)

            s->bits_per_raw_sample = 14;

    case AV_PIX_FMT_GBRP16:

        if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)

            s->bits_per_raw_sample = 16;

        else if (!s->bits_per_raw_sample)

            s->bits_per_raw_sample = avctx->bits_per_raw_sample;

        s->colorspace = 1;

        s->chroma_planes = 1;

        if (s->bits_per_raw_sample >= 16) {

            s->use32bit = 1;

            if (avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {

                av_log(avctx, AV_LOG_ERROR, "16bit RGB is experimental and under development, only use it for experiments\n");

                return AVERROR_INVALIDDATA;

            }

        }

        s->version = FFMAX(s->version, 1);

        break;

    default:

        av_log(avctx, AV_LOG_ERROR, "format not supported\n");

        return AVERROR(ENOSYS);

    }

    av_assert0(s->bits_per_raw_sample >= 8);



    if (s->bits_per_raw_sample > 8) {

        if (s->ac == AC_GOLOMB_RICE) {

            av_log(avctx, AV_LOG_INFO,

                    "bits_per_raw_sample > 8, forcing range coder\n");

            s->ac = AC_RANGE_CUSTOM_TAB;

        }

    }

    if (s->transparency) {

        av_log(avctx, AV_LOG_WARNING, "Storing alpha plane, this will require a recent FFV1 decoder to playback!\n");

    }

#if FF_API_PRIVATE_OPT

FF_DISABLE_DEPRECATION_WARNINGS

    if (avctx->context_model)

        s->context_model = avctx->context_model;

    if (avctx->context_model > 1U) {

        av_log(avctx, AV_LOG_ERROR, "Invalid context model %d, valid values are 0 and 1\n", avctx->context_model);

        return AVERROR(EINVAL);

    }

FF_ENABLE_DEPRECATION_WARNINGS

#endif



    if (s->ac == AC_RANGE_CUSTOM_TAB) {

        for (VAR_1 = 1; VAR_1 < 256; VAR_1++)

            s->state_transition[VAR_1] = ver2_state[VAR_1];

    } else {

        RangeCoder c;

        ff_build_rac_states(&c, 0.05 * (1LL << 32), 256 - 8);

        for (VAR_1 = 1; VAR_1 < 256; VAR_1++)

            s->state_transition[VAR_1] = c.one_state[VAR_1];

    }



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

        s->quant_table_count = 2;

        if (s->bits_per_raw_sample <= 8) {

            s->quant_tables[0][0][VAR_1]=           quant11[VAR_1];

            s->quant_tables[0][1][VAR_1]=        11*quant11[VAR_1];

            s->quant_tables[0][2][VAR_1]=     11*11*quant11[VAR_1];

            s->quant_tables[1][0][VAR_1]=           quant11[VAR_1];

            s->quant_tables[1][1][VAR_1]=        11*quant11[VAR_1];

            s->quant_tables[1][2][VAR_1]=     11*11*quant5 [VAR_1];

            s->quant_tables[1][3][VAR_1]=   5*11*11*quant5 [VAR_1];

            s->quant_tables[1][4][VAR_1]= 5*5*11*11*quant5 [VAR_1];

        } else {

            s->quant_tables[0][0][VAR_1]=           quant9_10bit[VAR_1];

            s->quant_tables[0][1][VAR_1]=        11*quant9_10bit[VAR_1];

            s->quant_tables[0][2][VAR_1]=     11*11*quant9_10bit[VAR_1];

            s->quant_tables[1][0][VAR_1]=           quant9_10bit[VAR_1];

            s->quant_tables[1][1][VAR_1]=        11*quant9_10bit[VAR_1];

            s->quant_tables[1][2][VAR_1]=     11*11*quant5_10bit[VAR_1];

            s->quant_tables[1][3][VAR_1]=   5*11*11*quant5_10bit[VAR_1];

            s->quant_tables[1][4][VAR_1]= 5*5*11*11*quant5_10bit[VAR_1];

        }

    }

    s->context_count[0] = (11 * 11 * 11        + 1) / 2;

    s->context_count[1] = (11 * 11 * 5 * 5 * 5 + 1) / 2;

    memcpy(s->quant_table, s->quant_tables[s->context_model],

           sizeof(s->quant_table));



    for (VAR_1 = 0; VAR_1 < s->VAR_9; VAR_1++) {

        PlaneContext *const VAR_6 = &s->plane[VAR_1];



        memcpy(VAR_6->quant_table, s->quant_table, sizeof(VAR_6->quant_table));

        VAR_6->quant_table_index = s->context_model;

        VAR_6->context_count     = s->context_count[VAR_6->quant_table_index];

    }



    if ((VAR_5 = ff_ffv1_allocate_initial_states(s)) < 0)

        return VAR_5;



#if FF_API_CODED_FRAME

FF_DISABLE_DEPRECATION_WARNINGS

    avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;

FF_ENABLE_DEPRECATION_WARNINGS

#endif



    if (!s->transparency)

        s->VAR_9 = 2;

    if (!s->chroma_planes && s->version > 3)

        s->VAR_9--;



    avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);

    s->picture_number = 0;



    if (avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) {

        for (VAR_1 = 0; VAR_1 < s->quant_table_count; VAR_1++) {

            s->rc_stat2[VAR_1] = av_mallocz(s->context_count[VAR_1] *

                                        sizeof(*s->rc_stat2[VAR_1]));

            if (!s->rc_stat2[VAR_1])

                return AVERROR(ENOMEM);

        }

    }

    if (avctx->stats_in) {

        char *VAR_6 = avctx->stats_in;

        uint8_t (*best_state)[256] = av_malloc_array(256, 256);

        int VAR_7 = 0;

        char *VAR_8;

        if (!best_state)

            return AVERROR(ENOMEM);



        av_assert0(s->version >= 2);



        for (;;) {

            for (VAR_2 = 0; VAR_2 < 256; VAR_2++)

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

                    s->rc_stat[VAR_2][VAR_1] = strtol(VAR_6, &VAR_8, 0);

                    if (VAR_8 == VAR_6) {

                        av_log(avctx, AV_LOG_ERROR,

                               "2Pass file invalid at %d %d [%s]\n", VAR_2, VAR_1, VAR_6);

                        av_freep(&best_state);

                        return AVERROR_INVALIDDATA;

                    }

                    VAR_6 = VAR_8;

                }

            for (VAR_1 = 0; VAR_1 < s->quant_table_count; VAR_1++)

                for (VAR_2 = 0; VAR_2 < s->context_count[VAR_1]; VAR_2++) {

                    for (VAR_3 = 0; VAR_3 < 32; VAR_3++)

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

                            s->rc_stat2[VAR_1][VAR_2][VAR_3][VAR_4] = strtol(VAR_6, &VAR_8, 0);

                            if (VAR_8 == VAR_6) {

                                av_log(avctx, AV_LOG_ERROR,

                                       "2Pass file invalid at %d %d %d %d [%s]\n",

                                       VAR_1, VAR_2, VAR_3, VAR_4, VAR_6);

                                av_freep(&best_state);

                                return AVERROR_INVALIDDATA;

                            }

                            VAR_6 = VAR_8;

                        }

                }

            VAR_7 = strtol(VAR_6, &VAR_8, 0);

            if (VAR_8 == VAR_6 || VAR_7 <= 0) {

                av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");

                av_freep(&best_state);

                return AVERROR_INVALIDDATA;

            }

            VAR_6 = VAR_8;

            while (*VAR_6 == '\n' || *VAR_6 == ' ')

                VAR_6++;

            if (VAR_6[0] == 0)

                break;

        }

        if (s->ac == AC_RANGE_CUSTOM_TAB)

            sort_stt(s, s->state_transition);



        find_best_state(best_state, s->state_transition);



        for (VAR_1 = 0; VAR_1 < s->quant_table_count; VAR_1++) {

            for (VAR_3 = 0; VAR_3 < 32; VAR_3++) {

                double a=0, b=0;

                int jp = 0;

                for (VAR_2 = 0; VAR_2 < s->context_count[VAR_1]; VAR_2++) {

                    double VAR_6 = 128;

                    if (s->rc_stat2[VAR_1][VAR_2][VAR_3][0] + s->rc_stat2[VAR_1][VAR_2][VAR_3][1] > 200 && VAR_2 || a+b > 200) {

                        if (a+b)

                            VAR_6 = 256.0 * b / (a + b);

                        s->initial_states[VAR_1][jp][VAR_3] =

                            best_state[av_clip(round(VAR_6), 1, 255)][av_clip_uint8((a + b) / VAR_7)];

                        for(jp++; jp<VAR_2; jp++)

                            s->initial_states[VAR_1][jp][VAR_3] = s->initial_states[VAR_1][jp-1][VAR_3];

                        a=b=0;

                    }

                    a += s->rc_stat2[VAR_1][VAR_2][VAR_3][0];

                    b += s->rc_stat2[VAR_1][VAR_2][VAR_3][1];

                    if (a+b) {

                        VAR_6 = 256.0 * b / (a + b);

                    }

                    s->initial_states[VAR_1][VAR_2][VAR_3] =

                        best_state[av_clip(round(VAR_6), 1, 255)][av_clip_uint8((a + b) / VAR_7)];

                }

            }

        }

        av_freep(&best_state);

    }



    if (s->version > 1) {

        int VAR_9 = 1 + 2*s->chroma_planes + s->transparency;

        s->num_v_slices = (avctx->width > 352 || avctx->height > 288 || !avctx->slices) ? 2 : 1;



        if (avctx->height < 5)

            s->num_v_slices = 1;



        for (; s->num_v_slices < 32; s->num_v_slices++) {

            for (s->num_h_slices = s->num_v_slices; s->num_h_slices < 2*s->num_v_slices; s->num_h_slices++) {

                int maxw = (avctx->width  + s->num_h_slices - 1) / s->num_h_slices;

                int maxh = (avctx->height + s->num_v_slices - 1) / s->num_v_slices;

                if (s->num_h_slices > avctx->width || s->num_v_slices > avctx->height)

                    continue;

                if (maxw * maxh * (int64_t)(s->bits_per_raw_sample+1) * VAR_9 > 8<<24)

                    continue;

                if (avctx->slices == s->num_h_slices * s->num_v_slices && avctx->slices <= MAX_SLICES || !avctx->slices)

                    goto slices_ok;

            }

        }

        av_log(avctx, AV_LOG_ERROR,

               "Unsupported number %d of slices requested, please specify a "

               "supported number with -slices (ex:4,6,9,12,16, ...)\n",

               avctx->slices);

        return AVERROR(ENOSYS);

slices_ok:

        if ((VAR_5 = write_extradata(s)) < 0)

            return VAR_5;

    }



    if ((VAR_5 = ff_ffv1_init_slice_contexts(s)) < 0)

        return VAR_5;

    s->slice_count = s->max_slice_count;

    if ((VAR_5 = ff_ffv1_init_slices_state(s)) < 0)

        return VAR_5;



#define STATS_OUT_SIZE 1024 * 1024 * 6

    if (avctx->flags & AV_CODEC_FLAG_PASS1) {

        avctx->stats_out = av_mallocz(STATS_OUT_SIZE);

        if (!avctx->stats_out)

            return AVERROR(ENOMEM);

        for (VAR_1 = 0; VAR_1 < s->quant_table_count; VAR_1++)

            for (VAR_2 = 0; VAR_2 < s->max_slice_count; VAR_2++) {

                FFV1Context *sf = s->slice_context[VAR_2];

                av_assert0(!sf->rc_stat2[VAR_1]);

                sf->rc_stat2[VAR_1] = av_mallocz(s->context_count[VAR_1] *

                                             sizeof(*sf->rc_stat2[VAR_1]));

                if (!sf->rc_stat2[VAR_1])

                    return AVERROR(ENOMEM);

            }

    }



    return 0;

}

static av_cold int FUNC_0(AVCodecContext *avctx)
{ FFV1Context *s = avctx->priv_data; const AVPixFmtDescriptor *VAR_0 = av_pix_fmt_desc_get(avctx->pix_fmt); int VAR_1, VAR_2, VAR_3, VAR_4, VAR_5; if ((VAR_5 = ff_ffv1_common_init(avctx)) < 0)
return VAR_5; s->version = 0; if ((avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) ||
avctx->slices > 1)
s->version = FFMAX(s->version, 2); if (avctx->slices == 0 && avctx->level < 0 && avctx->width * avctx->height > 720*576)
s->version = FFMAX(s->version, 2); if (avctx->level <= 0 && s->version == 2) { s->version = 3; } if (avctx->level >= 0 && avctx->level <= 4) { if (avctx->level < s->version) { av_log(avctx, AV_LOG_ERROR, "Version %d needed for requested features but %d requested\n", s->version, avctx->level); return AVERROR(EINVAL); } s->version = avctx->level; } if (s->ec < 0) { s->ec = (s->version >= 3); } if ((s->version == 2 || s->version>3) && avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) { av_log(avctx, AV_LOG_ERROR, "Version 2 needed for requested features but version 2 is experimental and not enabled\n"); return AVERROR_INVALIDDATA; } #if FF_API_CODER_TYPE
FF_DISABLE_DEPRECATION_WARNINGS
if (avctx->coder_type != -1)
s->ac = avctx->coder_type > 0 ? AC_RANGE_CUSTOM_TAB : AC_GOLOMB_RICE; else
FF_ENABLE_DEPRECATION_WARNINGS
#endif
if (s->ac == 1)
s->ac = AC_RANGE_CUSTOM_TAB; else if (s->ac == AC_RANGE_DEFAULT_TAB_FORCE)
s->ac = AC_RANGE_DEFAULT_TAB; s->VAR_9 = 3; switch(avctx->pix_fmt) { case AV_PIX_FMT_YUV444P9:
case AV_PIX_FMT_YUV422P9:
case AV_PIX_FMT_YUV420P9:
case AV_PIX_FMT_YUVA444P9:
case AV_PIX_FMT_YUVA422P9:
case AV_PIX_FMT_YUVA420P9:
if (!avctx->bits_per_raw_sample)
s->bits_per_raw_sample = 9; case AV_PIX_FMT_GRAY10:
case AV_PIX_FMT_YUV444P10:
case AV_PIX_FMT_YUV420P10:
case AV_PIX_FMT_YUV422P10:
case AV_PIX_FMT_YUVA444P10:
case AV_PIX_FMT_YUVA422P10:
case AV_PIX_FMT_YUVA420P10:
if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
s->bits_per_raw_sample = 10; case AV_PIX_FMT_GRAY12:
case AV_PIX_FMT_YUV444P12:
case AV_PIX_FMT_YUV420P12:
case AV_PIX_FMT_YUV422P12:
s->packed_at_lsb = 1; if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
s->bits_per_raw_sample = 12; case AV_PIX_FMT_GRAY16:
case AV_PIX_FMT_YUV444P16:
case AV_PIX_FMT_YUV422P16:
case AV_PIX_FMT_YUV420P16:
case AV_PIX_FMT_YUVA444P16:
case AV_PIX_FMT_YUVA422P16:
case AV_PIX_FMT_YUVA420P16:
if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) { s->bits_per_raw_sample = 16; } else if (!s->bits_per_raw_sample) { s->bits_per_raw_sample = avctx->bits_per_raw_sample; } if (s->bits_per_raw_sample <= 8) { av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n"); return AVERROR_INVALIDDATA; } s->version = FFMAX(s->version, 1); case AV_PIX_FMT_GRAY8:
case AV_PIX_FMT_YA8:
case AV_PIX_FMT_YUV444P:
case AV_PIX_FMT_YUV440P:
case AV_PIX_FMT_YUV422P:
case AV_PIX_FMT_YUV420P:
case AV_PIX_FMT_YUV411P:
case AV_PIX_FMT_YUV410P:
case AV_PIX_FMT_YUVA444P:
case AV_PIX_FMT_YUVA422P:
case AV_PIX_FMT_YUVA420P:
s->chroma_planes = VAR_0->nb_components < 3 ? 0 : 1; s->colorspace = 0; s->transparency = VAR_0->nb_components == 4 || VAR_0->nb_components == 2; if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
s->bits_per_raw_sample = 8; else if (!s->bits_per_raw_sample)
s->bits_per_raw_sample = 8; break; case AV_PIX_FMT_RGB32:
s->colorspace = 1; s->transparency = 1; s->chroma_planes = 1; s->bits_per_raw_sample = 8; break; case AV_PIX_FMT_RGB48:
s->colorspace = 1; s->chroma_planes = 1; s->bits_per_raw_sample = 16; s->use32bit = 1; s->version = FFMAX(s->version, 1); if (avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) { av_log(avctx, AV_LOG_ERROR, "16bit RGB is experimental and under development, only use it for experiments\n"); return AVERROR_INVALIDDATA; } break; case AV_PIX_FMT_0RGB32:
s->colorspace = 1; s->chroma_planes = 1; s->bits_per_raw_sample = 8; break; case AV_PIX_FMT_GBRP9:
if (!avctx->bits_per_raw_sample)
s->bits_per_raw_sample = 9; case AV_PIX_FMT_GBRP10:
if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
s->bits_per_raw_sample = 10; case AV_PIX_FMT_GBRP12:
if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
s->bits_per_raw_sample = 12; case AV_PIX_FMT_GBRP14:
if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
s->bits_per_raw_sample = 14; case AV_PIX_FMT_GBRP16:
if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
s->bits_per_raw_sample = 16; else if (!s->bits_per_raw_sample)
s->bits_per_raw_sample = avctx->bits_per_raw_sample; s->colorspace = 1; s->chroma_planes = 1; if (s->bits_per_raw_sample >= 16) { s->use32bit = 1; if (avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) { av_log(avctx, AV_LOG_ERROR, "16bit RGB is experimental and under development, only use it for experiments\n"); return AVERROR_INVALIDDATA; } } s->version = FFMAX(s->version, 1); break; default:
av_log(avctx, AV_LOG_ERROR, "format not supported\n"); return AVERROR(ENOSYS); } av_assert0(s->bits_per_raw_sample >= 8); if (s->bits_per_raw_sample > 8) { if (s->ac == AC_GOLOMB_RICE) { av_log(avctx, AV_LOG_INFO,
"bits_per_raw_sample > 8, forcing range coder\n"); s->ac = AC_RANGE_CUSTOM_TAB; } } if (s->transparency) { av_log(avctx, AV_LOG_WARNING, "Storing alpha plane, this will require a recent FFV1 decoder to playback!\n"); } #if FF_API_PRIVATE_OPT
FF_DISABLE_DEPRECATION_WARNINGS
if (avctx->context_model)
s->context_model = avctx->context_model; if (avctx->context_model > 1U) { av_log(avctx, AV_LOG_ERROR, "Invalid context model %d, valid values are 0 and 1\n", avctx->context_model); return AVERROR(EINVAL); } FF_ENABLE_DEPRECATION_WARNINGS
#endif
if (s->ac == AC_RANGE_CUSTOM_TAB) { for (VAR_1 = 1; VAR_1 < 256; VAR_1++) s->state_transition[VAR_1] = ver2_state[VAR_1]; } else { RangeCoder c; ff_build_rac_states(&c, 0.05 * (1LL << 32), 256 - 8); for (VAR_1 = 1; VAR_1 < 256; VAR_1++) s->state_transition[VAR_1] = c.one_state[VAR_1]; } for (VAR_1 = 0; VAR_1 < 256; VAR_1++) { s->quant_table_count = 2; if (s->bits_per_raw_sample <= 8) { s->quant_tables[0][0][VAR_1]=           quant11[VAR_1]; s->quant_tables[0][1][VAR_1]=        11*quant11[VAR_1]; s->quant_tables[0][2][VAR_1]=     11*11*quant11[VAR_1]; s->quant_tables[1][0][VAR_1]=           quant11[VAR_1]; s->quant_tables[1][1][VAR_1]=        11*quant11[VAR_1]; s->quant_tables[1][2][VAR_1]=     11*11*quant5 [VAR_1]; s->quant_tables[1][3][VAR_1]=   5*11*11*quant5 [VAR_1]; s->quant_tables[1][4][VAR_1]= 5*5*11*11*quant5 [VAR_1]; } else { s->quant_tables[0][0][VAR_1]=           quant9_10bit[VAR_1]; s->quant_tables[0][1][VAR_1]=        11*quant9_10bit[VAR_1]; s->quant_tables[0][2][VAR_1]=     11*11*quant9_10bit[VAR_1]; s->quant_tables[1][0][VAR_1]=           quant9_10bit[VAR_1]; s->quant_tables[1][1][VAR_1]=        11*quant9_10bit[VAR_1]; s->quant_tables[1][2][VAR_1]=     11*11*quant5_10bit[VAR_1]; s->quant_tables[1][3][VAR_1]=   5*11*11*quant5_10bit[VAR_1]; s->quant_tables[1][4][VAR_1]= 5*5*11*11*quant5_10bit[VAR_1]; } } s->context_count[0] = (11 * 11 * 11        + 1) / 2; s->context_count[1] = (11 * 11 * 5 * 5 * 5 + 1) / 2; memcpy(s->quant_table, s->quant_tables[s->context_model],
sizeof(s->quant_table)); for (VAR_1 = 0; VAR_1 < s->VAR_9; VAR_1++) { PlaneContext *const VAR_6 = &s->plane[VAR_1]; memcpy(VAR_6->quant_table, s->quant_table, sizeof(VAR_6->quant_table)); VAR_6->quant_table_index = s->context_model; VAR_6->context_count     = s->context_count[VAR_6->quant_table_index]; } if ((VAR_5 = ff_ffv1_allocate_initial_states(s)) < 0)
return VAR_5; #if FF_API_CODED_FRAME
FF_DISABLE_DEPRECATION_WARNINGS
avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I; FF_ENABLE_DEPRECATION_WARNINGS
#endif
if (!s->transparency)
s->VAR_9 = 2; if (!s->chroma_planes && s->version > 3)
s->VAR_9--; avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift); s->picture_number = 0; if (avctx->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) { for (VAR_1 = 0; VAR_1 < s->quant_table_count; VAR_1++) { s->rc_stat2[VAR_1] = av_mallocz(s->context_count[VAR_1] *
sizeof(*s->rc_stat2[VAR_1])); if (!s->rc_stat2[VAR_1])
return AVERROR(ENOMEM); } } if (avctx->stats_in) { char *VAR_6 = avctx->stats_in; uint8_t (*best_state)[256] = av_malloc_array(256, 256); int VAR_7 = 0; char *VAR_8; if (!best_state)
return AVERROR(ENOMEM); av_assert0(s->version >= 2); for (;;) { for (VAR_2 = 0; VAR_2 < 256; VAR_2++) for (VAR_1 = 0; VAR_1 < 2; VAR_1++) { s->rc_stat[VAR_2][VAR_1] = strtol(VAR_6, &VAR_8, 0); if (VAR_8 == VAR_6) { av_log(avctx, AV_LOG_ERROR,
"2Pass file invalid at %d %d [%s]\n", VAR_2, VAR_1, VAR_6); av_freep(&best_state); return AVERROR_INVALIDDATA; } VAR_6 = VAR_8; } for (VAR_1 = 0; VAR_1 < s->quant_table_count; VAR_1++) for (VAR_2 = 0; VAR_2 < s->context_count[VAR_1]; VAR_2++) { for (VAR_3 = 0; VAR_3 < 32; VAR_3++) for (VAR_4 = 0; VAR_4 < 2; VAR_4++) { s->rc_stat2[VAR_1][VAR_2][VAR_3][VAR_4] = strtol(VAR_6, &VAR_8, 0); if (VAR_8 == VAR_6) { av_log(avctx, AV_LOG_ERROR,
"2Pass file invalid at %d %d %d %d [%s]\n",
VAR_1, VAR_2, VAR_3, VAR_4, VAR_6); av_freep(&best_state); return AVERROR_INVALIDDATA; } VAR_6 = VAR_8; } } VAR_7 = strtol(VAR_6, &VAR_8, 0); if (VAR_8 == VAR_6 || VAR_7 <= 0) { av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n"); av_freep(&best_state); return AVERROR_INVALIDDATA; } VAR_6 = VAR_8; while (*VAR_6 == '\n' || *VAR_6 == ' ')
VAR_6++; if (VAR_6[0] == 0)
break; } if (s->ac == AC_RANGE_CUSTOM_TAB)
sort_stt(s, s->state_transition); find_best_state(best_state, s->state_transition); for (VAR_1 = 0; VAR_1 < s->quant_table_count; VAR_1++) { for (VAR_3 = 0; VAR_3 < 32; VAR_3++) { double a=0, b=0; int jp = 0; for (VAR_2 = 0; VAR_2 < s->context_count[VAR_1]; VAR_2++) { double VAR_6 = 128; if (s->rc_stat2[VAR_1][VAR_2][VAR_3][0] + s->rc_stat2[VAR_1][VAR_2][VAR_3][1] > 200 && VAR_2 || a+b > 200) { if (a+b)
VAR_6 = 256.0 * b / (a + b); s->initial_states[VAR_1][jp][VAR_3] =
best_state[av_clip(round(VAR_6), 1, 255)][av_clip_uint8((a + b) / VAR_7)]; for(jp++; jp<VAR_2; jp++) s->initial_states[VAR_1][jp][VAR_3] = s->initial_states[VAR_1][jp-1][VAR_3]; a=b=0; } a += s->rc_stat2[VAR_1][VAR_2][VAR_3][0]; b += s->rc_stat2[VAR_1][VAR_2][VAR_3][1]; if (a+b) { VAR_6 = 256.0 * b / (a + b); } s->initial_states[VAR_1][VAR_2][VAR_3] =
best_state[av_clip(round(VAR_6), 1, 255)][av_clip_uint8((a + b) / VAR_7)]; } } } av_freep(&best_state); } if (s->version > 1) { int VAR_9 = 1 + 2*s->chroma_planes + s->transparency; s->num_v_slices = (avctx->width > 352 || avctx->height > 288 || !avctx->slices) ? 2 : 1; if (avctx->height < 5)
s->num_v_slices = 1; for (; s->num_v_slices < 32; s->num_v_slices++) { for (s->num_h_slices = s->num_v_slices; s->num_h_slices < 2*s->num_v_slices; s->num_h_slices++) { int maxw = (avctx->width  + s->num_h_slices - 1) / s->num_h_slices; int maxh = (avctx->height + s->num_v_slices - 1) / s->num_v_slices; if (s->num_h_slices > avctx->width || s->num_v_slices > avctx->height)
continue; if (maxw * maxh * (int64_t)(s->bits_per_raw_sample+1) * VAR_9 > 8<<24)
continue; if (avctx->slices == s->num_h_slices * s->num_v_slices && avctx->slices <= MAX_SLICES || !avctx->slices)
goto slices_ok; } } av_log(avctx, AV_LOG_ERROR,
"Unsupported number %d of slices requested, please specify a "
"supported number with -slices (ex:4,6,9,12,16, ...)\n",
avctx->slices); return AVERROR(ENOSYS); slices_ok:
if ((VAR_5 = write_extradata(s)) < 0)
return VAR_5; } if ((VAR_5 = ff_ffv1_init_slice_contexts(s)) < 0)
return VAR_5; s->slice_count = s->max_slice_count; if ((VAR_5 = ff_ffv1_init_slices_state(s)) < 0)
return VAR_5; #define STATS_OUT_SIZE 1024 * 1024 * 6
if (avctx->flags & AV_CODEC_FLAG_PASS1) { avctx->stats_out = av_mallocz(STATS_OUT_SIZE); if (!avctx->stats_out)
return AVERROR(ENOMEM); for (VAR_1 = 0; VAR_1 < s->quant_table_count; VAR_1++) for (VAR_2 = 0; VAR_2 < s->max_slice_count; VAR_2++) { FFV1Context *sf = s->slice_context[VAR_2]; av_assert0(!sf->rc_stat2[VAR_1]); sf->rc_stat2[VAR_1] = av_mallocz(s->context_count[VAR_1] *
sizeof(*sf->rc_stat2[VAR_1])); if (!sf->rc_stat2[VAR_1])
return AVERROR(ENOMEM); } } return 0; }