ffmpeg / libavcodec / vp6.c @ 72415b2a
History  View  Annotate  Download (21.2 KB)
1 
/**


2 
* @file libavcodec/vp6.c

3 
* VP6 compatible video decoder

4 
*

5 
* Copyright (C) 2006 Aurelien Jacobs <aurel@gnuage.org>

6 
*

7 
* The VP6F decoder accepts an optional 1 byte extradata. It is composed of:

8 
*  upper 4bits: difference between encoded width and visible width

9 
*  lower 4bits: difference between encoded height and visible height

10 
*

11 
* This file is part of FFmpeg.

12 
*

13 
* FFmpeg is free software; you can redistribute it and/or

14 
* modify it under the terms of the GNU Lesser General Public

15 
* License as published by the Free Software Foundation; either

16 
* version 2.1 of the License, or (at your option) any later version.

17 
*

18 
* FFmpeg is distributed in the hope that it will be useful,

19 
* but WITHOUT ANY WARRANTY; without even the implied warranty of

20 
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

21 
* Lesser General Public License for more details.

22 
*

23 
* You should have received a copy of the GNU Lesser General Public

24 
* License along with FFmpeg; if not, write to the Free Software

25 
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 021101301 USA

26 
*/

27  
28 
#include <stdlib.h> 
29  
30 
#include "avcodec.h" 
31 
#include "dsputil.h" 
32 
#include "get_bits.h" 
33 
#include "huffman.h" 
34  
35 
#include "vp56.h" 
36 
#include "vp56data.h" 
37 
#include "vp6data.h" 
38  
39  
40 
static void vp6_parse_coeff(VP56Context *s); 
41 
static void vp6_parse_coeff_huffman(VP56Context *s); 
42  
43 
static int vp6_parse_header(VP56Context *s, const uint8_t *buf, int buf_size, 
44 
int *golden_frame)

