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 |
|
|
}; |