36 if (s->quantizer != quantizer)
38 s->quantizer = quantizer;
47 VP56mv vect[2] = {{0,0}, {0,0}};
51 for (pos=0; pos<12; pos++) {
53 mvp.
y = row + ff_vp56_candidate_predictor_pos[
pos][1];
54 if (mvp.
x < 0 || mvp.
x >= s->mb_width ||
55 mvp.
y < 0 || mvp.
y >= s->mb_height)
57 offset = mvp.
x + s->mb_width*mvp.
y;
61 if ((s->macroblocks[offset].mv.x == vect[0].
x &&
62 s->macroblocks[offset].mv.y == vect[0].
y) ||
63 (s->macroblocks[offset].mv.x == 0 &&
64 s->macroblocks[offset].mv.y == 0))
67 vect[nb_pred++] = s->macroblocks[
offset].mv;
72 s->vector_candidate_pos =
pos;
75 s->vector_candidate[0] = vect[0];
76 s->vector_candidate[1] = vect[1];
87 for (ctx=0; ctx<3; ctx++) {
95 for (type=0; type<10; type++) {
112 for (ctx=0; ctx<3; ctx++) {
115 for (type=0; type<10; type++)
118 for (type=0; type<10; type++) {
119 int p02, p34, p0234, p17, p56, p89, p5689, p156789;
134 p156789 = p17 + p5689;
155 uint8_t *mb_type_model = s->modelp->mb_type[
ctx][prev_type];
171 for (b=0; b<4; b++) {
178 for (b=0; b<4; b++) {
184 s->parse_vector_adjustment(s, &s->mv[b]);
187 s->mv[
b] = s->vector_candidate[0];
190 s->mv[
b] = s->vector_candidate[1];
198 s->macroblocks[row * s->mb_width + col].mv = s->mv[3];
201 s->mv[4].x = s->mv[5].x =
RSHIFT(mv.
x,2);
202 s->mv[4].y = s->mv[5].y =
RSHIFT(mv.
y,2);
212 s->macroblocks[row * s->mb_width + col].type = s->mb_type;
214 switch (s->mb_type) {
216 mv = &s->vector_candidate[0];
220 mv = &s->vector_candidate[1];
225 mv = &s->vector_candidate[0];
230 mv = &s->vector_candidate[1];
234 s->parse_vector_adjustment(s, &vect);
240 s->parse_vector_adjustment(s, &vect);
253 s->macroblocks[row*s->mb_width + col].mv = *
mv;
268 s->macroblocks[row * s->mb_width + col].type = s->mb_type;
272 s->macroblocks[row*s->mb_width + col].mv = *
mv;
283 int idx = s->idct_scantable[0];
286 for (b=0; b<6; b++) {
287 VP56RefDc *ab = &s->above_blocks[s->above_block_idx[
b]];
303 if (count < 2 && ref_frame == ab[-1+2*i].ref_frame) {
312 s->block_coeff[
b][idx] +=
dc;
313 s->prev_dc[
ff_vp56_b2p[
b]][ref_frame] = s->block_coeff[
b][idx];
318 s->block_coeff[
b][idx] *= s->dequant_dc;
323 ptrdiff_t
stride,
int dx,
int dy)
327 if (dx) s->vp56dsp.edge_filter_hor(yuv + 10-dx , stride, t);
328 if (dy) s->vp56dsp.edge_filter_ver(yuv + stride*(10-dy), stride, t);
330 int * bounding_values = s->bounding_values_array + 127;
339 ptrdiff_t
stride,
int x,
int y)
344 int overlap_offset = 0;
345 int mask = s->vp56_coord_div[
b] - 1;
346 int deblock_filtering = s->deblock_filtering;
353 deblock_filtering = 0;
355 dx = s->mv[
b].x / s->vp56_coord_div[
b];
356 dy = s->mv[
b].y / s->vp56_coord_div[
b];
365 if (x<0 || x+12>=s->plane_width[plane] ||
366 y<0 || y+12>=s->plane_height[plane]) {
367 s->vdsp.emulated_edge_mc(s->edge_emu_buffer,
368 src + s->block_offset[b] + (dy-2)*stride + (dx-2),
371 s->plane_width[plane],
372 s->plane_height[plane]);
373 src_block = s->edge_emu_buffer;
374 src_offset = 2 + 2*
stride;
375 }
else if (deblock_filtering) {
378 s->hdsp.put_pixels_tab[0][0](s->edge_emu_buffer,
379 src + s->block_offset[
b] + (dy-2)*stride + (dx-2),
381 src_block = s->edge_emu_buffer;
382 src_offset = 2 + 2*
stride;
385 src_offset = s->block_offset[
b] + dy*stride + dx;
388 if (deblock_filtering)
391 if (s->mv[b].x & mask)
392 overlap_offset += (s->mv[
b].x > 0) ? 1 : -1;
393 if (s->mv[b].y & mask)
394 overlap_offset += (s->mv[
b].y > 0) ? stride : -stride;
396 if (overlap_offset) {
398 s->filter(s, dst, src_block, src_offset, src_offset+overlap_offset,
399 stride, s->mv[b], mask, s->filter_selection, b<4);
401 s->vp3dsp.put_no_rnd_pixels_l2(dst, src_block+src_offset,
402 src_block+src_offset+overlap_offset,
405 s->hdsp.put_pixels_tab[1][0](dst, src_block+src_offset,
stride, 8);
411 if (selector > 10 || selector == 1)
412 s->vp3dsp.idct_put(dest, stride, block);
420 s->vp3dsp.idct_add(dest, stride, block);
421 else if (selector > 1)
424 s->vp3dsp.idct_dc_add(dest, stride, block);
429 int b, ab, b_max, plane, off;
430 AVFrame *frame_current, *frame_ref;
436 frame_ref = s->frames[ref_frame];
441 b_max = 6 - 2*is_alpha;
445 for (b=0; b<b_max; b++) {
448 s->stride[plane], s->block_coeff[b], s->idct_selector[b]);
454 for (b=0; b<b_max; b++) {
456 off = s->block_offset[
b];
457 s->hdsp.put_pixels_tab[1][0](frame_current->
data[plane] + off,
458 frame_ref->
data[plane] + off,
459 s->stride[plane], 8);
461 s->stride[plane], s->block_coeff[b], s->idct_selector[b]);
472 for (b=0; b<b_max; b++) {
473 int x_off = b==1 || b==3 ? 8 : 0;
474 int y_off = b==2 || b==3 ? 8 : 0;
476 vp56_mc(s, b, plane, frame_ref->
data[plane], s->stride[plane],
477 16*col+x_off, 16*row+y_off);
479 s->stride[plane], s->block_coeff[b], s->idct_selector[b]);
485 s->block_coeff[4][0] = 0;
486 s->block_coeff[5][0] = 0;
500 ret = s->parse_coeff(s);
529 s->plane_width[0] = s->plane_width[3] = avctx->
coded_width;
530 s->plane_width[1] = s->plane_width[2] = avctx->
coded_width/2;
531 s->plane_height[0] = s->plane_height[3] = avctx->
coded_height;
532 s->plane_height[1] = s->plane_height[2] = avctx->
coded_height/2;
534 s->have_undamaged_frame = 0;
542 if (s->mb_width > 1000 || s->mb_height > 1000) {
549 sizeof(*s->above_blocks));
551 sizeof(*s->macroblocks));
552 av_free(s->edge_emu_buffer_alloc);
553 s->edge_emu_buffer_alloc =
av_malloc(16*stride);
554 s->edge_emu_buffer = s->edge_emu_buffer_alloc;
555 if (!s->above_blocks || !s->macroblocks || !s->edge_emu_buffer_alloc)
558 s->edge_emu_buffer += 15 *
stride;
560 if (s->alpha_context)
574 int remaining_buf_size = avpkt->
size;
575 int alpha_offset = remaining_buf_size;
580 if (remaining_buf_size < 3)
582 alpha_offset = bytestream_get_be24(&buf);
583 remaining_buf_size -= 3;
584 if (remaining_buf_size < alpha_offset)
588 res = s->parse_header(s, buf, alpha_offset);
593 for (i = 0; i < 4; i++) {
595 if (s->alpha_context)
625 int bak_w = avctx->
width;
626 int bak_h = avctx->
height;
630 remaining_buf_size -= alpha_offset;
632 res = s->alpha_context->parse_header(s->alpha_context, buf, remaining_buf_size);
636 avctx->
width = bak_w;
646 s->discard_frame = 0;
649 if (s->discard_frame)
660 int jobnr,
int threadnr)
663 int is_alpha = (jobnr == 1);
664 VP56Context *
s = is_alpha ? s0->alpha_context :
s0;
666 int mb_row, mb_col, mb_row_flip, mb_offset = 0;
668 ptrdiff_t stride_y, stride_uv;
674 s->default_models_init(s);
675 for (block=0; block<s->mb_height*s->mb_width; block++)
680 s->parse_vector_models(s);
684 if (s->parse_coeff_models(s))
687 memset(s->prev_dc, 0,
sizeof(s->prev_dc));
691 for (block=0; block < 4*s->mb_width+6; block++) {
693 s->above_blocks[
block].dc_coeff = 0;
694 s->above_blocks[
block].not_null_dc = 0;
706 for (mb_row=0; mb_row<s->mb_height; mb_row++) {
708 mb_row_flip = s->mb_height - mb_row - 1;
710 mb_row_flip = mb_row;
712 for (block=0; block<4; block++) {
714 s->left_block[
block].dc_coeff = 0;
715 s->left_block[
block].not_null_dc = 0;
717 memset(s->coeff_ctx, 0,
sizeof(s->coeff_ctx));
718 memset(s->coeff_ctx_last, 24,
sizeof(s->coeff_ctx_last));
720 s->above_block_idx[0] = 1;
721 s->above_block_idx[1] = 2;
722 s->above_block_idx[2] = 1;
723 s->above_block_idx[3] = 2;
724 s->above_block_idx[4] = 2*s->mb_width + 2 + 1;
725 s->above_block_idx[5] = 3*s->mb_width + 4 + 1;
727 s->block_offset[s->frbi] = (mb_row_flip*16 + mb_offset) * stride_y;
728 s->block_offset[s->srbi] = s->block_offset[s->frbi] + 8*stride_y;
729 s->block_offset[1] = s->block_offset[0] + 8;
730 s->block_offset[3] = s->block_offset[2] + 8;
731 s->block_offset[4] = (mb_row_flip*8 + mb_offset) * stride_uv;
732 s->block_offset[5] = s->block_offset[4];
734 for (mb_col=0; mb_col<s->mb_width; mb_col++) {
740 s->discard_frame = 1;
748 for (y=0; y<4; y++) {
749 s->above_block_idx[y] += 2;
750 s->block_offset[y] += 16;
753 for (uv=4; uv<6; uv++) {
754 s->above_block_idx[uv] += 1;
755 s->block_offset[uv] += 8;
761 s->have_undamaged_frame = 1;
783 int flip,
int has_alpha)
795 for (i = 0; i < 64; i++) {
796 #define TRANSPOSE(x) (((x) >> 3) | (((x) & 7) << 3)) 808 s->edge_emu_buffer_alloc =
NULL;
810 s->above_blocks =
NULL;
811 s->macroblocks =
NULL;
813 s->deblock_filtering = 1;
818 s->has_alpha = has_alpha;
820 s->modelp = &s->model;
847 av_freep(&s->edge_emu_buffer_alloc);
av_cold int ff_vp56_free(AVCodecContext *avctx)
av_cold void ff_videodsp_init(VideoDSPContext *ctx, int bpc)
discard all frames except keyframes
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
const uint8_t ff_vp56_ac_dequant[64]
This structure describes decoded (raw) audio or video data.
VP5 and VP6 compatible video decoder (common features)
static int vp56_get_vectors_predictors(VP56Context *s, int row, int col, VP56Frame ref_frame)
int coded_width
Bitstream width / height, may be different from width/height e.g.
int ff_set_dimensions(AVCodecContext *s, int width, int height)
Check that the provided frame dimensions are valid and set them on the codec context.
uint8_t mb_types_stats[3][10][2]
static void vp56_idct_put(VP56Context *s, uint8_t *dest, ptrdiff_t stride, int16_t *block, int selector)
const VP56Tree ff_vp56_pmbtm_tree[]
Inter MB, no vector, from previous frame.
static VP56mb vp56_parse_mb_type(VP56Context *s, VP56mb prev_type, int ctx)
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
av_cold void ff_h264chroma_init(H264ChromaContext *c, int bit_depth)
av_cold int ff_vp56_init(AVCodecContext *avctx, int flip, int has_alpha)
void ff_vp3dsp_idct10_add(uint8_t *dest, ptrdiff_t stride, int16_t *block)
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
static VP56mb vp56_decode_mv(VP56Context *s, int row, int col)
void ff_vp3dsp_idct10_put(uint8_t *dest, ptrdiff_t stride, int16_t *block)
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
av_cold int ff_vp56_init_context(AVCodecContext *avctx, VP56Context *s, int flip, int has_alpha)
static int vp56_conceal_mb(VP56Context *s, int row, int col, int is_alpha)
const uint8_t ff_vp56_dc_dequant[64]
const uint8_t ff_vp56_filter_threshold[]
const int8_t ff_vp56_candidate_predictor_pos[12][2]
static av_always_inline int vp56_rac_get_tree(VP56RangeCoder *c, const VP56Tree *tree, const uint8_t *probs)
Inter MB, second vector, from golden frame.
#define i(width, name, range_min, range_max)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
static const uint16_t mask[17]
static void flip(AVCodecContext *avctx, AVFrame *frame)
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
int skip_alpha
Skip processing alpha if supported by codec.
static av_always_inline int vp56_rac_get(VP56RangeCoder *c)
int error_concealment
error concealment flags
static void vp56_parse_mb_type_models(VP56Context *s)
int flags
AV_CODEC_FLAG_*.
void ff_vp56_init_dequant(VP56Context *s, int quantizer)
const uint8_t ff_vp56_b6to4[]
static const uint8_t offset[127][2]
static void vp56_deblock_filter(VP56Context *s, uint8_t *yuv, ptrdiff_t stride, int dx, int dy)
Inter MB, first vector, from previous frame.
static int vp56_size_changed(VP56Context *s)
int av_reallocp_array(void *ptr, size_t nmemb, size_t size)
Allocate, reallocate, or free an array through a pointer to a pointer.
av_cold void ff_hpeldsp_init(HpelDSPContext *c, int flags)
VP5 and VP6 compatible video decoder (common data)
const uint8_t ff_vp56_pre_def_mb_type_stats[16][3][10][2]
Inter MB, first vector, from golden frame.
enum AVPictureType pict_type
Picture type of the frame.
int width
picture width / height.
int ff_vp56_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
static int vp56_decode_mb(VP56Context *s, int row, int col, int is_alpha)
void ff_vp3dsp_h_loop_filter_12(uint8_t *first_pixel, ptrdiff_t stride, int *bounding_values)
const uint8_t ff_vp56_b2p[]
#define FF_ARRAY_ELEMS(a)
static const int8_t mv[256][2]
const VP56Tree ff_vp56_pmbt_tree[]
static av_always_inline int vp56_rac_get_prob_branchy(VP56RangeCoder *c, int prob)
Inter MB, 4 vectors, from previous frame.
int(* execute2)(struct AVCodecContext *c, int(*func)(struct AVCodecContext *c2, void *arg, int jobnr, int threadnr), void *arg2, int *ret, int count)
The codec may call this to execute several independent things.
Inter MB, no vector, from golden frame.
Libavcodec external API header.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Inter MB, second vector, from previous frame.
main external API structure.
uint8_t mb_type[3][10][10]
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
static int ff_vp56_decode_mbs(AVCodecContext *avctx, void *, int, int)
static VP56mb vp56_conceal_mv(VP56Context *s, int row, int col)
Inter MB, above/left vector + delta, from previous frame.
const uint8_t ff_zigzag_direct[64]
static void vp56_decode_4mv(VP56Context *s, int row, int col)
const uint8_t ff_vp56_mb_type_model_model[]
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(const int16_t *) pi >> 8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(const int32_t *) pi >> 24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) #define SET_CONV_FUNC_GROUP(ofmt, ifmt) static void set_generic_function(AudioConvert *ac) { } void ff_audio_convert_free(AudioConvert **ac) { if(! *ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);} AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map) { AudioConvert *ac;int in_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) return NULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method !=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt) > 2) { ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc) { av_free(ac);return NULL;} return ac;} in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar) { ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar ? ac->channels :1;} else if(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;else ac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);return ac;} int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in) { int use_generic=1;int len=in->nb_samples;int p;if(ac->dc) { av_log(ac->avr, AV_LOG_TRACE, "%d samples - audio_convert: %s to %s (dithered)\", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> dc
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
static av_always_inline void vp56_render_mb(VP56Context *s, int row, int col, int is_alpha, VP56mb mb_type)
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
av_cold int ff_vp56_free_context(VP56Context *s)
void ff_vp3dsp_v_loop_filter_12(uint8_t *first_pixel, ptrdiff_t stride, int *bounding_values)
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
common internal api header.
const VP56Frame ff_vp56_reference_frame[]
void ff_vp3dsp_set_bounding_values(int *bounding_values_array, int filter_limit)
static void vp56_add_predictors_dc(VP56Context *s, VP56Frame ref_frame)
Inter MB, above/left vector + delta, from golden frame.
int key_frame
1 -> keyframe, 0-> not
static void vp56_idct_add(VP56Context *s, uint8_t *dest, ptrdiff_t stride, int16_t *block, int selector)
#define FFSWAP(type, a, b)
av_cold void ff_vp3dsp_init(VP3DSPContext *c, int flags)
static void vp56_mc(VP56Context *s, int b, int plane, uint8_t *src, ptrdiff_t stride, int x, int y)
This structure stores compressed data.
#define AV_GET_BUFFER_FLAG_REF
The decoder will keep a reference to the frame and may reuse it later.
static int vp56_rac_gets(VP56RangeCoder *c, int bits)