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