FFmpeg coverage

GCC Code Coverage Report

Directory:	../../../ffmpeg/		Exec	Total	Coverage
File:	src/libavcodec/vp5.c	Lines:	174	184	94.6 %
Date:	2020-08-14 10:39:37	Branches:	108	122	88.5 %


/*
 * 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 "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;
    int ret;

    ret = ff_vp56_init_range_decoder(&s->c, buf, buf_size);
    if (ret < 0)
        return ret;
    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)
    {
        int render_x, render_y;

        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)) {
            avpriv_report_missing_feature(s->avctx, "Interlacing");
            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;
        }
        render_y = vp56_rac_gets(c, 8);  /* number of displayed macroblock rows */
        render_x = vp56_rac_gets(c, 8);  /* number of displayed macroblock cols */
        if (render_x == 0 || render_x > cols ||
            render_y == 0 || render_y > rows)
            return AVERROR_INVALIDDATA;
        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 int 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) */

    if (vpX_rac_is_end(c)) {
        av_log(s->avctx, AV_LOG_ERROR, "End of AC stream reached in vp5_parse_coeff\n");
        return AVERROR_INVALIDDATA;
    }

    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];
        s->idct_selector[b] = 63;
    }
    return 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;
    ff_vp5dsp_init(&s->vp56dsp);
    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   = AV_CODEC_CAP_DR1,
};


Generated by: GCOVR (Version 4.2)