45 
{ 
46 
VP56RangeCoder *c = &s>c; 
47 
int parse_filter_info = 0; 
48 
int coeff_offset = 0; 
49 
int vrt_shift = 0; 
50 
int sub_version;

51 
int rows, cols;

52 
int res = 1; 
53 
int separated_coeff = buf[0] & 1; 
54  
55 
s>framep[VP56_FRAME_CURRENT]>key_frame = !(buf[0] & 0x80); 
56 
vp56_init_dequant(s, (buf[0] >> 1) & 0x3F); 
57  
58 
if (s>framep[VP56_FRAME_CURRENT]>key_frame) {

59 
sub_version = buf[1] >> 3; 
60 
if (sub_version > 8) 
61 
return 0; 
62 
s>filter_header = buf[1] & 0x06; 
63 
if (buf[1] & 1) { 
64 
av_log(s>avctx, AV_LOG_ERROR, "interlacing not supported\n");

65 
return 0; 
66 
} 
67 
if (separated_coeff  !s>filter_header) {

68 
coeff_offset = AV_RB16(buf+2)  2; 
69 
buf += 2;

70 
buf_size = 2;

71 
} 
72  
73 
rows = buf[2]; /* number of stored macroblock rows */ 
74 
cols = buf[3]; /* number of stored macroblock cols */ 
75 
/* buf[4] is number of displayed macroblock rows */

76 
/* buf[5] is number of displayed macroblock cols */

77  
78 
if (!s>macroblocks  /* first frame */ 
79 
16*cols != s>avctx>coded_width 

80 
16*rows != s>avctx>coded_height) {

81 
avcodec_set_dimensions(s>avctx, 16*cols, 16*rows); 
82 
if (s>avctx>extradata_size == 1) { 
83 
s>avctx>width = s>avctx>extradata[0] >> 4; 
84 
s>avctx>height = s>avctx>extradata[0] & 0x0F; 
85 
} 
86 
res = 2;

87 
} 
88  
89 
vp56_init_range_decoder(c, buf+6, buf_size6); 
90 
vp56_rac_gets(c, 2);

91  
92 
parse_filter_info = s>filter_header; 
93 
if (sub_version < 8) 
94 
vrt_shift = 5;

95 
s>sub_version = sub_version; 
96 
} else {

97 
if (!s>sub_version)

98 
return 0; 
99  
100 
if (separated_coeff  !s>filter_header) {

101 
coeff_offset = AV_RB16(buf+1)  2; 
102 
buf += 2;

103 
buf_size = 2;

104 
} 
105 
vp56_init_range_decoder(c, buf+1, buf_size1); 
106  
107 
*golden_frame = vp56_rac_get(c); 
108 
if (s>filter_header) {

109 
s>deblock_filtering = vp56_rac_get(c); 
110 
if (s>deblock_filtering)

111 
vp56_rac_get(c); 
112 
if (s>sub_version > 7) 
113 
parse_filter_info = vp56_rac_get(c); 
114 
} 
115 
} 
116  
117 
if (parse_filter_info) {

118 
if (vp56_rac_get(c)) {

119 
s>filter_mode = 2;

120 
s>sample_variance_threshold = vp56_rac_gets(c, 5) << vrt_shift;

121 
s>max_vector_length = 2 << vp56_rac_gets(c, 3); 
122 
} else if (vp56_rac_get(c)) { 
123 
s>filter_mode = 1;

124 
} else {

125 
s>filter_mode = 0;

126 
} 
127 
if (s>sub_version > 7) 
128 
s>filter_selection = vp56_rac_gets(c, 4);

129 
else

130 
s>filter_selection = 16;

131 
} 
132  
133 
s>use_huffman = vp56_rac_get(c); 
134  
135 
s>parse_coeff = vp6_parse_coeff; 
136 
if (coeff_offset) {

137 
buf += coeff_offset; 
138 
buf_size = coeff_offset; 
139 
if (buf_size < 0) 
140 
return 0; 
141 
if (s>use_huffman) {

142 
s>parse_coeff = vp6_parse_coeff_huffman; 
143 
init_get_bits(&s>gb, buf, buf_size<<3);

144 
} else {

145 
vp56_init_range_decoder(&s>cc, buf, buf_size); 
146 
s>ccp = &s>cc; 
147 
} 
148 
} else {

149 
s>ccp = &s>c; 
150 
} 
151  
152 
return res;

153 
} 
154  
155 
static void vp6_coeff_order_table_init(VP56Context *s) 
156 
{ 
157 
int i, pos, idx = 1; 
158  
159 
s>modelp>coeff_index_to_pos[0] = 0; 
160 
for (i=0; i<16; i++) 
161 
for (pos=1; pos<64; pos++) 
162 
if (s>modelp>coeff_reorder[pos] == i)

163 
s>modelp>coeff_index_to_pos[idx++] = pos; 
164 
} 
165  
166 
static void vp6_default_models_init(VP56Context *s) 
167 
{ 
168 
VP56Model *model = s>modelp; 
169  
170 
model>vector_dct[0] = 0xA2; 
171 
model>vector_dct[1] = 0xA4; 
172 
model>vector_sig[0] = 0x80; 
173 
model>vector_sig[1] = 0x80; 
174  
175 
memcpy(model>mb_types_stats, vp56_def_mb_types_stats, sizeof(model>mb_types_stats));

176 
memcpy(model>vector_fdv, vp6_def_fdv_vector_model, sizeof(model>vector_fdv));

177 
memcpy(model>vector_pdv, vp6_def_pdv_vector_model, sizeof(model>vector_pdv));

178 
memcpy(model>coeff_runv, vp6_def_runv_coeff_model, sizeof(model>coeff_runv));

179 
memcpy(model>coeff_reorder, vp6_def_coeff_reorder, sizeof(model>coeff_reorder));

180  
181 
vp6_coeff_order_table_init(s); 
182 
} 
183  
184 
static void vp6_parse_vector_models(VP56Context *s) 
185 
{ 
186 
VP56RangeCoder *c = &s>c; 
187 
VP56Model *model = s>modelp; 
188 
int comp, node;

189  
190 
for (comp=0; comp<2; comp++) { 
191 
if (vp56_rac_get_prob(c, vp6_sig_dct_pct[comp][0])) 
192 
model>vector_dct[comp] = vp56_rac_gets_nn(c, 7);

193 
if (vp56_rac_get_prob(c, vp6_sig_dct_pct[comp][1])) 
194 
model>vector_sig[comp] = vp56_rac_gets_nn(c, 7);

195 
} 
196  
197 
for (comp=0; comp<2; comp++) 
198 
for (node=0; node<7; node++) 
199 
if (vp56_rac_get_prob(c, vp6_pdv_pct[comp][node]))

200 
model>vector_pdv[comp][node] = vp56_rac_gets_nn(c, 7);

201  
202 
for (comp=0; comp<2; comp++) 
203 
for (node=0; node<8; node++) 
204 
if (vp56_rac_get_prob(c, vp6_fdv_pct[comp][node]))

205 
model>vector_fdv[comp][node] = vp56_rac_gets_nn(c, 7);

206 
} 
207  
208 
/* nodes must ascend by count, but with descending symbol order */

