2 * Copyright (C) 2006 Aurelien Jacobs <aurel@gnuage.org>
4 * This file is part of FFmpeg.
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.
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.
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
23 * VP5 and VP6 compatible video decoder (common features)
27 #include "bytestream.h"
29 #include "h264chroma.h"
34 void ff_vp56_init_dequant(VP56Context
*s
, int quantizer
)
36 s
->quantizer
= quantizer
;
37 s
->dequant_dc
= ff_vp56_dc_dequant
[quantizer
] << 2;
38 s
->dequant_ac
= ff_vp56_ac_dequant
[quantizer
] << 2;
41 static int vp56_get_vectors_predictors(VP56Context
*s
, int row
, int col
,
45 VP56mv vect
[2] = {{0,0}, {0,0}};
49 for (pos
=0; pos
<12; pos
++) {
50 mvp
.x
= col
+ ff_vp56_candidate_predictor_pos
[pos
][0];
51 mvp
.y
= row
+ ff_vp56_candidate_predictor_pos
[pos
][1];
52 if (mvp
.x
< 0 || mvp
.x
>= s
->mb_width
||
53 mvp
.y
< 0 || mvp
.y
>= s
->mb_height
)
55 offset
= mvp
.x
+ s
->mb_width
*mvp
.y
;
57 if (ff_vp56_reference_frame
[s
->macroblocks
[offset
].type
] != ref_frame
)
59 if ((s
->macroblocks
[offset
].mv
.x
== vect
[0].x
&&
60 s
->macroblocks
[offset
].mv
.y
== vect
[0].y
) ||
61 (s
->macroblocks
[offset
].mv
.x
== 0 &&
62 s
->macroblocks
[offset
].mv
.y
== 0))
65 vect
[nb_pred
++] = s
->macroblocks
[offset
].mv
;
70 s
->vector_candidate_pos
= pos
;
73 s
->vector_candidate
[0] = vect
[0];
74 s
->vector_candidate
[1] = vect
[1];
79 static void vp56_parse_mb_type_models(VP56Context
*s
)
81 VP56RangeCoder
*c
= &s
->c
;
82 VP56Model
*model
= s
->modelp
;
85 for (ctx
=0; ctx
<3; ctx
++) {
86 if (vp56_rac_get_prob_branchy(c
, 174)) {
87 int idx
= vp56_rac_gets(c
, 4);
88 memcpy(model
->mb_types_stats
[ctx
],
89 ff_vp56_pre_def_mb_type_stats
[idx
][ctx
],
90 sizeof(model
->mb_types_stats
[ctx
]));
92 if (vp56_rac_get_prob_branchy(c
, 254)) {
93 for (type
=0; type
<10; type
++) {
95 if (vp56_rac_get_prob_branchy(c
, 205)) {
96 int delta
, sign
= vp56_rac_get(c
);
98 delta
= vp56_rac_get_tree(c
, ff_vp56_pmbtm_tree
,
99 ff_vp56_mb_type_model_model
);
101 delta
= 4 * vp56_rac_gets(c
, 7);
102 model
->mb_types_stats
[ctx
][type
][i
] += (delta
^ -sign
) + sign
;
109 /* compute MB type probability tables based on previous MB type */
110 for (ctx
=0; ctx
<3; ctx
++) {
113 for (type
=0; type
<10; type
++)
114 p
[type
] = 100 * model
->mb_types_stats
[ctx
][type
][1];
116 for (type
=0; type
<10; type
++) {
117 int p02
, p34
, p0234
, p17
, p56
, p89
, p5689
, p156789
;
119 /* conservative MB type probability */
120 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]);
122 p
[type
] = 0; /* same MB type => weight is null */
124 /* binary tree parsing probabilities */
132 p156789
= p17
+ p5689
;
134 model
->mb_type
[ctx
][type
][1] = 1 + 255 * p0234
/(1+p0234
+p156789
);
135 model
->mb_type
[ctx
][type
][2] = 1 + 255 * p02
/ (1+p0234
);
136 model
->mb_type
[ctx
][type
][3] = 1 + 255 * p17
/ (1+p156789
);
137 model
->mb_type
[ctx
][type
][4] = 1 + 255 * p
[0] / (1+p02
);
138 model
->mb_type
[ctx
][type
][5] = 1 + 255 * p
[3] / (1+p34
);
139 model
->mb_type
[ctx
][type
][6] = 1 + 255 * p
[1] / (1+p17
);
140 model
->mb_type
[ctx
][type
][7] = 1 + 255 * p56
/ (1+p5689
);
141 model
->mb_type
[ctx
][type
][8] = 1 + 255 * p
[5] / (1+p56
);
142 model
->mb_type
[ctx
][type
][9] = 1 + 255 * p
[8] / (1+p89
);
144 /* restore initial value */
145 p
[type
] = 100 * model
->mb_types_stats
[ctx
][type
][1];
150 static VP56mb
vp56_parse_mb_type(VP56Context
*s
,
151 VP56mb prev_type
, int ctx
)
153 uint8_t *mb_type_model
= s
->modelp
->mb_type
[ctx
][prev_type
];
154 VP56RangeCoder
*c
= &s
->c
;
156 if (vp56_rac_get_prob_branchy(c
, mb_type_model
[0]))
159 return vp56_rac_get_tree(c
, ff_vp56_pmbt_tree
, mb_type_model
);
162 static void vp56_decode_4mv(VP56Context
*s
, int row
, int col
)
168 /* parse each block type */
169 for (b
=0; b
<4; b
++) {
170 type
[b
] = vp56_rac_gets(&s
->c
, 2);
172 type
[b
]++; /* only returns 0, 2, 3 or 4 (all INTER_PF) */
176 for (b
=0; b
<4; b
++) {
178 case VP56_MB_INTER_NOVEC_PF
:
179 s
->mv
[b
] = (VP56mv
) {0,0};
181 case VP56_MB_INTER_DELTA_PF
:
182 s
->parse_vector_adjustment(s
, &s
->mv
[b
]);
184 case VP56_MB_INTER_V1_PF
:
185 s
->mv
[b
] = s
->vector_candidate
[0];
187 case VP56_MB_INTER_V2_PF
:
188 s
->mv
[b
] = s
->vector_candidate
[1];
195 /* this is the one selected for the whole MB for prediction */
196 s
->macroblocks
[row
* s
->mb_width
+ col
].mv
= s
->mv
[3];
198 /* chroma vectors are average luma vectors */
199 if (s
->avctx
->codec
->id
== AV_CODEC_ID_VP5
) {
200 s
->mv
[4].x
= s
->mv
[5].x
= RSHIFT(mv
.x
,2);
201 s
->mv
[4].y
= s
->mv
[5].y
= RSHIFT(mv
.y
,2);
203 s
->mv
[4] = s
->mv
[5] = (VP56mv
) {mv
.x
/4, mv
.y
/4};
207 static VP56mb
vp56_decode_mv(VP56Context
*s
, int row
, int col
)
209 VP56mv
*mv
, vect
= {0,0};
212 ctx
= vp56_get_vectors_predictors(s
, row
, col
, VP56_FRAME_PREVIOUS
);
213 s
->mb_type
= vp56_parse_mb_type(s
, s
->mb_type
, ctx
);
214 s
->macroblocks
[row
* s
->mb_width
+ col
].type
= s
->mb_type
;
216 switch (s
->mb_type
) {
217 case VP56_MB_INTER_V1_PF
:
218 mv
= &s
->vector_candidate
[0];
221 case VP56_MB_INTER_V2_PF
:
222 mv
= &s
->vector_candidate
[1];
225 case VP56_MB_INTER_V1_GF
:
226 vp56_get_vectors_predictors(s
, row
, col
, VP56_FRAME_GOLDEN
);
227 mv
= &s
->vector_candidate
[0];
230 case VP56_MB_INTER_V2_GF
:
231 vp56_get_vectors_predictors(s
, row
, col
, VP56_FRAME_GOLDEN
);
232 mv
= &s
->vector_candidate
[1];
235 case VP56_MB_INTER_DELTA_PF
:
236 s
->parse_vector_adjustment(s
, &vect
);
240 case VP56_MB_INTER_DELTA_GF
:
241 vp56_get_vectors_predictors(s
, row
, col
, VP56_FRAME_GOLDEN
);
242 s
->parse_vector_adjustment(s
, &vect
);
246 case VP56_MB_INTER_4V
:
247 vp56_decode_4mv(s
, row
, col
);
255 s
->macroblocks
[row
*s
->mb_width
+ col
].mv
= *mv
;
257 /* same vector for all blocks */
264 static void vp56_add_predictors_dc(VP56Context
*s
, VP56Frame ref_frame
)
266 int idx
= s
->idct_scantable
[0];
269 for (b
=0; b
<6; b
++) {
270 VP56RefDc
*ab
= &s
->above_blocks
[s
->above_block_idx
[b
]];
271 VP56RefDc
*lb
= &s
->left_block
[ff_vp56_b6to4
[b
]];
276 if (ref_frame
== lb
->ref_frame
) {
280 if (ref_frame
== ab
->ref_frame
) {
284 if (s
->avctx
->codec
->id
== AV_CODEC_ID_VP5
)
286 if (count
< 2 && ref_frame
== ab
[-1+2*i
].ref_frame
) {
287 dc
+= ab
[-1+2*i
].dc_coeff
;
291 dc
= s
->prev_dc
[ff_vp56_b2p
[b
]][ref_frame
];
295 s
->block_coeff
[b
][idx
] += dc
;
296 s
->prev_dc
[ff_vp56_b2p
[b
]][ref_frame
] = s
->block_coeff
[b
][idx
];
297 ab
->dc_coeff
= s
->block_coeff
[b
][idx
];
298 ab
->ref_frame
= ref_frame
;
299 lb
->dc_coeff
= s
->block_coeff
[b
][idx
];
300 lb
->ref_frame
= ref_frame
;
301 s
->block_coeff
[b
][idx
] *= s
->dequant_dc
;
305 static void vp56_deblock_filter(VP56Context
*s
, uint8_t *yuv
,
306 ptrdiff_t stride
, int dx
, int dy
)
308 int t
= ff_vp56_filter_threshold
[s
->quantizer
];
309 if (dx
) s
->vp56dsp
.edge_filter_hor(yuv
+ 10-dx
, stride
, t
);
310 if (dy
) s
->vp56dsp
.edge_filter_ver(yuv
+ stride
*(10-dy
), stride
, t
);
313 static void vp56_mc(VP56Context
*s
, int b
, int plane
, uint8_t *src
,
314 ptrdiff_t stride
, int x
, int y
)
316 uint8_t *dst
= s
->frames
[VP56_FRAME_CURRENT
]->data
[plane
] + s
->block_offset
[b
];
319 int overlap_offset
= 0;
320 int mask
= s
->vp56_coord_div
[b
] - 1;
321 int deblock_filtering
= s
->deblock_filtering
;
325 if (s
->avctx
->skip_loop_filter
>= AVDISCARD_ALL
||
326 (s
->avctx
->skip_loop_filter
>= AVDISCARD_NONKEY
327 && !s
->frames
[VP56_FRAME_CURRENT
]->key_frame
))
328 deblock_filtering
= 0;
330 dx
= s
->mv
[b
].x
/ s
->vp56_coord_div
[b
];
331 dy
= s
->mv
[b
].y
/ s
->vp56_coord_div
[b
];
340 if (x
<0 || x
+12>=s
->plane_width
[plane
] ||
341 y
<0 || y
+12>=s
->plane_height
[plane
]) {
342 s
->vdsp
.emulated_edge_mc(s
->edge_emu_buffer
,
343 src
+ s
->block_offset
[b
] + (dy
-2)*stride
+ (dx
-2),
346 s
->plane_width
[plane
],
347 s
->plane_height
[plane
]);
348 src_block
= s
->edge_emu_buffer
;
349 src_offset
= 2 + 2*stride
;
350 } else if (deblock_filtering
) {
351 /* only need a 12x12 block, but there is no such dsp function, */
352 /* so copy a 16x12 block */
353 s
->hdsp
.put_pixels_tab
[0][0](s
->edge_emu_buffer
,
354 src
+ s
->block_offset
[b
] + (dy
-2)*stride
+ (dx
-2),
356 src_block
= s
->edge_emu_buffer
;
357 src_offset
= 2 + 2*stride
;
360 src_offset
= s
->block_offset
[b
] + dy
*stride
+ dx
;
363 if (deblock_filtering
)
364 vp56_deblock_filter(s
, src_block
, stride
, dx
&7, dy
&7);
366 if (s
->mv
[b
].x
& mask
)
367 overlap_offset
+= (s
->mv
[b
].x
> 0) ? 1 : -1;
368 if (s
->mv
[b
].y
& mask
)
369 overlap_offset
+= (s
->mv
[b
].y
> 0) ? stride
: -stride
;
371 if (overlap_offset
) {
373 s
->filter(s
, dst
, src_block
, src_offset
, src_offset
+overlap_offset
,
374 stride
, s
->mv
[b
], mask
, s
->filter_selection
, b
<4);
376 s
->vp3dsp
.put_no_rnd_pixels_l2(dst
, src_block
+src_offset
,
377 src_block
+src_offset
+overlap_offset
,
380 s
->hdsp
.put_pixels_tab
[1][0](dst
, src_block
+src_offset
, stride
, 8);
384 static void vp56_decode_mb(VP56Context
*s
, int row
, int col
, int is_alpha
)
386 AVFrame
*frame_current
, *frame_ref
;
389 int b
, ab
, b_max
, plane
, off
;
391 if (s
->frames
[VP56_FRAME_CURRENT
]->key_frame
)
392 mb_type
= VP56_MB_INTRA
;
394 mb_type
= vp56_decode_mv(s
, row
, col
);
395 ref_frame
= ff_vp56_reference_frame
[mb_type
];
399 vp56_add_predictors_dc(s
, ref_frame
);
401 frame_current
= s
->frames
[VP56_FRAME_CURRENT
];
402 frame_ref
= s
->frames
[ref_frame
];
403 if (mb_type
!= VP56_MB_INTRA
&& !frame_ref
->data
[0])
407 b_max
= 6 - 2*is_alpha
;
411 for (b
=0; b
<b_max
; b
++) {
412 plane
= ff_vp56_b2p
[b
+ab
];
413 s
->vp3dsp
.idct_put(frame_current
->data
[plane
] + s
->block_offset
[b
],
414 s
->stride
[plane
], s
->block_coeff
[b
]);
418 case VP56_MB_INTER_NOVEC_PF
:
419 case VP56_MB_INTER_NOVEC_GF
:
420 for (b
=0; b
<b_max
; b
++) {
421 plane
= ff_vp56_b2p
[b
+ab
];
422 off
= s
->block_offset
[b
];
423 s
->hdsp
.put_pixels_tab
[1][0](frame_current
->data
[plane
] + off
,
424 frame_ref
->data
[plane
] + off
,
425 s
->stride
[plane
], 8);
426 s
->vp3dsp
.idct_add(frame_current
->data
[plane
] + off
,
427 s
->stride
[plane
], s
->block_coeff
[b
]);
431 case VP56_MB_INTER_DELTA_PF
:
432 case VP56_MB_INTER_V1_PF
:
433 case VP56_MB_INTER_V2_PF
:
434 case VP56_MB_INTER_DELTA_GF
:
435 case VP56_MB_INTER_4V
:
436 case VP56_MB_INTER_V1_GF
:
437 case VP56_MB_INTER_V2_GF
:
438 for (b
=0; b
<b_max
; b
++) {
439 int x_off
= b
==1 || b
==3 ? 8 : 0;
440 int y_off
= b
==2 || b
==3 ? 8 : 0;
441 plane
= ff_vp56_b2p
[b
+ab
];
442 vp56_mc(s
, b
, plane
, frame_ref
->data
[plane
], s
->stride
[plane
],
443 16*col
+x_off
, 16*row
+y_off
);
444 s
->vp3dsp
.idct_add(frame_current
->data
[plane
] + s
->block_offset
[b
],
445 s
->stride
[plane
], s
->block_coeff
[b
]);
451 s
->block_coeff
[4][0] = 0;
452 s
->block_coeff
[5][0] = 0;
456 static int vp56_size_changed(VP56Context
*s
)
458 AVCodecContext
*avctx
= s
->avctx
;
459 int stride
= s
->frames
[VP56_FRAME_CURRENT
]->linesize
[0];
462 s
->plane_width
[0] = s
->plane_width
[3] = avctx
->coded_width
;
463 s
->plane_width
[1] = s
->plane_width
[2] = avctx
->coded_width
/2;
464 s
->plane_height
[0] = s
->plane_height
[3] = avctx
->coded_height
;
465 s
->plane_height
[1] = s
->plane_height
[2] = avctx
->coded_height
/2;
468 s
->stride
[i
] = s
->flip
* s
->frames
[VP56_FRAME_CURRENT
]->linesize
[i
];
470 s
->mb_width
= (avctx
->coded_width
+15) / 16;
471 s
->mb_height
= (avctx
->coded_height
+15) / 16;
473 if (s
->mb_width
> 1000 || s
->mb_height
> 1000) {
474 ff_set_dimensions(avctx
, 0, 0);
475 av_log(avctx
, AV_LOG_ERROR
, "picture too big\n");
479 av_reallocp_array(&s
->above_blocks
, 4*s
->mb_width
+6,
480 sizeof(*s
->above_blocks
));
481 av_reallocp_array(&s
->macroblocks
, s
->mb_width
*s
->mb_height
,
482 sizeof(*s
->macroblocks
));
483 av_free(s
->edge_emu_buffer_alloc
);
484 s
->edge_emu_buffer_alloc
= av_malloc(16*stride
);
485 s
->edge_emu_buffer
= s
->edge_emu_buffer_alloc
;
486 if (!s
->above_blocks
|| !s
->macroblocks
|| !s
->edge_emu_buffer_alloc
)
487 return AVERROR(ENOMEM
);
489 s
->edge_emu_buffer
+= 15 * stride
;
491 if (s
->alpha_context
)
492 return vp56_size_changed(s
->alpha_context
);
497 static int ff_vp56_decode_mbs(AVCodecContext
*avctx
, void *, int, int);
499 int ff_vp56_decode_frame(AVCodecContext
*avctx
, void *data
, int *got_frame
,
502 const uint8_t *buf
= avpkt
->data
;
503 VP56Context
*s
= avctx
->priv_data
;
504 AVFrame
*const p
= s
->frames
[VP56_FRAME_CURRENT
];
505 int remaining_buf_size
= avpkt
->size
;
506 int av_uninit(alpha_offset
);
511 if (remaining_buf_size
< 3)
513 alpha_offset
= bytestream_get_be24(&buf
);
514 remaining_buf_size
-= 3;
515 if (remaining_buf_size
< alpha_offset
)
519 res
= s
->parse_header(s
, buf
, remaining_buf_size
);
523 if (res
== VP56_SIZE_CHANGE
) {
524 for (i
= 0; i
< 4; i
++) {
525 av_frame_unref(s
->frames
[i
]);
526 if (s
->alpha_context
)
527 av_frame_unref(s
->alpha_context
->frames
[i
]);
531 if (ff_get_buffer(avctx
, p
, AV_GET_BUFFER_FLAG_REF
) < 0)
534 if (avctx
->pix_fmt
== AV_PIX_FMT_YUVA420P
) {
535 av_frame_unref(s
->alpha_context
->frames
[VP56_FRAME_CURRENT
]);
536 if ((ret
= av_frame_ref(s
->alpha_context
->frames
[VP56_FRAME_CURRENT
], p
)) < 0) {
542 if (res
== VP56_SIZE_CHANGE
) {
543 if (vp56_size_changed(s
)) {
549 if (avctx
->pix_fmt
== AV_PIX_FMT_YUVA420P
) {
550 int bak_w
= avctx
->width
;
551 int bak_h
= avctx
->height
;
552 int bak_cw
= avctx
->coded_width
;
553 int bak_ch
= avctx
->coded_height
;
555 remaining_buf_size
-= alpha_offset
;
557 res
= s
->alpha_context
->parse_header(s
->alpha_context
, buf
, remaining_buf_size
);
559 if(res
==VP56_SIZE_CHANGE
) {
560 av_log(avctx
, AV_LOG_ERROR
, "Alpha reconfiguration\n");
561 avctx
->width
= bak_w
;
562 avctx
->height
= bak_h
;
563 avctx
->coded_width
= bak_cw
;
564 avctx
->coded_height
= bak_ch
;
571 avctx
->execute2(avctx
, ff_vp56_decode_mbs
, 0, 0, (avctx
->pix_fmt
== AV_PIX_FMT_YUVA420P
) + 1);
573 if ((res
= av_frame_ref(data
, p
)) < 0)
580 static int ff_vp56_decode_mbs(AVCodecContext
*avctx
, void *data
,
581 int jobnr
, int threadnr
)
583 VP56Context
*s0
= avctx
->priv_data
;
584 int is_alpha
= (jobnr
== 1);
585 VP56Context
*s
= is_alpha
? s0
->alpha_context
: s0
;
586 AVFrame
*const p
= s
->frames
[VP56_FRAME_CURRENT
];
587 int mb_row
, mb_col
, mb_row_flip
, mb_offset
= 0;
589 ptrdiff_t stride_y
, stride_uv
;
593 p
->pict_type
= AV_PICTURE_TYPE_I
;
594 s
->default_models_init(s
);
595 for (block
=0; block
<s
->mb_height
*s
->mb_width
; block
++)
596 s
->macroblocks
[block
].type
= VP56_MB_INTRA
;
598 p
->pict_type
= AV_PICTURE_TYPE_P
;
599 vp56_parse_mb_type_models(s
);
600 s
->parse_vector_models(s
);
601 s
->mb_type
= VP56_MB_INTER_NOVEC_PF
;
604 if (s
->parse_coeff_models(s
))
607 memset(s
->prev_dc
, 0, sizeof(s
->prev_dc
));
608 s
->prev_dc
[1][VP56_FRAME_CURRENT
] = 128;
609 s
->prev_dc
[2][VP56_FRAME_CURRENT
] = 128;
611 for (block
=0; block
< 4*s
->mb_width
+6; block
++) {
612 s
->above_blocks
[block
].ref_frame
= VP56_FRAME_NONE
;
613 s
->above_blocks
[block
].dc_coeff
= 0;
614 s
->above_blocks
[block
].not_null_dc
= 0;
616 s
->above_blocks
[2*s
->mb_width
+ 2].ref_frame
= VP56_FRAME_CURRENT
;
617 s
->above_blocks
[3*s
->mb_width
+ 4].ref_frame
= VP56_FRAME_CURRENT
;
619 stride_y
= p
->linesize
[0];
620 stride_uv
= p
->linesize
[1];
625 /* main macroblocks loop */
626 for (mb_row
=0; mb_row
<s
->mb_height
; mb_row
++) {
628 mb_row_flip
= s
->mb_height
- mb_row
- 1;
630 mb_row_flip
= mb_row
;
632 for (block
=0; block
<4; block
++) {
633 s
->left_block
[block
].ref_frame
= VP56_FRAME_NONE
;
634 s
->left_block
[block
].dc_coeff
= 0;
635 s
->left_block
[block
].not_null_dc
= 0;
637 memset(s
->coeff_ctx
, 0, sizeof(s
->coeff_ctx
));
638 memset(s
->coeff_ctx_last
, 24, sizeof(s
->coeff_ctx_last
));
640 s
->above_block_idx
[0] = 1;
641 s
->above_block_idx
[1] = 2;
642 s
->above_block_idx
[2] = 1;
643 s
->above_block_idx
[3] = 2;
644 s
->above_block_idx
[4] = 2*s
->mb_width
+ 2 + 1;
645 s
->above_block_idx
[5] = 3*s
->mb_width
+ 4 + 1;
647 s
->block_offset
[s
->frbi
] = (mb_row_flip
*16 + mb_offset
) * stride_y
;
648 s
->block_offset
[s
->srbi
] = s
->block_offset
[s
->frbi
] + 8*stride_y
;
649 s
->block_offset
[1] = s
->block_offset
[0] + 8;
650 s
->block_offset
[3] = s
->block_offset
[2] + 8;
651 s
->block_offset
[4] = (mb_row_flip
*8 + mb_offset
) * stride_uv
;
652 s
->block_offset
[5] = s
->block_offset
[4];
654 for (mb_col
=0; mb_col
<s
->mb_width
; mb_col
++) {
655 vp56_decode_mb(s
, mb_row
, mb_col
, is_alpha
);
657 for (y
=0; y
<4; y
++) {
658 s
->above_block_idx
[y
] += 2;
659 s
->block_offset
[y
] += 16;
662 for (uv
=4; uv
<6; uv
++) {
663 s
->above_block_idx
[uv
] += 1;
664 s
->block_offset
[uv
] += 8;
670 if (p
->key_frame
|| s
->golden_frame
) {
671 av_frame_unref(s
->frames
[VP56_FRAME_GOLDEN
]);
672 if ((res
= av_frame_ref(s
->frames
[VP56_FRAME_GOLDEN
], p
)) < 0)
676 av_frame_unref(s
->frames
[VP56_FRAME_PREVIOUS
]);
677 FFSWAP(AVFrame
*, s
->frames
[VP56_FRAME_CURRENT
],
678 s
->frames
[VP56_FRAME_PREVIOUS
]);
682 av_cold
int ff_vp56_init(AVCodecContext
*avctx
, int flip
, int has_alpha
)
684 VP56Context
*s
= avctx
->priv_data
;
685 return ff_vp56_init_context(avctx
, s
, flip
, has_alpha
);
688 av_cold
int ff_vp56_init_context(AVCodecContext
*avctx
, VP56Context
*s
,
689 int flip
, int has_alpha
)
694 avctx
->pix_fmt
= has_alpha
? AV_PIX_FMT_YUVA420P
: AV_PIX_FMT_YUV420P
;
695 if (avctx
->skip_alpha
) avctx
->pix_fmt
= AV_PIX_FMT_YUV420P
;
697 ff_h264chroma_init(&s
->h264chroma
, 8);
698 ff_hpeldsp_init(&s
->hdsp
, avctx
->flags
);
699 ff_videodsp_init(&s
->vdsp
, 8);
700 ff_vp3dsp_init(&s
->vp3dsp
, avctx
->flags
);
701 ff_vp56dsp_init(&s
->vp56dsp
, avctx
->codec
->id
);
702 for (i
= 0; i
< 64; i
++) {
703 #define TRANSPOSE(x) (x >> 3) | ((x & 7) << 3)
704 s
->idct_scantable
[i
] = TRANSPOSE(ff_zigzag_direct
[i
]);
708 for (i
= 0; i
< FF_ARRAY_ELEMS(s
->frames
); i
++) {
709 s
->frames
[i
] = av_frame_alloc();
712 return AVERROR(ENOMEM
);
715 s
->edge_emu_buffer_alloc
= NULL
;
717 s
->above_blocks
= NULL
;
718 s
->macroblocks
= NULL
;
720 s
->deblock_filtering
= 1;
725 s
->has_alpha
= has_alpha
;
727 s
->modelp
= &s
->model
;
742 av_cold
int ff_vp56_free(AVCodecContext
*avctx
)
744 VP56Context
*s
= avctx
->priv_data
;
745 return ff_vp56_free_context(s
);
748 av_cold
int ff_vp56_free_context(VP56Context
*s
)
752 av_freep(&s
->above_blocks
);
753 av_freep(&s
->macroblocks
);
754 av_freep(&s
->edge_emu_buffer_alloc
);
756 for (i
= 0; i
< FF_ARRAY_ELEMS(s
->frames
); i
++)
757 av_frame_free(&s
->frames
[i
]);