ffmpeg / libavcodec / vp6.c @ d9504970
History  View  Annotate  Download (21.1 KB)
1 
/**


2 
* @file

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 
#define VP6_MAX_HUFF_SIZE 12 
40  
41 
static void vp6_parse_coeff(VP56Context *s); 
42 
static void vp6_parse_coeff_huffman(VP56Context *s); 
43  
44 
static int vp6_parse_header(VP56Context *s, const uint8_t *buf, int buf_size, 
45 
int *golden_frame)

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

52 
int rows, cols;

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

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

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

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

71 
buf_size = 2;

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

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

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

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

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

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

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

96 
s>sub_version = sub_version; 
97 
} else {

98 
if (!s>sub_version)

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

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

104 
buf_size = 2;

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

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

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

119 
if (vp56_rac_get(c)) {

120 
s>filter_mode = 2;

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

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

125 
} else {

126 
s>filter_mode = 0;

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

130 
else

131 
s>filter_selection = 16;

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

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

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

145 
} else {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

220 
int a, b, i;

221  
222 
/* first compute probabilities from model */

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

295 
for (pt=0; pt<2; pt++) 
296 
for (ctx=0; ctx<3; ctx++) 
297 
for (node=0; node<5; node++) 
298 
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); 
299 
} 
300 
} 
301  
302 
static void vp6_parse_vector_adjustment(VP56Context *s, VP56mv *vect) 
303 
{ 
304 
VP56RangeCoder *c = &s>c; 
305 
VP56Model *model = s>modelp; 
306 
int comp;

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

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

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

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

324 
delta = 8;

325 
} else {

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

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

334 
vect>x += delta; 
335 
else

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

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

342 
* This value is < 74.

343 
*/

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

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

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

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

362 
int b, cg, idx;

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

375 
break;

376 
} else {

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

378 
return;

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

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

386 
} else

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

388 
ct = 0;

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

392 
break;

393 
} else {

394 
int coeff2 = vp56_coeff_bias[coeff];

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

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

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

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

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

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

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

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

447 
coeff = 2;

448 
} 
449 
ct = 2;

