[deb_ffmpeg.git] / ffmpeg / libavcodec / vp5.c

/*
 * Copyright (C) 2006  Aurelien Jacobs <aurel@gnuage.org>
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

/**
 * @file
 * VP5 compatible video decoder
 */

#include <stdlib.h>
#include <string.h>

#include "avcodec.h"
#include "get_bits.h"
#include "internal.h"

#include "vp56.h"
#include "vp56data.h"
#include "vp5data.h"


static int vp5_parse_header(VP56Context *s, const uint8_t *buf, int buf_size)
{
    VP56RangeCoder *c = &s->c;
    int rows, cols;

    ff_vp56_init_range_decoder(&s->c, buf, buf_size);
    s->frames[VP56_FRAME_CURRENT]->key_frame = !vp56_rac_get(c);
    vp56_rac_get(c);
    ff_vp56_init_dequant(s, vp56_rac_gets(c, 6));
    if (s->frames[VP56_FRAME_CURRENT]->key_frame)
    {
        vp56_rac_gets(c, 8);
        if(vp56_rac_gets(c, 5) > 5)
            return AVERROR_INVALIDDATA;
        vp56_rac_gets(c, 2);
        if (vp56_rac_get(c)) {
            av_log(s->avctx, AV_LOG_ERROR, "interlacing not supported\n");
            return AVERROR_PATCHWELCOME;
        }
        rows = vp56_rac_gets(c, 8);  /* number of stored macroblock rows */
        cols = vp56_rac_gets(c, 8);  /* number of stored macroblock cols */
        if (!rows || !cols) {
            av_log(s->avctx, AV_LOG_ERROR, "Invalid size %dx%d\n",
                   cols << 4, rows << 4);
            return AVERROR_INVALIDDATA;
        }
        vp56_rac_gets(c, 8);  /* number of displayed macroblock rows */
        vp56_rac_gets(c, 8);  /* number of displayed macroblock cols */
        vp56_rac_gets(c, 2);
        if (!s->macroblocks || /* first frame */
            16*cols != s->avctx->coded_width ||
            16*rows != s->avctx->coded_height) {
            int ret = ff_set_dimensions(s->avctx, 16 * cols, 16 * rows);
            if (ret < 0)
                return ret;
            return VP56_SIZE_CHANGE;
        }
    } else if (!s->macroblocks)
        return AVERROR_INVALIDDATA;
    return 0;
}

static void vp5_parse_vector_adjustment(VP56Context *s, VP56mv *vect)
{
    VP56RangeCoder *c = &s->c;
    VP56Model *model = s->modelp;
    int comp, di;

    for (comp=0; comp<2; comp++) {
        int delta = 0;
        if (vp56_rac_get_prob_branchy(c, model->vector_dct[comp])) {
            int sign = vp56_rac_get_prob(c, model->vector_sig[comp]);
            di  = vp56_rac_get_prob(c, model->vector_pdi[comp][0]);
            di |= vp56_rac_get_prob(c, model->vector_pdi[comp][1]) << 1;
            delta = vp56_rac_get_tree(c, ff_vp56_pva_tree,
                                      model->vector_pdv[comp]);
            delta = di | (delta << 2);
            delta = (delta ^ -sign) + sign;
        }
        if (!comp)
            vect->x = delta;
        else
            vect->y = delta;
    }
}

static void vp5_parse_vector_models(VP56Context *s)
{
    VP56RangeCoder *c = &s->c;
    VP56Model *model = s->modelp;
    int comp, node;

    for (comp=0; comp<2; comp++) {
        if (vp56_rac_get_prob_branchy(c, vp5_vmc_pct[comp][0]))
            model->vector_dct[comp] = vp56_rac_gets_nn(c, 7);
        if (vp56_rac_get_prob_branchy(c, vp5_vmc_pct[comp][1]))
            model->vector_sig[comp] = vp56_rac_gets_nn(c, 7);
        if (vp56_rac_get_prob_branchy(c, vp5_vmc_pct[comp][2]))
            model->vector_pdi[comp][0] = vp56_rac_gets_nn(c, 7);
        if (vp56_rac_get_prob_branchy(c, vp5_vmc_pct[comp][3]))
            model->vector_pdi[comp][1] = vp56_rac_gets_nn(c, 7);
    }

    for (comp=0; comp<2; comp++)
        for (node=0; node<7; node++)
            if (vp56_rac_get_prob_branchy(c, vp5_vmc_pct[comp][4 + node]))
                model->vector_pdv[comp][node] = vp56_rac_gets_nn(c, 7);
}

