Mercurial > libavcodec.hg
annotate vp56.c @ 11346:a8b76b8455bc libavcodec
remove unused left_border field from context.
author | michael |
---|---|
date | Wed, 03 Mar 2010 19:44:27 +0000 |
parents | 8d23ea397dda |
children | 7d9a1a807e91 |
rev | line source |
---|---|
3695 | 1 /** |
8718
e9d9d946f213
Use full internal pathname in doxygen @file directives.
diego
parents:
8329
diff
changeset
|
2 * @file libavcodec/vp56.c |
3695 | 3 * VP5 and VP6 compatible video decoder (common features) |
4 * | |
5 * Copyright (C) 2006 Aurelien Jacobs <aurel@gnuage.org> | |
6 * | |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3715
diff
changeset
|
7 * This file is part of FFmpeg. |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3715
diff
changeset
|
8 * |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3715
diff
changeset
|
9 * FFmpeg is free software; you can redistribute it and/or |
3695 | 10 * modify it under the terms of the GNU Lesser General Public |
11 * License as published by the Free Software Foundation; either | |
12 * version 2.1 of the License, or (at your option) any later version. | |
13 * | |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3715
diff
changeset
|
14 * FFmpeg is distributed in the hope that it will be useful, |
3695 | 15 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
17 * Lesser General Public License for more details. | |
18 * | |
19 * You should have received a copy of the GNU Lesser General Public | |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3715
diff
changeset
|
20 * License along with FFmpeg; if not, write to the Free Software |
5215 | 21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
3695 | 22 */ |
23 | |
24 #include "avcodec.h" | |
5714
314be1cfdcb0
add a new vp6a codec (add alpha plan support to vp6)
aurel
parents:
5711
diff
changeset
|
25 #include "bytestream.h" |
3695 | 26 |
27 #include "vp56.h" | |
28 #include "vp56data.h" | |
11342 | 29 #include "get_bits.h" |
3695 | 30 |
31 | |
8299 | 32 void vp56_init_dequant(VP56Context *s, int quantizer) |
3695 | 33 { |
34 s->quantizer = quantizer; | |
35 s->dequant_dc = vp56_dc_dequant[quantizer] << 2; | |
36 s->dequant_ac = vp56_ac_dequant[quantizer] << 2; | |
11053
c57e72227d7d
Make VP5 and VP6 decoders output a qscale table to allow for more automatic
reimar
parents:
11050
diff
changeset
|
37 memset(s->qscale_table, quantizer, s->mb_width); |
3695 | 38 } |
39 | |
8299 | 40 static int vp56_get_vectors_predictors(VP56Context *s, int row, int col, |
41 VP56Frame ref_frame) | |
3695 | 42 { |
43 int nb_pred = 0; | |
8299 | 44 VP56mv vect[2] = {{0,0}, {0,0}}; |
3695 | 45 int pos, offset; |
8299 | 46 VP56mv mvp; |
3695 | 47 |
48 for (pos=0; pos<12; pos++) { | |
49 mvp.x = col + vp56_candidate_predictor_pos[pos][0]; | |
50 mvp.y = row + vp56_candidate_predictor_pos[pos][1]; | |
51 if (mvp.x < 0 || mvp.x >= s->mb_width || | |
52 mvp.y < 0 || mvp.y >= s->mb_height) | |
53 continue; | |
54 offset = mvp.x + s->mb_width*mvp.y; | |
55 | |
56 if (vp56_reference_frame[s->macroblocks[offset].type] != ref_frame) | |
57 continue; | |
3697 | 58 if ((s->macroblocks[offset].mv.x == vect[0].x && |
59 s->macroblocks[offset].mv.y == vect[0].y) || | |
3695 | 60 (s->macroblocks[offset].mv.x == 0 && |
61 s->macroblocks[offset].mv.y == 0)) | |
62 continue; | |
63 | |
3697 | 64 vect[nb_pred++] = s->macroblocks[offset].mv; |
3695 | 65 if (nb_pred > 1) { |
66 nb_pred = -1; | |
67 break; | |
68 } | |
69 s->vector_candidate_pos = pos; | |
70 } | |
71 | |
3697 | 72 s->vector_candidate[0] = vect[0]; |
73 s->vector_candidate[1] = vect[1]; | |
3695 | 74 |
75 return nb_pred+1; | |
76 } | |
77 | |
8299 | 78 static void vp56_parse_mb_type_models(VP56Context *s) |
3695 | 79 { |
8299 | 80 VP56RangeCoder *c = &s->c; |
8304 | 81 VP56Model *model = s->modelp; |
3695 | 82 int i, ctx, type; |
83 | |
84 for (ctx=0; ctx<3; ctx++) { | |
85 if (vp56_rac_get_prob(c, 174)) { | |
86 int idx = vp56_rac_gets(c, 4); | |
5711 | 87 memcpy(model->mb_types_stats[ctx], |
88 vp56_pre_def_mb_type_stats[idx][ctx], | |
89 sizeof(model->mb_types_stats[ctx])); | |
3695 | 90 } |
91 if (vp56_rac_get_prob(c, 254)) { | |
92 for (type=0; type<10; type++) { | |
93 for(i=0; i<2; i++) { | |
94 if (vp56_rac_get_prob(c, 205)) { | |
95 int delta, sign = vp56_rac_get(c); | |
96 | |
97 delta = vp56_rac_get_tree(c, vp56_pmbtm_tree, | |
98 vp56_mb_type_model_model); | |
99 if (!delta) | |
100 delta = 4 * vp56_rac_gets(c, 7); | |
5711 | 101 model->mb_types_stats[ctx][type][i] += (delta ^ -sign) + sign; |
3695 | 102 } |
103 } | |
104 } | |
105 } | |
106 } | |
107 | |
108 /* compute MB type probability tables based on previous MB type */ | |
109 for (ctx=0; ctx<3; ctx++) { | |
110 int p[10]; | |
111 | |
112 for (type=0; type<10; type++) | |
5711 | 113 p[type] = 100 * model->mb_types_stats[ctx][type][1]; |
3695 | 114 |
115 for (type=0; type<10; type++) { | |
116 int p02, p34, p0234, p17, p56, p89, p5689, p156789; | |
117 | |
118 /* conservative MB type probability */ | |
5711 | 119 model->mb_type[ctx][type][0] = 255 - (255 * model->mb_types_stats[ctx][type][0]) / (1 + model->mb_types_stats[ctx][type][0] + model->mb_types_stats[ctx][type][1]); |
3695 | 120 |
121 p[type] = 0; /* same MB type => weight is null */ | |
122 | |
123 /* binary tree parsing probabilities */ | |
124 p02 = p[0] + p[2]; | |
125 p34 = p[3] + p[4]; | |
126 p0234 = p02 + p34; | |
127 p17 = p[1] + p[7]; | |
128 p56 = p[5] + p[6]; | |
129 p89 = p[8] + p[9]; | |
130 p5689 = p56 + p89; | |
131 p156789 = p17 + p5689; | |
132 | |
5711 | 133 model->mb_type[ctx][type][1] = 1 + 255 * p0234/(1+p0234+p156789); |
134 model->mb_type[ctx][type][2] = 1 + 255 * p02 / (1+p0234); | |
135 model->mb_type[ctx][type][3] = 1 + 255 * p17 / (1+p156789); | |
136 model->mb_type[ctx][type][4] = 1 + 255 * p[0] / (1+p02); | |
137 model->mb_type[ctx][type][5] = 1 + 255 * p[3] / (1+p34); | |
138 model->mb_type[ctx][type][6] = 1 + 255 * p[1] / (1+p17); | |
139 model->mb_type[ctx][type][7] = 1 + 255 * p56 / (1+p5689); | |
140 model->mb_type[ctx][type][8] = 1 + 255 * p[5] / (1+p56); | |
141 model->mb_type[ctx][type][9] = 1 + 255 * p[8] / (1+p89); | |
3695 | 142 |
143 /* restore initial value */ | |
5711 | 144 p[type] = 100 * model->mb_types_stats[ctx][type][1]; |
3695 | 145 } |
146 } | |
147 } | |
148 | |
8299 | 149 static VP56mb vp56_parse_mb_type(VP56Context *s, |
8300 | 150 VP56mb prev_type, int ctx) |
3695 | 151 { |
5711 | 152 uint8_t *mb_type_model = s->modelp->mb_type[ctx][prev_type]; |
8299 | 153 VP56RangeCoder *c = &s->c; |
3695 | 154 |
155 if (vp56_rac_get_prob(c, mb_type_model[0])) | |
156 return prev_type; | |
157 else | |
158 return vp56_rac_get_tree(c, vp56_pmbt_tree, mb_type_model); | |
159 } | |
160 | |
8299 | 161 static void vp56_decode_4mv(VP56Context *s, int row, int col) |
3695 | 162 { |
8299 | 163 VP56mv mv = {0,0}; |
3695 | 164 int type[4]; |
165 int b; | |
166 | |
167 /* parse each block type */ | |
168 for (b=0; b<4; b++) { | |
169 type[b] = vp56_rac_gets(&s->c, 2); | |
170 if (type[b]) | |
171 type[b]++; /* only returns 0, 2, 3 or 4 (all INTER_PF) */ | |
172 } | |
173 | |
174 /* get vectors */ | |
175 for (b=0; b<4; b++) { | |
176 switch (type[b]) { | |
177 case VP56_MB_INTER_NOVEC_PF: | |
8299 | 178 s->mv[b] = (VP56mv) {0,0}; |
3695 | 179 break; |
180 case VP56_MB_INTER_DELTA_PF: | |
181 s->parse_vector_adjustment(s, &s->mv[b]); | |
182 break; | |
183 case VP56_MB_INTER_V1_PF: | |
184 s->mv[b] = s->vector_candidate[0]; | |
185 break; | |
186 case VP56_MB_INTER_V2_PF: | |
187 s->mv[b] = s->vector_candidate[1]; | |
188 break; | |
189 } | |
190 mv.x += s->mv[b].x; | |
191 mv.y += s->mv[b].y; | |
192 } | |
193 | |
194 /* this is the one selected for the whole MB for prediction */ | |
195 s->macroblocks[row * s->mb_width + col].mv = s->mv[3]; | |
196 | |
197 /* chroma vectors are average luma vectors */ | |
198 if (s->avctx->codec->id == CODEC_ID_VP5) { | |
199 s->mv[4].x = s->mv[5].x = RSHIFT(mv.x,2); | |
200 s->mv[4].y = s->mv[5].y = RSHIFT(mv.y,2); | |
201 } else { | |
8299 | 202 s->mv[4] = s->mv[5] = (VP56mv) {mv.x/4, mv.y/4}; |
3695 | 203 } |
204 } | |
205 | |
8299 | 206 static VP56mb vp56_decode_mv(VP56Context *s, int row, int col) |
3695 | 207 { |
8299 | 208 VP56mv *mv, vect = {0,0}; |
3695 | 209 int ctx, b; |
210 | |
211 ctx = vp56_get_vectors_predictors(s, row, col, VP56_FRAME_PREVIOUS); | |
212 s->mb_type = vp56_parse_mb_type(s, s->mb_type, ctx); | |
213 s->macroblocks[row * s->mb_width + col].type = s->mb_type; | |
214 | |
215 switch (s->mb_type) { | |
216 case VP56_MB_INTER_V1_PF: | |
217 mv = &s->vector_candidate[0]; | |
218 break; | |
219 | |
220 case VP56_MB_INTER_V2_PF: | |
221 mv = &s->vector_candidate[1]; | |
222 break; | |
223 | |
224 case VP56_MB_INTER_V1_GF: | |
225 vp56_get_vectors_predictors(s, row, col, VP56_FRAME_GOLDEN); | |
226 mv = &s->vector_candidate[0]; | |
227 break; | |
228 | |
229 case VP56_MB_INTER_V2_GF: | |
230 vp56_get_vectors_predictors(s, row, col, VP56_FRAME_GOLDEN); | |
231 mv = &s->vector_candidate[1]; | |
232 break; | |
233 | |
234 case VP56_MB_INTER_DELTA_PF: | |
3697 | 235 s->parse_vector_adjustment(s, &vect); |
236 mv = &vect; | |
3695 | 237 break; |
238 | |
239 case VP56_MB_INTER_DELTA_GF: | |
240 vp56_get_vectors_predictors(s, row, col, VP56_FRAME_GOLDEN); | |
3697 | 241 s->parse_vector_adjustment(s, &vect); |
242 mv = &vect; | |
3695 | 243 break; |
244 | |
245 case VP56_MB_INTER_4V: | |
246 vp56_decode_4mv(s, row, col); | |
247 return s->mb_type; | |
248 | |
249 default: | |
3697 | 250 mv = &vect; |
3695 | 251 break; |
252 } | |
253 | |
254 s->macroblocks[row*s->mb_width + col].mv = *mv; | |
255 | |
256 /* same vector for all blocks */ | |
257 for (b=0; b<6; b++) | |
258 s->mv[b] = *mv; | |
259 | |
260 return s->mb_type; | |
261 } | |
262 | |
8299 | 263 static void vp56_add_predictors_dc(VP56Context *s, VP56Frame ref_frame) |
3695 | 264 { |
265 int idx = s->scantable.permutated[0]; | |
5718
bb4293d858da
rename one variable to be consistent with the rest of the file
aurel
parents:
5717
diff
changeset
|
266 int b; |
3695 | 267 |
5718
bb4293d858da
rename one variable to be consistent with the rest of the file
aurel
parents:
5717
diff
changeset
|
268 for (b=0; b<6; b++) { |
8299 | 269 VP56RefDc *ab = &s->above_blocks[s->above_block_idx[b]]; |
270 VP56RefDc *lb = &s->left_block[vp56_b6to4[b]]; | |
3695 | 271 int count = 0; |
272 int dc = 0; | |
5719 | 273 int i; |
3695 | 274 |
275 if (ref_frame == lb->ref_frame) { | |
276 dc += lb->dc_coeff; | |
277 count++; | |
278 } | |
279 if (ref_frame == ab->ref_frame) { | |
280 dc += ab->dc_coeff; | |
281 count++; | |
282 } | |
5719 | 283 if (s->avctx->codec->id == CODEC_ID_VP5) |
284 for (i=0; i<2; i++) | |
285 if (count < 2 && ref_frame == ab[-1+2*i].ref_frame) { | |
286 dc += ab[-1+2*i].dc_coeff; | |
287 count++; | |
288 } | |
3695 | 289 if (count == 0) |
5718
bb4293d858da
rename one variable to be consistent with the rest of the file
aurel
parents:
5717
diff
changeset
|
290 dc = s->prev_dc[vp56_b2p[b]][ref_frame]; |
3695 | 291 else if (count == 2) |
292 dc /= 2; | |
293 | |
5718
bb4293d858da
rename one variable to be consistent with the rest of the file
aurel
parents:
5717
diff
changeset
|
294 s->block_coeff[b][idx] += dc; |
bb4293d858da
rename one variable to be consistent with the rest of the file
aurel
parents:
5717
diff
changeset
|
295 s->prev_dc[vp56_b2p[b]][ref_frame] = s->block_coeff[b][idx]; |
bb4293d858da
rename one variable to be consistent with the rest of the file
aurel
parents:
5717
diff
changeset
|
296 ab->dc_coeff = s->block_coeff[b][idx]; |
3695 | 297 ab->ref_frame = ref_frame; |
5718
bb4293d858da
rename one variable to be consistent with the rest of the file
aurel
parents:
5717
diff
changeset
|
298 lb->dc_coeff = s->block_coeff[b][idx]; |
3695 | 299 lb->ref_frame = ref_frame; |
5718
bb4293d858da
rename one variable to be consistent with the rest of the file
aurel
parents:
5717
diff
changeset
|
300 s->block_coeff[b][idx] *= s->dequant_dc; |
3695 | 301 } |
302 } | |
303 | |
8299 | 304 static void vp56_edge_filter(VP56Context *s, uint8_t *yuv, |
3695 | 305 int pix_inc, int line_inc, int t) |
306 { | |
307 int pix2_inc = 2 * pix_inc; | |
308 int i, v; | |
309 | |
310 for (i=0; i<12; i++) { | |
311 v = (yuv[-pix2_inc] + 3*(yuv[0]-yuv[-pix_inc]) - yuv[pix_inc] + 4) >>3; | |
312 v = s->adjust(v, t); | |
4594 | 313 yuv[-pix_inc] = av_clip_uint8(yuv[-pix_inc] + v); |
314 yuv[0] = av_clip_uint8(yuv[0] - v); | |
3695 | 315 yuv += line_inc; |
316 } | |
317 } | |
318 | |
8299 | 319 static void vp56_deblock_filter(VP56Context *s, uint8_t *yuv, |
3695 | 320 int stride, int dx, int dy) |
321 { | |
322 int t = vp56_filter_threshold[s->quantizer]; | |
323 if (dx) vp56_edge_filter(s, yuv + 10-dx , 1, stride, t); | |
324 if (dy) vp56_edge_filter(s, yuv + stride*(10-dy), stride, 1, t); | |
325 } | |
326 | |
8299 | 327 static void vp56_mc(VP56Context *s, int b, int plane, uint8_t *src, |
3695 | 328 int stride, int x, int y) |
329 { | |
4595 | 330 uint8_t *dst=s->framep[VP56_FRAME_CURRENT]->data[plane]+s->block_offset[b]; |
3695 | 331 uint8_t *src_block; |
332 int src_offset; | |
333 int overlap_offset = 0; | |
334 int mask = s->vp56_coord_div[b] - 1; | |
335 int deblock_filtering = s->deblock_filtering; | |
336 int dx; | |
337 int dy; | |
338 | |
339 if (s->avctx->skip_loop_filter >= AVDISCARD_ALL || | |
340 (s->avctx->skip_loop_filter >= AVDISCARD_NONKEY | |
4595 | 341 && !s->framep[VP56_FRAME_CURRENT]->key_frame)) |
3695 | 342 deblock_filtering = 0; |
343 | |
344 dx = s->mv[b].x / s->vp56_coord_div[b]; | |
345 dy = s->mv[b].y / s->vp56_coord_div[b]; | |
346 | |
347 if (b >= 4) { | |
348 x /= 2; | |
349 y /= 2; | |
350 } | |
351 x += dx - 2; | |
352 y += dy - 2; | |
353 | |
354 if (x<0 || x+12>=s->plane_width[plane] || | |
355 y<0 || y+12>=s->plane_height[plane]) { | |
356 ff_emulated_edge_mc(s->edge_emu_buffer, | |
357 src + s->block_offset[b] + (dy-2)*stride + (dx-2), | |
358 stride, 12, 12, x, y, | |
359 s->plane_width[plane], | |
360 s->plane_height[plane]); | |
361 src_block = s->edge_emu_buffer; | |
362 src_offset = 2 + 2*stride; | |
363 } else if (deblock_filtering) { | |
3715
cdaee53c5da1
replaces back some C code by dsp.put_pixels_tab[0][0] (revert r6231)
aurel
parents:
3706
diff
changeset
|
364 /* only need a 12x12 block, but there is no such dsp function, */ |
cdaee53c5da1
replaces back some C code by dsp.put_pixels_tab[0][0] (revert r6231)
aurel
parents:
3706
diff
changeset
|
365 /* so copy a 16x12 block */ |
cdaee53c5da1
replaces back some C code by dsp.put_pixels_tab[0][0] (revert r6231)
aurel
parents:
3706
diff
changeset
|
366 s->dsp.put_pixels_tab[0][0](s->edge_emu_buffer, |
cdaee53c5da1
replaces back some C code by dsp.put_pixels_tab[0][0] (revert r6231)
aurel
parents:
3706
diff
changeset
|
367 src + s->block_offset[b] + (dy-2)*stride + (dx-2), |
cdaee53c5da1
replaces back some C code by dsp.put_pixels_tab[0][0] (revert r6231)
aurel
parents:
3706
diff
changeset
|
368 stride, 12); |
3695 | 369 src_block = s->edge_emu_buffer; |
370 src_offset = 2 + 2*stride; | |
371 } else { | |
372 src_block = src; | |
373 src_offset = s->block_offset[b] + dy*stride + dx; | |
374 } | |
375 | |
376 if (deblock_filtering) | |
377 vp56_deblock_filter(s, src_block, stride, dx&7, dy&7); | |
378 | |
379 if (s->mv[b].x & mask) | |
380 overlap_offset += (s->mv[b].x > 0) ? 1 : -1; | |
381 if (s->mv[b].y & mask) | |
382 overlap_offset += (s->mv[b].y > 0) ? stride : -stride; | |
383 | |
384 if (overlap_offset) { | |
385 if (s->filter) | |
386 s->filter(s, dst, src_block, src_offset, src_offset+overlap_offset, | |
387 stride, s->mv[b], mask, s->filter_selection, b<4); | |
388 else | |
389 s->dsp.put_no_rnd_pixels_l2[1](dst, src_block+src_offset, | |
390 src_block+src_offset+overlap_offset, | |
391 stride, 8); | |
392 } else { | |
393 s->dsp.put_pixels_tab[1][0](dst, src_block+src_offset, stride, 8); | |
394 } | |
395 } | |
396 | |
8299 | 397 static void vp56_decode_mb(VP56Context *s, int row, int col, int is_alpha) |
3695 | 398 { |
399 AVFrame *frame_current, *frame_ref; | |
8299 | 400 VP56mb mb_type; |
401 VP56Frame ref_frame; | |
5717 | 402 int b, ab, b_max, plane, off; |
3695 | 403 |
4595 | 404 if (s->framep[VP56_FRAME_CURRENT]->key_frame) |
3695 | 405 mb_type = VP56_MB_INTRA; |
406 else | |
407 mb_type = vp56_decode_mv(s, row, col); | |
408 ref_frame = vp56_reference_frame[mb_type]; | |
409 | |
8288 | 410 s->dsp.clear_blocks(*s->block_coeff); |
3695 | 411 |
412 s->parse_coeff(s); | |
413 | |
414 vp56_add_predictors_dc(s, ref_frame); | |
415 | |
4595 | 416 frame_current = s->framep[VP56_FRAME_CURRENT]; |
417 frame_ref = s->framep[ref_frame]; | |
3695 | 418 |
5714
314be1cfdcb0
add a new vp6a codec (add alpha plan support to vp6)
aurel
parents:
5711
diff
changeset
|
419 ab = 6*is_alpha; |
314be1cfdcb0
add a new vp6a codec (add alpha plan support to vp6)
aurel
parents:
5711
diff
changeset
|
420 b_max = 6 - 2*is_alpha; |
314be1cfdcb0
add a new vp6a codec (add alpha plan support to vp6)
aurel
parents:
5711
diff
changeset
|
421 |
3695 | 422 switch (mb_type) { |
423 case VP56_MB_INTRA: | |
5714
314be1cfdcb0
add a new vp6a codec (add alpha plan support to vp6)
aurel
parents:
5711
diff
changeset
|
424 for (b=0; b<b_max; b++) { |
5717 | 425 plane = vp56_b2p[b+ab]; |
426 s->dsp.idct_put(frame_current->data[plane] + s->block_offset[b], | |
427 s->stride[plane], s->block_coeff[b]); | |
3695 | 428 } |
429 break; | |
430 | |
431 case VP56_MB_INTER_NOVEC_PF: | |
432 case VP56_MB_INTER_NOVEC_GF: | |
5714
314be1cfdcb0
add a new vp6a codec (add alpha plan support to vp6)
aurel
parents:
5711
diff
changeset
|
433 for (b=0; b<b_max; b++) { |
5717 | 434 plane = vp56_b2p[b+ab]; |
3695 | 435 off = s->block_offset[b]; |
5717 | 436 s->dsp.put_pixels_tab[1][0](frame_current->data[plane] + off, |
437 frame_ref->data[plane] + off, | |
438 s->stride[plane], 8); | |
439 s->dsp.idct_add(frame_current->data[plane] + off, | |
440 s->stride[plane], s->block_coeff[b]); | |
3695 | 441 } |
442 break; | |
443 | |
444 case VP56_MB_INTER_DELTA_PF: | |
445 case VP56_MB_INTER_V1_PF: | |
446 case VP56_MB_INTER_V2_PF: | |
447 case VP56_MB_INTER_DELTA_GF: | |
448 case VP56_MB_INTER_4V: | |
449 case VP56_MB_INTER_V1_GF: | |
450 case VP56_MB_INTER_V2_GF: | |
5714
314be1cfdcb0
add a new vp6a codec (add alpha plan support to vp6)
aurel
parents:
5711
diff
changeset
|
451 for (b=0; b<b_max; b++) { |
3695 | 452 int x_off = b==1 || b==3 ? 8 : 0; |
453 int y_off = b==2 || b==3 ? 8 : 0; | |
5717 | 454 plane = vp56_b2p[b+ab]; |
455 vp56_mc(s, b, plane, frame_ref->data[plane], s->stride[plane], | |
3695 | 456 16*col+x_off, 16*row+y_off); |
5717 | 457 s->dsp.idct_add(frame_current->data[plane] + s->block_offset[b], |
458 s->stride[plane], s->block_coeff[b]); | |
3695 | 459 } |
460 break; | |
461 } | |
462 } | |
463 | |
5708 | 464 static int vp56_size_changed(AVCodecContext *avctx) |
3695 | 465 { |
8299 | 466 VP56Context *s = avctx->priv_data; |
4595 | 467 int stride = s->framep[VP56_FRAME_CURRENT]->linesize[0]; |
3695 | 468 int i; |
469 | |
5714
314be1cfdcb0
add a new vp6a codec (add alpha plan support to vp6)
aurel
parents:
5711
diff
changeset
|
470 s->plane_width[0] = s->plane_width[3] = avctx->coded_width; |
5708 | 471 s->plane_width[1] = s->plane_width[2] = avctx->coded_width/2; |
5714
314be1cfdcb0
add a new vp6a codec (add alpha plan support to vp6)
aurel
parents:
5711
diff
changeset
|
472 s->plane_height[0] = s->plane_height[3] = avctx->coded_height; |
5708 | 473 s->plane_height[1] = s->plane_height[2] = avctx->coded_height/2; |
3695 | 474 |
5714
314be1cfdcb0
add a new vp6a codec (add alpha plan support to vp6)
aurel
parents:
5711
diff
changeset
|
475 for (i=0; i<4; i++) |
4595 | 476 s->stride[i] = s->flip * s->framep[VP56_FRAME_CURRENT]->linesize[i]; |
3695 | 477 |
5708 | 478 s->mb_width = (avctx->coded_width +15) / 16; |
479 s->mb_height = (avctx->coded_height+15) / 16; | |
3695 | 480 |
481 if (s->mb_width > 1000 || s->mb_height > 1000) { | |
482 av_log(avctx, AV_LOG_ERROR, "picture too big\n"); | |
483 return -1; | |
484 } | |
485 | |
11053
c57e72227d7d
Make VP5 and VP6 decoders output a qscale table to allow for more automatic
reimar
parents:
11050
diff
changeset
|
486 s->qscale_table = av_realloc(s->qscale_table, s->mb_width); |
3695 | 487 s->above_blocks = av_realloc(s->above_blocks, |
488 (4*s->mb_width+6) * sizeof(*s->above_blocks)); | |
489 s->macroblocks = av_realloc(s->macroblocks, | |
490 s->mb_width*s->mb_height*sizeof(*s->macroblocks)); | |
3715
cdaee53c5da1
replaces back some C code by dsp.put_pixels_tab[0][0] (revert r6231)
aurel
parents:
3706
diff
changeset
|
491 av_free(s->edge_emu_buffer_alloc); |
cdaee53c5da1
replaces back some C code by dsp.put_pixels_tab[0][0] (revert r6231)
aurel
parents:
3706
diff
changeset
|
492 s->edge_emu_buffer_alloc = av_malloc(16*stride); |
3695 | 493 s->edge_emu_buffer = s->edge_emu_buffer_alloc; |
494 if (s->flip < 0) | |
495 s->edge_emu_buffer += 15 * stride; | |
496 | |
497 return 0; | |
498 } | |
499 | |
500 int vp56_decode_frame(AVCodecContext *avctx, void *data, int *data_size, | |
9356
2983bd7deaf5
fix vp5/vp6 decoding by using new prototype for decode function
aurel
parents:
8782
diff
changeset
|
501 AVPacket *avpkt) |
3695 | 502 { |
9356
2983bd7deaf5
fix vp5/vp6 decoding by using new prototype for decode function
aurel
parents:
8782
diff
changeset
|
503 const uint8_t *buf = avpkt->data; |
8299 | 504 VP56Context *s = avctx->priv_data; |
4595 | 505 AVFrame *const p = s->framep[VP56_FRAME_CURRENT]; |
9356
2983bd7deaf5
fix vp5/vp6 decoding by using new prototype for decode function
aurel
parents:
8782
diff
changeset
|
506 int remaining_buf_size = avpkt->size; |
8782 | 507 int is_alpha, av_uninit(alpha_offset); |
5714
314be1cfdcb0
add a new vp6a codec (add alpha plan support to vp6)
aurel
parents:
5711
diff
changeset
|
508 |
314be1cfdcb0
add a new vp6a codec (add alpha plan support to vp6)
aurel
parents:
5711
diff
changeset
|
509 if (s->has_alpha) { |
11050
170c9ce34d14
vp56: check buffer size to fix a potential segfault
aurel
parents:
10968
diff
changeset
|
510 if (remaining_buf_size < 3) |
170c9ce34d14
vp56: check buffer size to fix a potential segfault
aurel
parents:
10968
diff
changeset
|
511 return -1; |
5714
314be1cfdcb0
add a new vp6a codec (add alpha plan support to vp6)
aurel
parents:
5711
diff
changeset
|
512 alpha_offset = bytestream_get_be24(&buf); |
6756
c00f5cad61cc
ensure vp56_decode_frame always return unchanged buf_size
aurel
parents:
6517
diff
changeset
|
513 remaining_buf_size -= 3; |
11050
170c9ce34d14
vp56: check buffer size to fix a potential segfault
aurel
parents:
10968
diff
changeset
|
514 if (remaining_buf_size < alpha_offset) |
170c9ce34d14
vp56: check buffer size to fix a potential segfault
aurel
parents:
10968
diff
changeset
|
515 return -1; |
5714
314be1cfdcb0
add a new vp6a codec (add alpha plan support to vp6)
aurel
parents:
5711
diff
changeset
|
516 } |
314be1cfdcb0
add a new vp6a codec (add alpha plan support to vp6)
aurel
parents:
5711
diff
changeset
|
517 |
314be1cfdcb0
add a new vp6a codec (add alpha plan support to vp6)
aurel
parents:
5711
diff
changeset
|
518 for (is_alpha=0; is_alpha < 1+s->has_alpha; is_alpha++) { |
5715 | 519 int mb_row, mb_col, mb_row_flip, mb_offset = 0; |
520 int block, y, uv, stride_y, stride_uv; | |
521 int golden_frame = 0; | |
522 int res; | |
3695 | 523 |
5715 | 524 s->modelp = &s->models[is_alpha]; |
3695 | 525 |
6756
c00f5cad61cc
ensure vp56_decode_frame always return unchanged buf_size
aurel
parents:
6517
diff
changeset
|
526 res = s->parse_header(s, buf, remaining_buf_size, &golden_frame); |
5715 | 527 if (!res) |
528 return -1; | |
3695 | 529 |
5715 | 530 if (!is_alpha) { |
531 p->reference = 1; | |
532 if (avctx->get_buffer(avctx, p) < 0) { | |
533 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n"); | |
534 return -1; | |
3695 | 535 } |
536 | |
5715 | 537 if (res == 2) |
538 if (vp56_size_changed(avctx)) { | |
539 avctx->release_buffer(avctx, p); | |
540 return -1; | |
541 } | |
542 } | |
543 | |
544 if (p->key_frame) { | |
545 p->pict_type = FF_I_TYPE; | |
546 s->default_models_init(s); | |
547 for (block=0; block<s->mb_height*s->mb_width; block++) | |
548 s->macroblocks[block].type = VP56_MB_INTRA; | |
549 } else { | |
550 p->pict_type = FF_P_TYPE; | |
551 vp56_parse_mb_type_models(s); | |
552 s->parse_vector_models(s); | |
553 s->mb_type = VP56_MB_INTER_NOVEC_PF; | |
554 } | |
555 | |
556 s->parse_coeff_models(s); | |
557 | |
558 memset(s->prev_dc, 0, sizeof(s->prev_dc)); | |
559 s->prev_dc[1][VP56_FRAME_CURRENT] = 128; | |
560 s->prev_dc[2][VP56_FRAME_CURRENT] = 128; | |
561 | |
562 for (block=0; block < 4*s->mb_width+6; block++) { | |
6795 | 563 s->above_blocks[block].ref_frame = VP56_FRAME_NONE; |
5715 | 564 s->above_blocks[block].dc_coeff = 0; |
565 s->above_blocks[block].not_null_dc = 0; | |
566 } | |
6795 | 567 s->above_blocks[2*s->mb_width + 2].ref_frame = VP56_FRAME_CURRENT; |
568 s->above_blocks[3*s->mb_width + 4].ref_frame = VP56_FRAME_CURRENT; | |
5715 | 569 |
570 stride_y = p->linesize[0]; | |
571 stride_uv = p->linesize[1]; | |
572 | |
573 if (s->flip < 0) | |
574 mb_offset = 7; | |
575 | |
576 /* main macroblocks loop */ | |
577 for (mb_row=0; mb_row<s->mb_height; mb_row++) { | |
578 if (s->flip < 0) | |
579 mb_row_flip = s->mb_height - mb_row - 1; | |
580 else | |
581 mb_row_flip = mb_row; | |
582 | |
583 for (block=0; block<4; block++) { | |
6795 | 584 s->left_block[block].ref_frame = VP56_FRAME_NONE; |
5715 | 585 s->left_block[block].dc_coeff = 0; |
586 s->left_block[block].not_null_dc = 0; | |
587 } | |
5716 | 588 memset(s->coeff_ctx, 0, sizeof(s->coeff_ctx)); |
5715 | 589 memset(s->coeff_ctx_last, 24, sizeof(s->coeff_ctx_last)); |
590 | |
591 s->above_block_idx[0] = 1; | |
592 s->above_block_idx[1] = 2; | |
593 s->above_block_idx[2] = 1; | |
594 s->above_block_idx[3] = 2; | |
595 s->above_block_idx[4] = 2*s->mb_width + 2 + 1; | |
596 s->above_block_idx[5] = 3*s->mb_width + 4 + 1; | |
597 | |
598 s->block_offset[s->frbi] = (mb_row_flip*16 + mb_offset) * stride_y; | |
599 s->block_offset[s->srbi] = s->block_offset[s->frbi] + 8*stride_y; | |
600 s->block_offset[1] = s->block_offset[0] + 8; | |
601 s->block_offset[3] = s->block_offset[2] + 8; | |
602 s->block_offset[4] = (mb_row_flip*8 + mb_offset) * stride_uv; | |
603 s->block_offset[5] = s->block_offset[4]; | |
604 | |
605 for (mb_col=0; mb_col<s->mb_width; mb_col++) { | |
606 vp56_decode_mb(s, mb_row, mb_col, is_alpha); | |
607 | |
608 for (y=0; y<4; y++) { | |
609 s->above_block_idx[y] += 2; | |
610 s->block_offset[y] += 16; | |
611 } | |
612 | |
613 for (uv=4; uv<6; uv++) { | |
614 s->above_block_idx[uv] += 1; | |
615 s->block_offset[uv] += 8; | |
616 } | |
3695 | 617 } |
618 } | |
619 | |
5715 | 620 if (p->key_frame || golden_frame) { |
621 if (s->framep[VP56_FRAME_GOLDEN]->data[0] && | |
622 s->framep[VP56_FRAME_GOLDEN] != s->framep[VP56_FRAME_GOLDEN2]) | |
623 avctx->release_buffer(avctx, s->framep[VP56_FRAME_GOLDEN]); | |
624 s->framep[VP56_FRAME_GOLDEN] = p; | |
625 } | |
5714
314be1cfdcb0
add a new vp6a codec (add alpha plan support to vp6)
aurel
parents:
5711
diff
changeset
|
626 |
5715 | 627 if (s->has_alpha) { |
628 FFSWAP(AVFrame *, s->framep[VP56_FRAME_GOLDEN], | |
629 s->framep[VP56_FRAME_GOLDEN2]); | |
630 buf += alpha_offset; | |
6756
c00f5cad61cc
ensure vp56_decode_frame always return unchanged buf_size
aurel
parents:
6517
diff
changeset
|
631 remaining_buf_size -= alpha_offset; |
5715 | 632 } |
5714
314be1cfdcb0
add a new vp6a codec (add alpha plan support to vp6)
aurel
parents:
5711
diff
changeset
|
633 } |
314be1cfdcb0
add a new vp6a codec (add alpha plan support to vp6)
aurel
parents:
5711
diff
changeset
|
634 |
314be1cfdcb0
add a new vp6a codec (add alpha plan support to vp6)
aurel
parents:
5711
diff
changeset
|
635 if (s->framep[VP56_FRAME_PREVIOUS] == s->framep[VP56_FRAME_GOLDEN] || |
314be1cfdcb0
add a new vp6a codec (add alpha plan support to vp6)
aurel
parents:
5711
diff
changeset
|
636 s->framep[VP56_FRAME_PREVIOUS] == s->framep[VP56_FRAME_GOLDEN2]) { |
314be1cfdcb0
add a new vp6a codec (add alpha plan support to vp6)
aurel
parents:
5711
diff
changeset
|
637 if (s->framep[VP56_FRAME_UNUSED] != s->framep[VP56_FRAME_GOLDEN] && |
314be1cfdcb0
add a new vp6a codec (add alpha plan support to vp6)
aurel
parents:
5711
diff
changeset
|
638 s->framep[VP56_FRAME_UNUSED] != s->framep[VP56_FRAME_GOLDEN2]) |
314be1cfdcb0
add a new vp6a codec (add alpha plan support to vp6)
aurel
parents:
5711
diff
changeset
|
639 FFSWAP(AVFrame *, s->framep[VP56_FRAME_PREVIOUS], |
314be1cfdcb0
add a new vp6a codec (add alpha plan support to vp6)
aurel
parents:
5711
diff
changeset
|
640 s->framep[VP56_FRAME_UNUSED]); |
314be1cfdcb0
add a new vp6a codec (add alpha plan support to vp6)
aurel
parents:
5711
diff
changeset
|
641 else |
314be1cfdcb0
add a new vp6a codec (add alpha plan support to vp6)
aurel
parents:
5711
diff
changeset
|
642 FFSWAP(AVFrame *, s->framep[VP56_FRAME_PREVIOUS], |
314be1cfdcb0
add a new vp6a codec (add alpha plan support to vp6)
aurel
parents:
5711
diff
changeset
|
643 s->framep[VP56_FRAME_UNUSED2]); |
314be1cfdcb0
add a new vp6a codec (add alpha plan support to vp6)
aurel
parents:
5711
diff
changeset
|
644 } else if (s->framep[VP56_FRAME_PREVIOUS]->data[0]) |
314be1cfdcb0
add a new vp6a codec (add alpha plan support to vp6)
aurel
parents:
5711
diff
changeset
|
645 avctx->release_buffer(avctx, s->framep[VP56_FRAME_PREVIOUS]); |
4595 | 646 FFSWAP(AVFrame *, s->framep[VP56_FRAME_CURRENT], |
647 s->framep[VP56_FRAME_PREVIOUS]); | |
3695 | 648 |
11053
c57e72227d7d
Make VP5 and VP6 decoders output a qscale table to allow for more automatic
reimar
parents:
11050
diff
changeset
|
649 p->qstride = 0; |
c57e72227d7d
Make VP5 and VP6 decoders output a qscale table to allow for more automatic
reimar
parents:
11050
diff
changeset
|
650 p->qscale_table = s->qscale_table; |
c57e72227d7d
Make VP5 and VP6 decoders output a qscale table to allow for more automatic
reimar
parents:
11050
diff
changeset
|
651 p->qscale_type = FF_QSCALE_TYPE_VP56; |
4596 | 652 *(AVFrame*)data = *p; |
653 *data_size = sizeof(AVFrame); | |
3695 | 654 |
9356
2983bd7deaf5
fix vp5/vp6 decoding by using new prototype for decode function
aurel
parents:
8782
diff
changeset
|
655 return avpkt->size; |
3695 | 656 } |
657 | |
6517
48759bfbd073
Apply 'cold' attribute to init/uninit functions in libavcodec
zuxy
parents:
6297
diff
changeset
|
658 av_cold void vp56_init(AVCodecContext *avctx, int flip, int has_alpha) |
3695 | 659 { |
8299 | 660 VP56Context *s = avctx->priv_data; |
3695 | 661 int i; |
662 | |
663 s->avctx = avctx; | |
5714
314be1cfdcb0
add a new vp6a codec (add alpha plan support to vp6)
aurel
parents:
5711
diff
changeset
|
664 avctx->pix_fmt = has_alpha ? PIX_FMT_YUVA420P : PIX_FMT_YUV420P; |
3695 | 665 |
5708 | 666 if (avctx->idct_algo == FF_IDCT_AUTO) |
667 avctx->idct_algo = FF_IDCT_VP3; | |
668 dsputil_init(&s->dsp, avctx); | |
3695 | 669 ff_init_scantable(s->dsp.idct_permutation, &s->scantable,ff_zigzag_direct); |
670 | |
5714
314be1cfdcb0
add a new vp6a codec (add alpha plan support to vp6)
aurel
parents:
5711
diff
changeset
|
671 for (i=0; i<4; i++) |
4595 | 672 s->framep[i] = &s->frames[i]; |
673 s->framep[VP56_FRAME_UNUSED] = s->framep[VP56_FRAME_GOLDEN]; | |
5714
314be1cfdcb0
add a new vp6a codec (add alpha plan support to vp6)
aurel
parents:
5711
diff
changeset
|
674 s->framep[VP56_FRAME_UNUSED2] = s->framep[VP56_FRAME_GOLDEN2]; |
3695 | 675 s->edge_emu_buffer_alloc = NULL; |
676 | |
677 s->above_blocks = NULL; | |
678 s->macroblocks = NULL; | |
679 s->quantizer = -1; | |
680 s->deblock_filtering = 1; | |
681 | |
682 s->filter = NULL; | |
683 | |
5714
314be1cfdcb0
add a new vp6a codec (add alpha plan support to vp6)
aurel
parents:
5711
diff
changeset
|
684 s->has_alpha = has_alpha; |
3695 | 685 if (flip) { |
686 s->flip = -1; | |
687 s->frbi = 2; | |
688 s->srbi = 0; | |
689 } else { | |
690 s->flip = 1; | |
691 s->frbi = 0; | |
692 s->srbi = 2; | |
693 } | |
694 } | |
695 | |
6517
48759bfbd073
Apply 'cold' attribute to init/uninit functions in libavcodec
zuxy
parents:
6297
diff
changeset
|
696 av_cold int vp56_free(AVCodecContext *avctx) |
3695 | 697 { |
8299 | 698 VP56Context *s = avctx->priv_data; |
11342 | 699 int pt; |
3695 | 700 |
11053
c57e72227d7d
Make VP5 and VP6 decoders output a qscale table to allow for more automatic
reimar
parents:
11050
diff
changeset
|
701 av_freep(&s->qscale_table); |
10968
c1cccc058c7a
Use av_freep intead of av_free to free pointers in vp56 context.
reimar
parents:
9356
diff
changeset
|
702 av_freep(&s->above_blocks); |
c1cccc058c7a
Use av_freep intead of av_free to free pointers in vp56 context.
reimar
parents:
9356
diff
changeset
|
703 av_freep(&s->macroblocks); |
c1cccc058c7a
Use av_freep intead of av_free to free pointers in vp56 context.
reimar
parents:
9356
diff
changeset
|
704 av_freep(&s->edge_emu_buffer_alloc); |
5708 | 705 if (s->framep[VP56_FRAME_GOLDEN]->data[0]) |
4595 | 706 avctx->release_buffer(avctx, s->framep[VP56_FRAME_GOLDEN]); |
5714
314be1cfdcb0
add a new vp6a codec (add alpha plan support to vp6)
aurel
parents:
5711
diff
changeset
|
707 if (s->framep[VP56_FRAME_GOLDEN2]->data[0]) |
314be1cfdcb0
add a new vp6a codec (add alpha plan support to vp6)
aurel
parents:
5711
diff
changeset
|
708 avctx->release_buffer(avctx, s->framep[VP56_FRAME_GOLDEN2]); |
4595 | 709 if (s->framep[VP56_FRAME_PREVIOUS]->data[0]) |
710 avctx->release_buffer(avctx, s->framep[VP56_FRAME_PREVIOUS]); | |
11342 | 711 |
712 for (pt=0; pt < 2; pt++) { | |
713 int ct, cg; | |
714 free_vlc(&s->dccv_vlc[pt]); | |
715 free_vlc(&s->runv_vlc[pt]); | |
716 for (ct=0; ct<3; ct++) | |
717 for (cg = 0; cg < 6; cg++) | |
718 free_vlc(&s->ract_vlc[pt][ct][cg]); | |
719 } | |
720 | |
3695 | 721 return 0; |
722 } |