450 
} else {

451 
ct = 1;

452 
coeff = 1;

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

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

461 
} else {

462 
/* parse a run */

463 
ct = 0;

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

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

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

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

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

482 
} 
483 
} 
484  
485 
static int vp6_block_variance(uint8_t *src, int stride) 
486 
{ 
487 
int sum = 0, square_sum = 0; 
488 
int y, x;

489  
490 
for (y=0; y<8; y+=2) { 
491 
for (x=0; x<8; x+=2) { 
492 
sum += src[x]; 
493 
square_sum += src[x]*src[x]; 
494 
} 
495 
src += 2*stride;

496 
} 
497 
return (16*square_sum  sum*sum) >> 8; 
498 
} 
499  
500 
static void vp6_filter_hv4(uint8_t *dst, uint8_t *src, int stride, 
501 
int delta, const int16_t *weights) 
502 
{ 
503 
int x, y;

504  
505 
for (y=0; y<8; y++) { 
506 
for (x=0; x<8; x++) { 
507 
dst[x] = av_clip_uint8(( src[xdelta ] * weights[0]

508 
+ src[x ] * weights[1]

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

510 
+ src[x+2*delta] * weights[3] + 64) >> 7); 
511 
} 
512 
src += stride; 
513 
dst += stride; 
514 
} 
515 
} 
516  
517 
static void vp6_filter_diag2(VP56Context *s, uint8_t *dst, uint8_t *src, 
518 
int stride, int h_weight, int v_weight) 
519 
{ 
520 
uint8_t *tmp = s>edge_emu_buffer+16;

521 
s>dsp.put_h264_chroma_pixels_tab[0](tmp, src, stride, 9, h_weight, 0); 
522 
s>dsp.put_h264_chroma_pixels_tab[0](dst, tmp, stride, 8, 0, v_weight); 
523 
} 
524  
525 
static void vp6_filter(VP56Context *s, uint8_t *dst, uint8_t *src, 
526 
int offset1, int offset2, int stride, 
527 
VP56mv mv, int mask, int select, int luma) 
528 
{ 
529 
int filter4 = 0; 
530 
int x8 = mv.x & mask;

531 
int y8 = mv.y & mask;

532  
533 
if (luma) {

534 
x8 *= 2;

535 
y8 *= 2;

536 
filter4 = s>filter_mode; 
537 
if (filter4 == 2) { 
538 
if (s>max_vector_length &&

539 
(FFABS(mv.x) > s>max_vector_length  
540 
FFABS(mv.y) > s>max_vector_length)) { 
541 
filter4 = 0;

542 
} else if (s>sample_variance_threshold 
543 
&& (vp6_block_variance(src+offset1, stride) 
544 
< s>sample_variance_threshold)) { 
545 
filter4 = 0;

546 
} 
547 
} 
548 
} 
549  
550 
if ((y8 && (offset2offset1)*s>flip<0)  (!y8 && offset1 > offset2)) { 
551 
offset1 = offset2; 
552 
} 
553  
554 
if (filter4) {

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

557 
vp6_block_copy_filter[select][x8]); 
558 
} else if (!x8) { /* above or below combine */ 
559 
vp6_filter_hv4(dst, src+offset1, stride, stride, 
560 
vp6_block_copy_filter[select][y8]); 
561 
} else {

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

563 
vp6_block_copy_filter[select][x8], 
564 
vp6_block_copy_filter[select][y8]); 
565 
} 
566 
} else {

567 
if (!x8  !y8) {

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

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

571 
} 
572 
} 
573 
} 
574  
575 
static av_cold int vp6_decode_init(AVCodecContext *avctx) 
576 
{ 
577 
VP56Context *s = avctx>priv_data; 
578  
579 
ff_vp56_init(avctx, avctx>codec>id == CODEC_ID_VP6, 
580 
avctx>codec>id == CODEC_ID_VP6A); 
581 
s>vp56_coord_div = vp6_coord_div; 
582 
s>parse_vector_adjustment = vp6_parse_vector_adjustment; 
583 
s>filter = vp6_filter; 
584 
s>default_models_init = vp6_default_models_init; 
585 
s>parse_vector_models = vp6_parse_vector_models; 
586 
s>parse_coeff_models = vp6_parse_coeff_models; 
587 
s>parse_header = vp6_parse_header; 
588  
589 
return 0; 
590 
} 
591  
592 
static av_cold int vp6_decode_free(AVCodecContext *avctx) 
593 
{ 
594 
VP56Context *s = avctx>priv_data; 
595 
int pt, ct, cg;

596  
597 
ff_vp56_free(avctx); 
598  
599 
for (pt=0; pt<2; pt++) { 
600 
free_vlc(&s>dccv_vlc[pt]); 
601 
free_vlc(&s>runv_vlc[pt]); 
602 
for (ct=0; ct<3; ct++) 
603 
for (cg=0; cg<6; cg++) 
604 
free_vlc(&s>ract_vlc[pt][ct][cg]); 
605 
} 
606 
return 0; 
607 
} 
608  
609 
AVCodec vp6_decoder = { 
610 
"vp6",

611 
AVMEDIA_TYPE_VIDEO, 
612 
CODEC_ID_VP6, 
613 
sizeof(VP56Context),

614 
vp6_decode_init, 
615 
NULL,

616 
vp6_decode_free, 
617 
ff_vp56_decode_frame, 
618 
CODEC_CAP_DR1, 
619 
.long_name = NULL_IF_CONFIG_SMALL("On2 VP6"),

620 
}; 
621  
622 
/* flash version, not flipped upsidedown */

623 
AVCodec vp6f_decoder = { 
624 
"vp6f",

625 
AVMEDIA_TYPE_VIDEO, 
626 
CODEC_ID_VP6F, 
627 
sizeof(VP56Context),

628 
vp6_decode_init, 
629 
NULL,

630 
vp6_decode_free, 
631 
ff_vp56_decode_frame, 
632 
CODEC_CAP_DR1, 
633 
.long_name = NULL_IF_CONFIG_SMALL("On2 VP6 (Flash version)"),

634 
}; 
635  
636 
/* flash version, not flipped upsidedown, with alpha channel */

637 
AVCodec vp6a_decoder = { 
638 
"vp6a",

639 
AVMEDIA_TYPE_VIDEO, 
640 
CODEC_ID_VP6A, 
641 
sizeof(VP56Context),

642 
vp6_decode_init, 
643 
NULL,

644 
vp6_decode_free, 
645 
ff_vp56_decode_frame, 
646 
CODEC_CAP_DR1, 
647 
.long_name = NULL_IF_CONFIG_SMALL("On2 VP6 (Flash version, with alpha channel)"),

648 
}; 