static int vp5_parse_coeff_models(VP56Context *s)
{
    VP56RangeCoder *c = &s->c;
    VP56Model *model = s->modelp;
    uint8_t def_prob[11];
    int node, cg, ctx;
    int ct;    /* code type */
    int pt;    /* plane type (0 for Y, 1 for U or V) */

    memset(def_prob, 0x80, sizeof(def_prob));

    for (pt=0; pt<2; pt++)
        for (node=0; node<11; node++)
            if (vp56_rac_get_prob_branchy(c, vp5_dccv_pct[pt][node])) {
                def_prob[node] = vp56_rac_gets_nn(c, 7);
                model->coeff_dccv[pt][node] = def_prob[node];
            } else if (s->frames[VP56_FRAME_CURRENT]->key_frame) {
                model->coeff_dccv[pt][node] = def_prob[node];
            }

    for (ct=0; ct<3; ct++)
        for (pt=0; pt<2; pt++)
            for (cg=0; cg<6; cg++)
                for (node=0; node<11; node++)
                    if (vp56_rac_get_prob_branchy(c, vp5_ract_pct[ct][pt][cg][node])) {
                        def_prob[node] = vp56_rac_gets_nn(c, 7);
                        model->coeff_ract[pt][ct][cg][node] = def_prob[node];
                    } else if (s->frames[VP56_FRAME_CURRENT]->key_frame) {
                        model->coeff_ract[pt][ct][cg][node] = def_prob[node];
                    }

    /* coeff_dcct is a linear combination of coeff_dccv */
    for (pt=0; pt<2; pt++)
        for (ctx=0; ctx<36; ctx++)
            for (node=0; node<5; node++)
                model->coeff_dcct[pt][ctx][node] = av_clip(((model->coeff_dccv[pt][node] * vp5_dccv_lc[node][ctx][0] + 128) >> 8) + vp5_dccv_lc[node][ctx][1], 1, 254);

    /* coeff_acct is a linear combination of coeff_ract */
    for (ct=0; ct<3; ct++)
        for (pt=0; pt<2; pt++)
            for (cg=0; cg<3; cg++)
                for (ctx=0; ctx<6; ctx++)
                    for (node=0; node<5; node++)
                        model->coeff_acct[pt][ct][cg][ctx][node] = av_clip(((model->coeff_ract[pt][ct][cg][node] * vp5_ract_lc[ct][cg][node][ctx][0] + 128) >> 8) + vp5_ract_lc[ct][cg][node][ctx][1], 1, 254);
    return 0;
}