Line	Branch	Exec	Source
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 "internal.h"
31
32			#include "vp56.h"
33			#include "vp56data.h"
34			#include "vp5data.h"
35
36
37		247	static int vp5_parse_header(VP56Context s, const uint8_t buf, int buf_size)
38			{
39		247	VP56RangeCoder *c = &s->c;
40			int rows, cols;
41			int ret;
42
43		247	ret = ff_vp56_init_range_decoder(&s->c, buf, buf_size);
44	✗✓	247	if (ret < 0)
45			return ret;
46		247	s->frames[VP56_FRAME_CURRENT]->key_frame = !vp56_rac_get(c);
47		247	vp56_rac_get(c);
48		247	ff_vp56_init_dequant(s, vp56_rac_gets(c, 6));
49	✓✓	247	if (s->frames[VP56_FRAME_CURRENT]->key_frame)
50			{
51			int render_x, render_y;
52
53		5	vp56_rac_gets(c, 8);
54	✗✓	5	if(vp56_rac_gets(c, 5) > 5)
55			return AVERROR_INVALIDDATA;
56		5	vp56_rac_gets(c, 2);
57	✗✓	5	if (vp56_rac_get(c)) {
58			avpriv_report_missing_feature(s->avctx, "Interlacing");
59			return AVERROR_PATCHWELCOME;
60			}
61		5	rows = vp56_rac_gets(c, 8); /* number of stored macroblock rows */
62		5	cols = vp56_rac_gets(c, 8); /* number of stored macroblock cols */
63	✓✗✗✓	5	if (!rows \|\| !cols) {
64			av_log(s->avctx, AV_LOG_ERROR, "Invalid size %dx%d\n",
65			cols << 4, rows << 4);
66			return AVERROR_INVALIDDATA;
67			}
68		5	render_y = vp56_rac_gets(c, 8); /* number of displayed macroblock rows */
69		5	render_x = vp56_rac_gets(c, 8); /* number of displayed macroblock cols */
70	✓✗✓✗ ✓✗	5	if (render_x == 0 \|\| render_x > cols \|\|
71	✗✓	5	render_y == 0 \|\| render_y > rows)
72			return AVERROR_INVALIDDATA;
73		5	vp56_rac_gets(c, 2);
74	✓✓	5	if (!s->macroblocks \|\| /* first frame */
75	✓✗	4	16*cols != s->avctx->coded_width \|\|
76	✗✓	4	16*rows != s->avctx->coded_height) {
77		1	int ret = ff_set_dimensions(s->avctx, 16 * cols, 16 * rows);
78	✗✓	1	if (ret < 0)
79			return ret;
80		1	return VP56_SIZE_CHANGE;
81			}
82	✗✓	242	} else if (!s->macroblocks)
83			return AVERROR_INVALIDDATA;
84		246	return 0;
85			}
86
87		10107	static void vp5_parse_vector_adjustment(VP56Context s, VP56mv vect)
88			{
89		10107	VP56RangeCoder *c = &s->c;
90		10107	VP56Model *model = s->modelp;
91			int comp, di;
92
93	✓✓	30321	for (comp=0; comp<2; comp++) {
94		20214	int delta = 0;
95	✓✓	20214	if (vp56_rac_get_prob_branchy(c, model->vector_dct[comp])) {
96		16164	int sign = vp56_rac_get_prob(c, model->vector_sig[comp]);
97		16164	di = vp56_rac_get_prob(c, model->vector_pdi[comp][0]);
98		16164	di \|= vp56_rac_get_prob(c, model->vector_pdi[comp][1]) << 1;
99		16164	delta = vp56_rac_get_tree(c, ff_vp56_pva_tree,
100		16164	model->vector_pdv[comp]);
101		16164	delta = di \| (delta << 2);
102		16164	delta = (delta ^ -sign) + sign;
103			}
104	✓✓	20214	if (!comp)
105		10107	vect->x = delta;
106			else
107		10107	vect->y = delta;
108			}
109		10107	}
110
111		242	static void vp5_parse_vector_models(VP56Context *s)
112			{
113		242	VP56RangeCoder *c = &s->c;
114		242	VP56Model *model = s->modelp;
115			int comp, node;
116
117	✓✓	726	for (comp=0; comp<2; comp++) {
118	✓✓	484	if (vp56_rac_get_prob_branchy(c, vp5_vmc_pct[comp][0]))
119		5	model->vector_dct[comp] = vp56_rac_gets_nn(c, 7);
120	✓✓	484	if (vp56_rac_get_prob_branchy(c, vp5_vmc_pct[comp][1]))
121		11	model->vector_sig[comp] = vp56_rac_gets_nn(c, 7);
122	✓✓	484	if (vp56_rac_get_prob_branchy(c, vp5_vmc_pct[comp][2]))
123		11	model->vector_pdi[comp][0] = vp56_rac_gets_nn(c, 7);
124	✓✓	484	if (vp56_rac_get_prob_branchy(c, vp5_vmc_pct[comp][3]))
125		9	model->vector_pdi[comp][1] = vp56_rac_gets_nn(c, 7);
126			}
127
128	✓✓	726	for (comp=0; comp<2; comp++)
129	✓✓	3872	for (node=0; node<7; node++)
130	✓✓	3388	if (vp56_rac_get_prob_branchy(c, vp5_vmc_pct[comp][4 + node]))
131		16	model->vector_pdv[comp][node] = vp56_rac_gets_nn(c, 7);
132		242	}
133
134		247	static int vp5_parse_coeff_models(VP56Context *s)
135			{
136		247	VP56RangeCoder *c = &s->c;
137		247	VP56Model *model = s->modelp;
138			uint8_t def_prob[11];
139			int node, cg, ctx;
140			int ct; /* code type */
141			int pt; /* plane type (0 for Y, 1 for U or V) */
142
143		247	memset(def_prob, 0x80, sizeof(def_prob));
144
145	✓✓	741	for (pt=0; pt<2; pt++)
146	✓✓	5928	for (node=0; node<11; node++)
147	✓✓	5434	if (vp56_rac_get_prob_branchy(c, vp5_dccv_pct[pt][node])) {
148		487	def_prob[node] = vp56_rac_gets_nn(c, 7);
149		487	model->coeff_dccv[pt][node] = def_prob[node];
150	✓✓	4947	} else if (s->frames[VP56_FRAME_CURRENT]->key_frame) {
151		92	model->coeff_dccv[pt][node] = def_prob[node];
152			}
153
154	✓✓	988	for (ct=0; ct<3; ct++)
155	✓✓	2223	for (pt=0; pt<2; pt++)
156	✓✓	10374	for (cg=0; cg<6; cg++)
157	✓✓	106704	for (node=0; node<11; node++)
158	✓✓	97812	if (vp56_rac_get_prob_branchy(c, vp5_ract_pct[ct][pt][cg][node])) {
159		1083	def_prob[node] = vp56_rac_gets_nn(c, 7);
160		1083	model->coeff_ract[pt][ct][cg][node] = def_prob[node];
161	✓✓	96729	} else if (s->frames[VP56_FRAME_CURRENT]->key_frame) {
162		1877	model->coeff_ract[pt][ct][cg][node] = def_prob[node];
163			}
164
165			/* coeff_dcct is a linear combination of coeff_dccv */
166	✓✓	741	for (pt=0; pt<2; pt++)
167	✓✓	18278	for (ctx=0; ctx<36; ctx++)
168	✓✓	106704	for (node=0; node<5; node++)
169		88920	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);
170
171			/* coeff_acct is a linear combination of coeff_ract */
172	✓✓	988	for (ct=0; ct<3; ct++)
173	✓✓	2223	for (pt=0; pt<2; pt++)
174	✓✓	5928	for (cg=0; cg<3; cg++)
175	✓✓	31122	for (ctx=0; ctx<6; ctx++)
176	✓✓	160056	for (node=0; node<5; node++)
177		133380	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);
178		247	return 0;
179			}
180
181		149814	static int vp5_parse_coeff(VP56Context *s)
182			{
183		149814	VP56RangeCoder *c = &s->c;
184		149814	VP56Model *model = s->modelp;
185		149814	uint8_t *permute = s->idct_scantable;
186			uint8_t model1, model2;
187			int coeff, sign, coeff_idx;
188			int b, i, cg, idx, ctx, ctx_last;
189		149814	int pt = 0; /* plane type (0 for Y, 1 for U or V) */
190
191	✓✓	149814	if (vpX_rac_is_end(c)) {
192		1	av_log(s->avctx, AV_LOG_ERROR, "End of AC stream reached in vp5_parse_coeff\n");
193		1	return AVERROR_INVALIDDATA;
194			}
195
196	✓✓	1048691	for (b=0; b<6; b++) {
197		898878	int ct = 1; /* code type */
198
199	✓✓	898878	if (b > 3) pt = 1;
200
201		898878	ctx = 6*s->coeff_ctx[ff_vp56_b6to4[b]][0]
202		898878	+ s->above_blocks[s->above_block_idx[b]].not_null_dc;
203		898878	model1 = model->coeff_dccv[pt];
204		898878	model2 = model->coeff_dcct[pt][ctx];
205
206		898878	coeff_idx = 0;
207			for (;;) {
208	✓✓	2385981	if (vp56_rac_get_prob_branchy(c, model2[0])) {
209	✓✓	475835	if (vp56_rac_get_prob_branchy(c, model2[2])) {
210	✓✓	66554	if (vp56_rac_get_prob_branchy(c, model2[3])) {
211		9320	s->coeff_ctx[ff_vp56_b6to4[b]][coeff_idx] = 4;
212		9320	idx = vp56_rac_get_tree(c, ff_vp56_pc_tree, model1);
213		9320	sign = vp56_rac_get(c);
214		9320	coeff = ff_vp56_coeff_bias[idx+5];
215	✓✓	34985	for (i=ff_vp56_coeff_bit_length[idx]; i>=0; i--)
216		25665	coeff += vp56_rac_get_prob(c, ff_vp56_coeff_parse_table[idx][i]) << i;
217			} else {
218	✓✓	57234	if (vp56_rac_get_prob_branchy(c, model2[4])) {
219		13703	coeff = 3 + vp56_rac_get_prob(c, model1[5]);
220		13703	s->coeff_ctx[ff_vp56_b6to4[b]][coeff_idx] = 3;
221			} else {
222		43531	coeff = 2;
223		43531	s->coeff_ctx[ff_vp56_b6to4[b]][coeff_idx] = 2;
224			}
225		57234	sign = vp56_rac_get(c);
226			}
227		66554	ct = 2;
228			} else {
229		409281	ct = 1;
230		409281	s->coeff_ctx[ff_vp56_b6to4[b]][coeff_idx] = 1;
231		409281	sign = vp56_rac_get(c);
232		409281	coeff = 1;
233			}
234		475835	coeff = (coeff ^ -sign) + sign;
235	✓✓	475835	if (coeff_idx)
236		325078	coeff *= s->dequant_ac;
237		475835	s->block_coeff[b][permute[coeff_idx]] = coeff;
238			} else {
239	✓✓✓✓	1910146	if (ct && !vp56_rac_get_prob_branchy(c, model2[1]))
240		898855	break;
241		1011291	ct = 0;
242		1011291	s->coeff_ctx[ff_vp56_b6to4[b]][coeff_idx] = 0;
243			}
244		1487126	coeff_idx++;
245	✓✓	1487126	if (coeff_idx >= 64)
246		23	break;
247
248		1487103	cg = vp5_coeff_groups[coeff_idx];
249		1487103	ctx = s->coeff_ctx[ff_vp56_b6to4[b]][coeff_idx];
250		1487103	model1 = model->coeff_ract[pt][ct][cg];
251	✓✓	1487103	model2 = cg > 2 ? model1 : model->coeff_acct[pt][ct][cg][ctx];
252			}
253
254		898878	ctx_last = FFMIN(s->coeff_ctx_last[ff_vp56_b6to4[b]], 24);
255		898878	s->coeff_ctx_last[ff_vp56_b6to4[b]] = coeff_idx;
256	✓✓	898878	if (coeff_idx < ctx_last)
257	✓✓	1240664	for (i=coeff_idx; i<=ctx_last; i++)
258		1113676	s->coeff_ctx[ff_vp56_b6to4[b]][i] = 5;
259		898878	s->above_blocks[s->above_block_idx[b]].not_null_dc = s->coeff_ctx[ff_vp56_b6to4[b]][0];
260		898878	s->idct_selector[b] = 63;
261			}
262		149813	return 0;
263			}
264
265		5	static void vp5_default_models_init(VP56Context *s)
266			{
267		5	VP56Model *model = s->modelp;
268			int i;
269
270	✓✓	15	for (i=0; i<2; i++) {
271		10	model->vector_sig[i] = 0x80;
272		10	model->vector_dct[i] = 0x80;
273		10	model->vector_pdi[i][0] = 0x55;
274		10	model->vector_pdi[i][1] = 0x80;
275			}
276		5	memcpy(model->mb_types_stats, ff_vp56_def_mb_types_stats, sizeof(model->mb_types_stats));
277		5	memset(model->vector_pdv, 0x80, sizeof(model->vector_pdv));
278		5	}
279
280		2	static av_cold int vp5_decode_init(AVCodecContext *avctx)
281			{
282		2	VP56Context *s = avctx->priv_data;
283			int ret;
284
285	✗✓	2	if ((ret = ff_vp56_init(avctx, 1, 0)) < 0)
286			return ret;
287		2	ff_vp5dsp_init(&s->vp56dsp);
288		2	s->vp56_coord_div = vp5_coord_div;
289		2	s->parse_vector_adjustment = vp5_parse_vector_adjustment;
290		2	s->parse_coeff = vp5_parse_coeff;
291		2	s->default_models_init = vp5_default_models_init;
292		2	s->parse_vector_models = vp5_parse_vector_models;
293		2	s->parse_coeff_models = vp5_parse_coeff_models;
294		2	s->parse_header = vp5_parse_header;
295
296		2	return 0;
297			}
298
299			AVCodec ff_vp5_decoder = {
300			.name = "vp5",
301			.long_name = NULL_IF_CONFIG_SMALL("On2 VP5"),
302			.type = AVMEDIA_TYPE_VIDEO,
303			.id = AV_CODEC_ID_VP5,
304			.priv_data_size = sizeof(VP56Context),
305			.init = vp5_decode_init,
306			.close = ff_vp56_free,
307			.decode = ff_vp56_decode_frame,
308			.capabilities = AV_CODEC_CAP_DR1,
309			};