209 
static int vp6_huff_cmp(const void *va, const void *vb) 
210 
{ 
211 
const Node *a = va, *b = vb;

212 
return (a>count  b>count)*16 + (b>sym  a>sym); 
213 
} 
214  
215 
static void vp6_build_huff_tree(VP56Context *s, uint8_t coeff_model[], 
216 
const uint8_t *map, unsigned size, VLC *vlc) 
217 
{ 
218 
Node nodes[2*size], *tmp = &nodes[size];

219 
int a, b, i;

220  
221 
/* first compute probabilities from model */

222 
tmp[0].count = 256; 
223 
for (i=0; i<size1; i++) { 
224 
a = tmp[i].count * coeff_model[i] >> 8;

225 
b = tmp[i].count * (255  coeff_model[i]) >> 8; 
226 
nodes[map[2*i ]].count = a + !a;

227 
nodes[map[2*i+1]].count = b + !b; 
228 
} 
229  
230 
free_vlc(vlc); 
231 
/* then build the huffman tree accodring to probabilities */

232 
ff_huff_build_tree(s>avctx, vlc, size, nodes, vp6_huff_cmp, 
233 
FF_HUFFMAN_FLAG_HNODE_FIRST); 
234 
} 
235  
236 
static void vp6_parse_coeff_models(VP56Context *s) 
237 
{ 
238 
VP56RangeCoder *c = &s>c; 
239 
VP56Model *model = s>modelp; 
240 
int def_prob[11]; 
241 
int node, cg, ctx, pos;

242 
int ct; /* code type */ 
243 
int pt; /* plane type (0 for Y, 1 for U or V) */ 
244  
245 
memset(def_prob, 0x80, sizeof(def_prob)); 
246  
247 
for (pt=0; pt<2; pt++) 
248 
for (node=0; node<11; node++) 
249 
if (vp56_rac_get_prob(c, vp6_dccv_pct[pt][node])) {

250 
def_prob[node] = vp56_rac_gets_nn(c, 7);

251 
model>coeff_dccv[pt][node] = def_prob[node]; 
252 
} else if (s>framep[VP56_FRAME_CURRENT]>key_frame) { 
253 
model>coeff_dccv[pt][node] = def_prob[node]; 
254 
} 
255  
256 
if (vp56_rac_get(c)) {

257 
for (pos=1; pos<64; pos++) 
258 
if (vp56_rac_get_prob(c, vp6_coeff_reorder_pct[pos]))

259 
model>coeff_reorder[pos] = vp56_rac_gets(c, 4);

260 
vp6_coeff_order_table_init(s); 
261 
} 
262  
263 
for (cg=0; cg<2; cg++) 
264 
for (node=0; node<14; node++) 
265 
if (vp56_rac_get_prob(c, vp6_runv_pct[cg][node]))

266 
model>coeff_runv[cg][node] = vp56_rac_gets_nn(c, 7);

267  
268 
for (ct=0; ct<3; ct++) 
269 
for (pt=0; pt<2; pt++) 
270 
for (cg=0; cg<6; cg++) 
271 
for (node=0; node<11; node++) 
272 
if (vp56_rac_get_prob(c, vp6_ract_pct[ct][pt][cg][node])) {

273 
def_prob[node] = vp56_rac_gets_nn(c, 7);

274 
model>coeff_ract[pt][ct][cg][node] = def_prob[node]; 
275 
} else if (s>framep[VP56_FRAME_CURRENT]>key_frame) { 
276 
model>coeff_ract[pt][ct][cg][node] = def_prob[node]; 
277 
} 
278  
279 
if (s>use_huffman) {

280 
for (pt=0; pt<2; pt++) { 
281 
vp6_build_huff_tree(s, model>coeff_dccv[pt], 
282 
vp6_huff_coeff_map, 12, &s>dccv_vlc[pt]);

283 
vp6_build_huff_tree(s, model>coeff_runv[pt], 
284 
vp6_huff_run_map, 9, &s>runv_vlc[pt]);

285 
for (ct=0; ct<3; ct++) 
286 
for (cg = 0; cg < 6; cg++) 
287 
vp6_build_huff_tree(s, model>coeff_ract[pt][ct][cg], 
288 
vp6_huff_coeff_map, 12,

289 
&s>ract_vlc[pt][ct][cg]); 
290 
} 
291 
memset(s>nb_null, 0, sizeof(s>nb_null)); 
292 
} else {

293 
/* coeff_dcct is a linear combination of coeff_dccv */

294 
for (pt=0; pt<2; pt++) 
295 
for (ctx=0; ctx<3; ctx++) 
296 
for (node=0; node<5; node++) 
297 
model>coeff_dcct[pt][ctx][node] = av_clip(((model>coeff_dccv[pt][node] * vp6_dccv_lc[ctx][node][0] + 128) >> 8) + vp6_dccv_lc[ctx][node][1], 1, 255); 
298 
} 
299 
} 
300  
301 
static void vp6_parse_vector_adjustment(VP56Context *s, VP56mv *vect) 
302 
{ 
303 
VP56RangeCoder *c = &s>c; 
304 
VP56Model *model = s>modelp; 
305 
int comp;

306  
307 
*vect = (VP56mv) {0,0}; 
308 
if (s>vector_candidate_pos < 2) 
309 
*vect = s>vector_candidate[0];

310  
311 
for (comp=0; comp<2; comp++) { 
312 
int i, delta = 0; 
313  
314 
if (vp56_rac_get_prob(c, model>vector_dct[comp])) {

315 
static const uint8_t prob_order[] = {0, 1, 2, 7, 6, 5, 4}; 
316 
for (i=0; i<sizeof(prob_order); i++) { 
317 
int j = prob_order[i];

318 
delta = vp56_rac_get_prob(c, model>vector_fdv[comp][j])<<j; 
319 
} 
320 
if (delta & 0xF0) 
321 
delta = vp56_rac_get_prob(c, model>vector_fdv[comp][3])<<3; 
322 
else

323 
delta = 8;

324 
} else {

325 
delta = vp56_rac_get_tree(c, vp56_pva_tree, 
326 
model>vector_pdv[comp]); 
327 
} 
328  
329 
if (delta && vp56_rac_get_prob(c, model>vector_sig[comp]))

330 
delta = delta; 
331  
332 
if (!comp)

333 
vect>x += delta; 
334 
else

335 
vect>y += delta; 
336 
} 
337 
} 
338  
339 
/**

340 
* Read number of consecutive blocks with null DC or AC.

341 
* This value is < 74.

342 
*/