static void vp5_parse_coeff(VP56Context *s)
{
    VP56RangeCoder *c = &s->c;
    VP56Model *model = s->modelp;
    uint8_t *permute = s->idct_scantable;
    uint8_t *model1, *model2;
    int coeff, sign, coeff_idx;
    int b, i, cg, idx, ctx, ctx_last;
    int pt = 0;    /* plane type (0 for Y, 1 for U or V) */

    for (b=0; b<6; b++) {
        int ct = 1;    /* code type */

        if (b > 3) pt = 1;

        ctx = 6*s->coeff_ctx[ff_vp56_b6to4[b]][0]
              + s->above_blocks[s->above_block_idx[b]].not_null_dc;
        model1 = model->coeff_dccv[pt];
        model2 = model->coeff_dcct[pt][ctx];

        coeff_idx = 0;
        for (;;) {
            if (vp56_rac_get_prob_branchy(c, model2[0])) {
                if (vp56_rac_get_prob_branchy(c, model2[2])) {
                    if (vp56_rac_get_prob_branchy(c, model2[3])) {
                        s->coeff_ctx[ff_vp56_b6to4[b]][coeff_idx] = 4;
                        idx = vp56_rac_get_tree(c, ff_vp56_pc_tree, model1);
                        sign = vp56_rac_get(c);
                        coeff = ff_vp56_coeff_bias[idx+5];
                        for (i=ff_vp56_coeff_bit_length[idx]; i>=0; i--)
                            coeff += vp56_rac_get_prob(c, ff_vp56_coeff_parse_table[idx][i]) << i;
                    } else {
                        if (vp56_rac_get_prob_branchy(c, model2[4])) {
                            coeff = 3 + vp56_rac_get_prob(c, model1[5]);
                            s->coeff_ctx[ff_vp56_b6to4[b]][coeff_idx] = 3;
                        } else {
                            coeff = 2;
                            s->coeff_ctx[ff_vp56_b6to4[b]][coeff_idx] = 2;
                        }
                        sign = vp56_rac_get(c);
                    }
                    ct = 2;
                } else {
                    ct = 1;
                    s->coeff_ctx[ff_vp56_b6to4[b]][coeff_idx] = 1;
                    sign = vp56_rac_get(c);
                    coeff = 1;
                }
                coeff = (coeff ^ -sign) + sign;
                if (coeff_idx)
                    coeff *= s->dequant_ac;
                s->block_coeff[b][permute[coeff_idx]] = coeff;
            } else {
                if (ct && !vp56_rac_get_prob_branchy(c, model2[1]))
                    break;
                ct = 0;
                s->coeff_ctx[ff_vp56_b6to4[b]][coeff_idx] = 0;
            }
            coeff_idx++;
            if (coeff_idx >= 64)
                break;

            cg = vp5_coeff_groups[coeff_idx];
            ctx = s->coeff_ctx[ff_vp56_b6to4[b]][coeff_idx];
            model1 = model->coeff_ract[pt][ct][cg];
            model2 = cg > 2 ? model1 : model->coeff_acct[pt][ct][cg][ctx];
        }

        ctx_last = FFMIN(s->coeff_ctx_last[ff_vp56_b6to4[b]], 24);
        s->coeff_ctx_last[ff_vp56_b6to4[b]] = coeff_idx;
        if (coeff_idx < ctx_last)
            for (i=coeff_idx; i<=ctx_last; i++)
                s->coeff_ctx[ff_vp56_b6to4[b]][i] = 5;
        s->above_blocks[s->above_block_idx[b]].not_null_dc = s->coeff_ctx[ff_vp56_b6to4[b]][0];
    }
}

static void vp5_default_models_init(VP56Context *s)
{
    VP56Model *model = s->modelp;
    int i;

    for (i=0; i<2; i++) {
        model->vector_sig[i] = 0x80;
        model->vector_dct[i] = 0x80;
        model->vector_pdi[i][0] = 0x55;
        model->vector_pdi[i][1] = 0x80;
    }
    memcpy(model->mb_types_stats, ff_vp56_def_mb_types_stats, sizeof(model->mb_types_stats));
    memset(model->vector_pdv, 0x80, sizeof(model->vector_pdv));
}

static av_cold int vp5_decode_init(AVCodecContext *avctx)
{
    VP56Context *s = avctx->priv_data;
    int ret;

    if ((ret = ff_vp56_init(avctx, 1, 0)) < 0)
        return ret;
    s->vp56_coord_div = vp5_coord_div;
    s->parse_vector_adjustment = vp5_parse_vector_adjustment;
    s->parse_coeff = vp5_parse_coeff;
    s->default_models_init = vp5_default_models_init;
    s->parse_vector_models = vp5_parse_vector_models;
    s->parse_coeff_models = vp5_parse_coeff_models;
    s->parse_header = vp5_parse_header;

    return 0;
}

AVCodec ff_vp5_decoder = {
    .name           = "vp5",
    .long_name      = NULL_IF_CONFIG_SMALL("On2 VP5"),
    .type           = AVMEDIA_TYPE_VIDEO,
    .id             = AV_CODEC_ID_VP5,
    .priv_data_size = sizeof(VP56Context),
    .init           = vp5_decode_init,
    .close          = ff_vp56_free,
    .decode         = ff_vp56_decode_frame,
    .capabilities   = CODEC_CAP_DR1,
};
Commit	Line	Data
2ba45a60 DM	1	/*
	2	* Copyright (C) 2006 Aurelien Jacobs <aurel@gnuage.org>
	3	*
	4	* This file is part of FFmpeg.
	5	*
	6	* FFmpeg is free software; you can redistribute it and/or
	7	* modify it under the terms of the GNU Lesser General Public
	8	* License as published by the Free Software Foundation; either
	9	* version 2.1 of the License, or (at your option) any later version.
	10	*
	11	* FFmpeg is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	14	* Lesser General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU Lesser General Public
	17	* License along with FFmpeg; if not, write to the Free Software
	18	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	19	*/
	20
	21	/**
	22	* @file
	23	* VP5 compatible video decoder
	24	*/
	25
	26	#include <stdlib.h>
	27	#include <string.h>
	28
	29	#include "avcodec.h"
	30	#include "get_bits.h"
	31	#include "internal.h"
	32
	33	#include "vp56.h"
	34	#include "vp56data.h"
	35	#include "vp5data.h"
	36
	37
	38	static int vp5_parse_header(VP56Context s, const uint8_t buf, int buf_size)
	39	{
	40	VP56RangeCoder *c = &s->c;
	41	int rows, cols;
	42
	43	ff_vp56_init_range_decoder(&s->c, buf, buf_size);
	44	s->frames[VP56_FRAME_CURRENT]->key_frame = !vp56_rac_get(c);
	45	vp56_rac_get(c);
	46	ff_vp56_init_dequant(s, vp56_rac_gets(c, 6));
	47	if (s->frames[VP56_FRAME_CURRENT]->key_frame)
	48	{
	49	vp56_rac_gets(c, 8);
	50	if(vp56_rac_gets(c, 5) > 5)
	51	return AVERROR_INVALIDDATA;
	52	vp56_rac_gets(c, 2);
	53	if (vp56_rac_get(c)) {
	54	av_log(s->avctx, AV_LOG_ERROR, "interlacing not supported\n");
	55	return AVERROR_PATCHWELCOME;
	56	}
	57	rows = vp56_rac_gets(c, 8); /* number of stored macroblock rows */
	58	cols = vp56_rac_gets(c, 8); /* number of stored macroblock cols */
	59	if (!rows \|\| !cols) {
	60	av_log(s->avctx, AV_LOG_ERROR, "Invalid size %dx%d\n",
	61	cols << 4, rows << 4);
	62	return AVERROR_INVALIDDATA;
	63	}
	64	vp56_rac_gets(c, 8); /* number of displayed macroblock rows */
65	vp56_rac_gets(c, 8); /* number of displayed macroblock cols */
66	vp56_rac_gets(c, 2);
67	if (!s->macroblocks \|\| /* first frame */
68	16*cols != s->avctx->coded_width \|\|
69	16*rows != s->avctx->coded_height) {
70	int ret = ff_set_dimensions(s->avctx, 16 * cols, 16 * rows);
71	if (ret < 0)
72	return ret;
73	return VP56_SIZE_CHANGE;
74	}
75	} else if (!s->macroblocks)
76	return AVERROR_INVALIDDATA;
77	return 0;
78	}
79
80	static void vp5_parse_vector_adjustment(VP56Context s, VP56mv vect)
81	{
82	VP56RangeCoder *c = &s->c;
83	VP56Model *model = s->modelp;
84	int comp, di;
85
86	for (comp=0; comp<2; comp++) {
87	int delta = 0;
88	if (vp56_rac_get_prob_branchy(c, model->vector_dct[comp])) {
89	int sign = vp56_rac_get_prob(c, model->vector_sig[comp]);
90	di = vp56_rac_get_prob(c, model->vector_pdi[comp][0]);
91	di \|= vp56_rac_get_prob(c, model->vector_pdi[comp][1]) << 1;
92	delta = vp56_rac_get_tree(c, ff_vp56_pva_tree,
93	model->vector_pdv[comp]);
94	delta = di \| (delta << 2);
95	delta = (delta ^ -sign) + sign;
96	}
97	if (!comp)
98	vect->x = delta;
99	else
100	vect->y = delta;
101	}
102	}
103
104	static void vp5_parse_vector_models(VP56Context *s)
105	{
106	VP56RangeCoder *c = &s->c;
107	VP56Model *model = s->modelp;
108	int comp, node;
109
110	for (comp=0; comp<2; comp++) {
111	if (vp56_rac_get_prob_branchy(c, vp5_vmc_pct[comp][0]))
112	model->vector_dct[comp] = vp56_rac_gets_nn(c, 7);
113	if (vp56_rac_get_prob_branchy(c, vp5_vmc_pct[comp][1]))
114	model->vector_sig[comp] = vp56_rac_gets_nn(c, 7);
115	if (vp56_rac_get_prob_branchy(c, vp5_vmc_pct[comp][2]))
116	model->vector_pdi[comp][0] = vp56_rac_gets_nn(c, 7);
117	if (vp56_rac_get_prob_branchy(c, vp5_vmc_pct[comp][3]))
118	model->vector_pdi[comp][1] = vp56_rac_gets_nn(c, 7);
119	}
120
121	for (comp=0; comp<2; comp++)
122	for (node=0; node<7; node++)
123	if (vp56_rac_get_prob_branchy(c, vp5_vmc_pct[comp][4 + node]))
124	model->vector_pdv[comp][node] = vp56_rac_gets_nn(c, 7);
125	}
126
127	static int vp5_parse_coeff_models(VP56Context *s)
128	{
129	VP56RangeCoder *c = &s->c;
130	VP56Model *model = s->modelp;
131	uint8_t def_prob[11];
132	int node, cg, ctx;
133	int ct; /* code type */
134	int pt; /* plane type (0 for Y, 1 for U or V) */
135
136	memset(def_prob, 0x80, sizeof(def_prob));
137
138	for (pt=0; pt<2; pt++)
139	for (node=0; node<11; node++)
140	if (vp56_rac_get_prob_branchy(c, vp5_dccv_pct[pt][node])) {
141	def_prob[node] = vp56_rac_gets_nn(c, 7);
142	model->coeff_dccv[pt][node] = def_prob[node];
143	} else if (s->frames[VP56_FRAME_CURRENT]->key_frame) {
144	model->coeff_dccv[pt][node] = def_prob[node];
145	}
146
147	for (ct=0; ct<3; ct++)
148	for (pt=0; pt<2; pt++)
149	for (cg=0; cg<6; cg++)
150	for (node=0; node<11; node++)
151	if (vp56_rac_get_prob_branchy(c, vp5_ract_pct[ct][pt][cg][node])) {
152	def_prob[node] = vp56_rac_gets_nn(c, 7);
153	model->coeff_ract[pt][ct][cg][node] = def_prob[node];
154	} else if (s->frames[VP56_FRAME_CURRENT]->key_frame) {
155	model->coeff_ract[pt][ct][cg][node] = def_prob[node];
156	}
157
158	/* coeff_dcct is a linear combination of coeff_dccv */
159	for (pt=0; pt<2; pt++)
160	for (ctx=0; ctx<36; ctx++)
161	for (node=0; node<5; node++)
162	model->coeff_dcct[pt][ctx][node] = av_clip(((model->coeff_dccv[pt][node] * vp5_dccv_lc[node][ctx][0] + 128) >> 8) + vp5_dccv_lc[node][ctx][1], 1, 254);
163
164	/* coeff_acct is a linear combination of coeff_ract */
165	for (ct=0; ct<3; ct++)
166	for (pt=0; pt<2; pt++)
167	for (cg=0; cg<3; cg++)
168	for (ctx=0; ctx<6; ctx++)
169	for (node=0; node<5; node++)
170	model->coeff_acct[pt][ct][cg][ctx][node] = av_clip(((model->coeff_ract[pt][ct][cg][node] * vp5_ract_lc[ct][cg][node][ctx][0] + 128) >> 8) + vp5_ract_lc[ct][cg][node][ctx][1], 1, 254);
171	return 0;
172	}
173
174	static void vp5_parse_coeff(VP56Context *s)
175	{
176	VP56RangeCoder *c = &s->c;
177	VP56Model *model = s->modelp;
178	uint8_t *permute = s->idct_scantable;
179	uint8_t model1, model2;
180	int coeff, sign, coeff_idx;
181	int b, i, cg, idx, ctx, ctx_last;
182	int pt = 0; /* plane type (0 for Y, 1 for U or V) */
183
184	for (b=0; b<6; b++) {
185	int ct = 1; /* code type */
186
187	if (b > 3) pt = 1;
188
189	ctx = 6*s->coeff_ctx[ff_vp56_b6to4[b]][0]
190	+ s->above_blocks[s->above_block_idx[b]].not_null_dc;
191	model1 = model->coeff_dccv[pt];
192	model2 = model->coeff_dcct[pt][ctx];
193
194	coeff_idx = 0;
195	for (;;) {
196	if (vp56_rac_get_prob_branchy(c, model2[0])) {
197	if (vp56_rac_get_prob_branchy(c, model2[2])) {
198	if (vp56_rac_get_prob_branchy(c, model2[3])) {
199	s->coeff_ctx[ff_vp56_b6to4[b]][coeff_idx] = 4;
200	idx = vp56_rac_get_tree(c, ff_vp56_pc_tree, model1);
201	sign = vp56_rac_get(c);
202	coeff = ff_vp56_coeff_bias[idx+5];
203	for (i=ff_vp56_coeff_bit_length[idx]; i>=0; i--)
204	coeff += vp56_rac_get_prob(c, ff_vp56_coeff_parse_table[idx][i]) << i;
205	} else {
206	if (vp56_rac_get_prob_branchy(c, model2[4])) {
207	coeff = 3 + vp56_rac_get_prob(c, model1[5]);
208	s->coeff_ctx[ff_vp56_b6to4[b]][coeff_idx] = 3;
209	} else {
210	coeff = 2;
211	s->coeff_ctx[ff_vp56_b6to4[b]][coeff_idx] = 2;
212	}
213	sign = vp56_rac_get(c);
214	}
215	ct = 2;
216	} else {
217	ct = 1;
218	s->coeff_ctx[ff_vp56_b6to4[b]][coeff_idx] = 1;
219	sign = vp56_rac_get(c);
220	coeff = 1;
221	}
222	coeff = (coeff ^ -sign) + sign;
223	if (coeff_idx)
224	coeff *= s->dequant_ac;
225	s->block_coeff[b][permute[coeff_idx]] = coeff;
226	} else {
227	if (ct && !vp56_rac_get_prob_branchy(c, model2[1]))
228	break;
229	ct = 0;
230	s->coeff_ctx[ff_vp56_b6to4[b]][coeff_idx] = 0;
231	}
232	coeff_idx++;
233	if (coeff_idx >= 64)
234	break;
235
236	cg = vp5_coeff_groups[coeff_idx];
237	ctx = s->coeff_ctx[ff_vp56_b6to4[b]][coeff_idx];
238	model1 = model->coeff_ract[pt][ct][cg];
239	model2 = cg > 2 ? model1 : model->coeff_acct[pt][ct][cg][ctx];
240	}
241
242	ctx_last = FFMIN(s->coeff_ctx_last[ff_vp56_b6to4[b]], 24);
243	s->coeff_ctx_last[ff_vp56_b6to4[b]] = coeff_idx;
244	if (coeff_idx < ctx_last)
245	for (i=coeff_idx; i<=ctx_last; i++)
246	s->coeff_ctx[ff_vp56_b6to4[b]][i] = 5;
247	s->above_blocks[s->above_block_idx[b]].not_null_dc = s->coeff_ctx[ff_vp56_b6to4[b]][0];
248	}
249	}
250
251	static void vp5_default_models_init(VP56Context *s)
252	{
253	VP56Model *model = s->modelp;
254	int i;
255
256	for (i=0; i<2; i++) {
257	model->vector_sig[i] = 0x80;
258	model->vector_dct[i] = 0x80;
259	model->vector_pdi[i][0] = 0x55;
260	model->vector_pdi[i][1] = 0x80;
261	}
262	memcpy(model->mb_types_stats, ff_vp56_def_mb_types_stats, sizeof(model->mb_types_stats));
263	memset(model->vector_pdv, 0x80, sizeof(model->vector_pdv));
264	}
265
266	static av_cold int vp5_decode_init(AVCodecContext *avctx)
267	{
268	VP56Context *s = avctx->priv_data;
269	int ret;
270
271	if ((ret = ff_vp56_init(avctx, 1, 0)) < 0)
272	return ret;
273	s->vp56_coord_div = vp5_coord_div;
274	s->parse_vector_adjustment = vp5_parse_vector_adjustment;
275	s->parse_coeff = vp5_parse_coeff;
276	s->default_models_init = vp5_default_models_init;
277	s->parse_vector_models = vp5_parse_vector_models;
278	s->parse_coeff_models = vp5_parse_coeff_models;
279	s->parse_header = vp5_parse_header;
280
281	return 0;
282	}
283
284	AVCodec ff_vp5_decoder = {
285	.name = "vp5",
286	.long_name = NULL_IF_CONFIG_SMALL("On2 VP5"),
287	.type = AVMEDIA_TYPE_VIDEO,
288	.id = AV_CODEC_ID_VP5,
289	.priv_data_size = sizeof(VP56Context),
290	.init = vp5_decode_init,
291	.close = ff_vp56_free,
292	.decode = ff_vp56_decode_frame,
293	.capabilities = CODEC_CAP_DR1,
294	};