343 
static unsigned vp6_get_nb_null(VP56Context *s) 
344 
{ 
345 
unsigned val = get_bits(&s>gb, 2); 
346 
if (val == 2) 
347 
val += get_bits(&s>gb, 2);

348 
else if (val == 3) { 
349 
val = get_bits1(&s>gb) << 2;

350 
val = 6+val + get_bits(&s>gb, 2+val); 
351 
} 
352 
return val;

353 
} 
354  
355 
static void vp6_parse_coeff_huffman(VP56Context *s) 
356 
{ 
357 
VP56Model *model = s>modelp; 
358 
uint8_t *permute = s>scantable.permutated; 
359 
VLC *vlc_coeff; 
360 
int coeff, sign, coeff_idx;

361 
int b, cg, idx;

362 
int pt = 0; /* plane type (0 for Y, 1 for U or V) */ 
363  
364 
for (b=0; b<6; b++) { 
365 
int ct = 0; /* code type */ 
366 
if (b > 3) pt = 1; 
367 
vlc_coeff = &s>dccv_vlc[pt]; 
368  
369 
for (coeff_idx=0; coeff_idx<64; ) { 
370 
int run = 1; 
371 
if (coeff_idx<2 && s>nb_null[coeff_idx][pt]) { 
372 
s>nb_null[coeff_idx][pt]; 
373 
if (coeff_idx)

374 
break;

375 
} else {

376 
if (get_bits_count(&s>gb) >= s>gb.size_in_bits)

377 
return;

378 
coeff = get_vlc2(&s>gb, vlc_coeff>table, 9, 3); 
379 
if (coeff == 0) { 
380 
if (coeff_idx) {

381 
int pt = (coeff_idx >= 6); 
382 
run += get_vlc2(&s>gb, s>runv_vlc[pt].table, 9, 3); 
383 
if (run >= 9) 
384 
run += get_bits(&s>gb, 6);

385 
} else

386 
s>nb_null[0][pt] = vp6_get_nb_null(s);

387 
ct = 0;

388 
} else if (coeff == 11) { /* end of block */ 
389 
if (coeff_idx == 1) /* first AC coeff ? */ 
390 
s>nb_null[1][pt] = vp6_get_nb_null(s);

391 
break;

392 
} else {

393 
int coeff2 = vp56_coeff_bias[coeff];

394 
if (coeff > 4) 
395 
coeff2 += get_bits(&s>gb, coeff <= 9 ? coeff  4 : 11); 
396 
ct = 1 + (coeff2 > 1); 
397 
sign = get_bits1(&s>gb); 
398 
coeff2 = (coeff2 ^ sign) + sign; 
399 
if (coeff_idx)

400 
coeff2 *= s>dequant_ac; 
401 
idx = model>coeff_index_to_pos[coeff_idx]; 
402 
s>block_coeff[b][permute[idx]] = coeff2; 
403 
} 
404 
} 
405 
coeff_idx+=run; 
406 
cg = FFMIN(vp6_coeff_groups[coeff_idx], 3);

407 
vlc_coeff = &s>ract_vlc[pt][ct][cg]; 
408 
} 
409 
} 
410 
} 
411  
412 
static void vp6_parse_coeff(VP56Context *s) 
413 
{ 
414 
VP56RangeCoder *c = s>ccp; 
415 
VP56Model *model = s>modelp; 
416 
uint8_t *permute = s>scantable.permutated; 
417 
uint8_t *model1, *model2, *model3; 
418 
int coeff, sign, coeff_idx;

419 
int b, i, cg, idx, ctx;

420 
int pt = 0; /* plane type (0 for Y, 1 for U or V) */ 
421  
422 
for (b=0; b<6; b++) { 
423 
int ct = 1; /* code type */ 
424 
int run = 1; 
425  
426 
if (b > 3) pt = 1; 
427  
428 
ctx = s>left_block[vp56_b6to4[b]].not_null_dc 
429 
+ s>above_blocks[s>above_block_idx[b]].not_null_dc; 
430 
model1 = model>coeff_dccv[pt]; 
431 
model2 = model>coeff_dcct[pt][ctx]; 
432  
433 
for (coeff_idx=0; coeff_idx<64; ) { 
434 
if ((coeff_idx>1 && ct==0)  vp56_rac_get_prob(c, model2[0])) { 
435 
/* parse a coeff */

436 
if (vp56_rac_get_prob(c, model2[2])) { 
437 
if (vp56_rac_get_prob(c, model2[3])) { 
438 
idx = vp56_rac_get_tree(c, vp56_pc_tree, model1); 
439 
coeff = vp56_coeff_bias[idx+5];

440 
for (i=vp56_coeff_bit_length[idx]; i>=0; i) 
441 
coeff += vp56_rac_get_prob(c, vp56_coeff_parse_table[idx][i]) << i; 
442 
} else {

443 
if (vp56_rac_get_prob(c, model2[4])) 
444 
coeff = 3 + vp56_rac_get_prob(c, model1[5]); 
445 
else

446 
coeff = 2;

447 
} 
448 
ct = 2;

449 
} else {

450 
ct = 1;

451 
coeff = 1;

452 
} 
453 
sign = vp56_rac_get(c); 
454 
coeff = (coeff ^ sign) + sign; 
455 
if (coeff_idx)

456 
coeff *= s>dequant_ac; 
457 
idx = model>coeff_index_to_pos[coeff_idx]; 
458 
s>block_coeff[b][permute[idx]] = coeff; 
459 
run = 1;

460 
} else {

461 
/* parse a run */

462 
ct = 0;

463 
if (coeff_idx > 0) { 
464 
if (!vp56_rac_get_prob(c, model2[1])) 
465 
break;

466  
467 
model3 = model>coeff_runv[coeff_idx >= 6];

468 
run = vp56_rac_get_tree(c, vp6_pcr_tree, model3); 
469 
if (!run)

470 
for (run=9, i=0; i<6; i++) 
471 
run += vp56_rac_get_prob(c, model3[i+8]) << i;

472 
} 
473 
} 
474  
475 
cg = vp6_coeff_groups[coeff_idx+=run]; 
476 
model1 = model2 = model>coeff_ract[pt][ct][cg]; 
477 
} 
478  
479 
s>left_block[vp56_b6to4[b]].not_null_dc = 
480 
s>above_blocks[s>above_block_idx[b]].not_null_dc = !!s>block_coeff[b][0];

481 
} 
482 
} 
483  
484 
static int vp6_adjust(int v, int t) 
485 
{ 
486 
int V = v, s = v >> 31; 
487 
V ^= s; 
488 
V = s; 
489 
if (Vt1 >= (unsigned)(t1)) 
490 
return v;

491 
V = 2*t  V;

492 
V += s; 
493 
V ^= s; 
494 
return V;

495 
} 
496  
497 
static int vp6_block_variance(uint8_t *src, int stride) 
498 
{ 
499 
int sum = 0, square_sum = 0; 
500 
int y, x;

501  
502 
for (y=0; y<8; y+=2) { 
503 
for (x=0; x<8; x+=2) { 
504 
sum += src[x]; 
505 
square_sum += src[x]*src[x]; 
506 
} 
507 
src += 2*stride;

508 
} 
509 
return (16*square_sum  sum*sum) >> 8; 
510 
} 
511  
512 
static void vp6_filter_hv4(uint8_t *dst, uint8_t *src, int stride, 
513 
int delta, const int16_t *weights) 
514 
{ 
515 
int x, y;

516  
517 
for (y=0; y<8; y++) { 
518 
for (x=0; x<8; x++) { 
519 
dst[x] = av_clip_uint8(( src[xdelta ] * weights[0]

520 
+ src[x ] * weights[1]

521 
+ src[x+delta ] * weights[2]

522 
+ src[x+2*delta] * weights[3] + 64) >> 7); 
523 
} 
524 
src += stride; 
525 
dst += stride; 
526 
} 
527 
} 
528  
529 
static void vp6_filter_diag2(VP56Context *s, uint8_t *dst, uint8_t *src, 
530 
int stride, int h_weight, int v_weight) 
531 
{ 
532 
uint8_t *tmp = s>edge_emu_buffer+16;

533 
s>dsp.put_h264_chroma_pixels_tab[0](tmp, src, stride, 9, h_weight, 0); 
534 
s>dsp.put_h264_chroma_pixels_tab[0](dst, tmp, stride, 8, 0, v_weight); 
535 
} 
536  
537 
static void vp6_filter(VP56Context *s, uint8_t *dst, uint8_t *src, 
538 
int offset1, int offset2, int stride, 
539 
VP56mv mv, int mask, int select, int luma) 
540 
{ 
541 
int filter4 = 0; 
542 
int x8 = mv.x & mask;

543 
int y8 = mv.y & mask;

544  
545 
if (luma) {

546 
x8 *= 2;

547 
y8 *= 2;

548 
filter4 = s>filter_mode; 
549 
if (filter4 == 2) { 
550 
if (s>max_vector_length &&

551 
(FFABS(mv.x) > s>max_vector_length  
552 
FFABS(mv.y) > s>max_vector_length)) { 
553 
filter4 = 0;

554 
} else if (s>sample_variance_threshold 
555 
&& (vp6_block_variance(src+offset1, stride) 
556 
< s>sample_variance_threshold)) { 
557 
filter4 = 0;

558 
} 
559 
} 
560 
} 
561  
562 
if ((y8 && (offset2offset1)*s>flip<0)  (!y8 && offset1 > offset2)) { 
563 
offset1 = offset2; 
564 
} 
565  
566 
if (filter4) {

567 
if (!y8) { /* left or right combine */ 
568 
vp6_filter_hv4(dst, src+offset1, stride, 1,

569 
vp6_block_copy_filter[select][x8]); 
570 
} else if (!x8) { /* above or below combine */ 
571 
vp6_filter_hv4(dst, src+offset1, stride, stride, 
572 
vp6_block_copy_filter[select][y8]); 
573 
} else {

574 
s>dsp.vp6_filter_diag4(dst, src+offset1+((mv.x^mv.y)>>31), stride,

575 
vp6_block_copy_filter[select][x8], 
576 
vp6_block_copy_filter[select][y8]); 
577 
} 
578 
} else {

579 
if (!x8  !y8) {

580 
s>dsp.put_h264_chroma_pixels_tab[0](dst, src+offset1, stride, 8, x8, y8); 
581 
} else {

582 
vp6_filter_diag2(s, dst, src+offset1 + ((mv.x^mv.y)>>31), stride, x8, y8);

583 
} 
584 
} 
585 
} 
586  
587 
static av_cold int vp6_decode_init(AVCodecContext *avctx) 
588 
{ 
589 
VP56Context *s = avctx>priv_data; 
590  
591 
vp56_init(avctx, avctx>codec>id == CODEC_ID_VP6, 
592 
avctx>codec>id == CODEC_ID_VP6A); 
593 
s>vp56_coord_div = vp6_coord_div; 
594 
s>parse_vector_adjustment = vp6_parse_vector_adjustment; 
595 
s>adjust = vp6_adjust; 
596 
s>filter = vp6_filter; 
597 
s>default_models_init = vp6_default_models_init; 
598 
s>parse_vector_models = vp6_parse_vector_models; 
599 
s>parse_coeff_models = vp6_parse_coeff_models; 
600 
s>parse_header = vp6_parse_header; 
601  
602 
return 0; 
603 
} 
604  
605 
static av_cold int vp6_decode_free(AVCodecContext *avctx) 
606 
{ 
607 
VP56Context *s = avctx>priv_data; 
608 
int pt, ct, cg;

609  
610 
vp56_free(avctx); 
611  
612 
for (pt=0; pt<2; pt++) { 
613 
free_vlc(&s>dccv_vlc[pt]); 
614 
free_vlc(&s>runv_vlc[pt]); 
615 
for (ct=0; ct<3; ct++) 
616 
for (cg=0; cg<6; cg++) 
617 
free_vlc(&s>ract_vlc[pt][ct][cg]); 
618 
} 
619 
return 0; 
620 
} 
621  
622 
AVCodec vp6_decoder = { 
623 
"vp6",

624 
AVMEDIA_TYPE_VIDEO, 
625 
CODEC_ID_VP6, 
626 
sizeof(VP56Context),

627 
vp6_decode_init, 
628 
NULL,

629 
vp6_decode_free, 
630 
vp56_decode_frame, 
631 
CODEC_CAP_DR1, 
632 
.long_name = NULL_IF_CONFIG_SMALL("On2 VP6"),

633 
}; 
634  
635 
/* flash version, not flipped upsidedown */

636 
AVCodec vp6f_decoder = { 
637 
"vp6f",

638 
AVMEDIA_TYPE_VIDEO, 
639 
CODEC_ID_VP6F, 
640 
sizeof(VP56Context),

641 
vp6_decode_init, 
642 
NULL,

643 
vp6_decode_free, 
644 
vp56_decode_frame, 
645 
CODEC_CAP_DR1, 
646 
.long_name = NULL_IF_CONFIG_SMALL("On2 VP6 (Flash version)"),

647 
}; 
648  
649 
/* flash version, not flipped upsidedown, with alpha channel */

650 
AVCodec vp6a_decoder = { 
651 
"vp6a",

652 
AVMEDIA_TYPE_VIDEO, 
653 
CODEC_ID_VP6A, 
654 
sizeof(VP56Context),

655 
vp6_decode_init, 
656 
NULL,

657 
vp6_decode_free, 
658 
vp56_decode_frame, 
659 
CODEC_CAP_DR1, 
660 
.long_name = NULL_IF_CONFIG_SMALL("On2 VP6 (Flash version, with alpha channel)"),

661 
}; 