41 #define VP6_MAX_HUFF_SIZE 12 49 int parse_filter_info = 0;
56 int separated_coeff = buf[0] & 1;
62 sub_version = buf[1] >> 3;
65 s->filter_header = buf[1] & 0x06;
70 if (separated_coeff || !s->filter_header) {
71 coeff_offset =
AV_RB16(buf+2) - 2;
85 if (!s->macroblocks ||
86 16*cols != s->avctx->coded_width ||
87 16*rows != s->avctx->coded_height) {
88 if (s->avctx->extradata_size == 0 &&
89 FFALIGN(s->avctx->width, 16) == 16 * cols &&
90 FFALIGN(s->avctx->height, 16) == 16 * rows) {
94 s->avctx->coded_width = 16 * cols;
95 s->avctx->coded_height = 16 * rows;
101 if (s->avctx->extradata_size == 1) {
102 s->avctx->width -= s->avctx->extradata[0] >> 4;
103 s->avctx->height -= s->avctx->extradata[0] & 0x0F;
114 parse_filter_info = s->filter_header;
117 s->sub_version = sub_version;
120 if (!s->sub_version || !s->avctx->coded_width || !s->avctx->coded_height)
123 if (separated_coeff || !s->filter_header) {
124 coeff_offset =
AV_RB16(buf+1) - 2;
133 if (s->filter_header) {
135 if (s->deblock_filtering)
137 if (s->sub_version > 7)
142 if (parse_filter_info) {
145 s->sample_variance_threshold =
vp56_rac_gets(c, 5) << vrt_shift;
152 if (s->sub_version > 7)
155 s->filter_selection = 16;
163 buf_size -= coeff_offset;
168 if (s->use_huffman) {
192 s->modelp->coeff_index_to_pos[0] = 0;
194 for (pos=1; pos<64; pos++)
195 if (s->modelp->coeff_reorder[pos] == i)
196 s->modelp->coeff_index_to_pos[idx++] = pos;
198 for (idx = 0; idx < 64; idx++) {
200 for (i = 0; i <= idx; i++) {
201 int v = s->modelp->coeff_index_to_pos[
i];
205 if (s->sub_version > 6)
207 s->modelp->coeff_index_to_idct_selector[idx] =
max;
235 for (comp=0; comp<2; comp++) {
242 for (comp=0; comp<2; comp++)
243 for (node=0; node<7; node++)
247 for (comp=0; comp<2; comp++)
248 for (node=0; node<8; node++)
256 const Node *
a = va, *
b = vb;
257 return (a->
count - b->count)*16 + (b->sym - a->
sym);
268 for (i=0; i<size-1; i++) {
269 a = tmp[
i].
count * coeff_model[
i] >> 8;
270 b = tmp[
i].
count * (255 - coeff_model[
i]) >> 8;
271 nodes[map[2*
i ]].
count = a + !
a;
272 nodes[map[2*i+1]].
count = b + !
b;
287 int node, cg,
ctx, pos;
291 memset(def_prob, 0x80,
sizeof(def_prob));
293 for (pt=0; pt<2; pt++)
294 for (node=0; node<11; node++)
303 for (pos=1; pos<64; pos++)
309 for (cg=0; cg<2; cg++)
310 for (node=0; node<14; node++)
314 for (ct=0; ct<3; ct++)
315 for (pt=0; pt<2; pt++)
316 for (cg=0; cg<6; cg++)
317 for (node=0; node<11; node++)
325 if (s->use_huffman) {
326 for (pt=0; pt<2; pt++) {
333 for (ct=0; ct<3; ct++)
334 for (cg = 0; cg < 6; cg++)
337 &s->ract_vlc[pt][ct][cg]))
340 memset(s->nb_null, 0,
sizeof(s->nb_null));
343 for (pt=0; pt<2; pt++)
344 for (ctx=0; ctx<3; ctx++)
345 for (node=0; node<5; node++)
358 if (s->vector_candidate_pos < 2)
359 *vect = s->vector_candidate[0];
361 for (comp=0; comp<2; comp++) {
365 static const uint8_t prob_order[] = {0, 1, 2, 7, 6, 5, 4};
366 for (i=0; i<
sizeof(prob_order); i++) {
367 int j = prob_order[
i];
400 val = 6+val +
get_bits(&s->gb, 2+val);
410 int coeff, sign, coeff_idx;
414 for (b=0; b<6; b++) {
417 vlc_coeff = &s->dccv_vlc[
pt];
419 for (coeff_idx = 0;;) {
421 if (coeff_idx<2 && s->nb_null[coeff_idx][pt]) {
422 s->nb_null[coeff_idx][
pt]--;
431 int pt = (coeff_idx >= 6);
438 }
else if (coeff == 11) {
445 coeff2 +=
get_bits(&s->gb, coeff <= 9 ? coeff - 4 : 11);
446 ct = 1 + (coeff2 > 1);
448 coeff2 = (coeff2 ^ -sign) + sign;
450 coeff2 *= s->dequant_ac;
452 s->block_coeff[
b][permute[idx]] = coeff2;
459 vlc_coeff = &s->ract_vlc[
pt][ct][cg];
471 uint8_t *model1, *model2, *model3;
472 int coeff, sign, coeff_idx;
473 int b,
i, cg, idx,
ctx;
481 for (b=0; b<6; b++) {
488 + s->above_blocks[s->above_block_idx[
b]].not_null_dc;
514 coeff = (coeff ^ -sign) + sign;
516 coeff *= s->dequant_ac;
518 s->block_coeff[
b][permute[idx]] =
coeff;
530 for (run=9, i=0; i<6; i++)
542 s->above_blocks[s->above_block_idx[
b]].not_null_dc = !!s->block_coeff[
b][0];
550 int sum = 0, square_sum = 0;
553 for (y=0; y<8; y+=2) {
554 for (x=0; x<8; x+=2) {
556 square_sum += src[x]*src[x];
560 return (16*square_sum - sum*sum) >> 8;
564 int delta,
const int16_t *weights)
568 for (y=0; y<8; y++) {
569 for (x=0; x<8; x++) {
570 dst[x] = av_clip_uint8(( src[x-delta ] * weights[0]
571 + src[x ] * weights[1]
572 + src[x+delta ] * weights[2]
573 + src[x+2*delta] * weights[3] + 64) >> 7);
581 ptrdiff_t
stride,
int h_weight,
int v_weight)
584 s->h264chroma.put_h264_chroma_pixels_tab[0](
tmp,
src,
stride, 9, h_weight, 0);
585 s->h264chroma.put_h264_chroma_pixels_tab[0](dst,
tmp,
stride, 8, 0, v_weight);
589 int offset1,
int offset2, ptrdiff_t
stride,
593 int x8 = mv.
x &
mask;
594 int y8 = mv.
y &
mask;
599 filter4 = s->filter_mode;
601 if (s->max_vector_length &&
602 (
FFABS(mv.
x) > s->max_vector_length ||
603 FFABS(mv.
y) > s->max_vector_length)) {
605 }
else if (s->sample_variance_threshold
607 < s->sample_variance_threshold)) {
613 if ((y8 && (offset2-offset1)*s->flip<0) || (!y8 && offset1 > offset2)) {
625 s->vp56dsp.vp6_filter_diag4(dst, src+offset1+((mv.
x^mv.
y)>>31), stride,
631 s->h264chroma.put_h264_chroma_pixels_tab[0](dst, src + offset1,
stride, 8, x8, y8);
653 s->alpha_context =
av_mallocz(
sizeof(VP56Context));
655 s->flip == -1, s->has_alpha);
665 s->deblock_filtering = 0;
684 if (s->alpha_context) {
697 for (pt=0; pt<2; pt++) {
700 for (ct=0; ct<3; ct++)
701 for (cg=0; cg<6; cg++)
711 .priv_data_size =
sizeof(VP56Context),
724 .priv_data_size =
sizeof(VP56Context),
737 .priv_data_size =
sizeof(VP56Context),
av_cold int ff_vp56_free(AVCodecContext *avctx)
const struct AVCodec * codec
const char const char void * val
static void vp6_coeff_order_table_init(VP56Context *s)
uint8_t coeff_ract[2][3][6][11]
static const uint8_t vp6_ract_pct[3][2][6][11]
static av_cold int vp6_decode_init(AVCodecContext *avctx)
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
#define FF_HUFFMAN_FLAG_HNODE_FIRST
static const uint8_t vp6_runv_pct[2][14]
static int vp6_build_huff_tree(VP56Context *s, uint8_t coeff_model[], const uint8_t *map, unsigned size, VLC *vlc)
uint8_t coeff_index_to_pos[64]
VP5 and VP6 compatible video decoder (common features)
static const int16_t vp6_block_copy_filter[17][8][4]
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
static const uint8_t vp6_def_fdv_vector_model[2][8]
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.
const uint8_t ff_vp56_coeff_bias[]
uint8_t coeff_dccv[2][11]
int ff_huff_build_tree(AVCodecContext *avctx, VLC *vlc, int nb_codes, int nb_bits, Node *nodes, HuffCmp cmp, int flags)
nodes size must be 2*nb_codes first nb_codes nodes.count must be set
static av_cold int init(AVCodecContext *avctx)
uint8_t mb_types_stats[3][10][2]
static int vp6_parse_coeff(VP56Context *s)
static void vp6_filter_diag2(VP56Context *s, uint8_t *dst, uint8_t *src, ptrdiff_t stride, int h_weight, int v_weight)
static const uint8_t vp6_huff_coeff_map[]
av_cold int ff_vp56_init(AVCodecContext *avctx, int flip, int has_alpha)
static av_cold void vp6_decode_free_context(VP56Context *s)
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
static const uint8_t vp6_def_runv_coeff_model[2][14]
static const uint8_t vp6_def_coeff_reorder[]
static int vp6_parse_coeff_models(VP56Context *s)
av_cold int ff_vp56_init_context(AVCodecContext *avctx, VP56Context *s, int flip, int has_alpha)
#define VP6_MAX_HUFF_SIZE
bitstream reader API header.
static av_always_inline int vpX_rac_is_end(VP56RangeCoder *c)
vp5689 returns 1 if the end of the stream has been reached, 0 otherwise.
static const uint8_t vp6_dccv_pct[2][11]
static av_always_inline int vp56_rac_get_tree(VP56RangeCoder *c, const VP56Tree *tree, const uint8_t *probs)
uint8_t coeff_reorder[64]
static int get_bits_left(GetBitContext *gb)
#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]
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
static av_always_inline int vp56_rac_get(VP56RangeCoder *c)
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
const char * name
Name of the codec implementation.
void ff_vp56_init_dequant(VP56Context *s, int quantizer)
static void vp6_filter(VP56Context *s, uint8_t *dst, uint8_t *src, int offset1, int offset2, ptrdiff_t stride, VP56mv mv, int mask, int select, int luma)
const uint8_t ff_vp56_b6to4[]
static int vp6_huff_cmp(const void *va, const void *vb)
static void vp6_parse_vector_models(VP56Context *s)
int ff_vp56_init_range_decoder(VP56RangeCoder *c, const uint8_t *buf, int buf_size)
VP5 and VP6 compatible video decoder (common data)
static av_unused int vp56_rac_gets_nn(VP56RangeCoder *c, int bits)
static av_cold void vp6_decode_init_context(VP56Context *s)
static void vp6_filter_hv4(uint8_t *dst, uint8_t *src, ptrdiff_t stride, int delta, const int16_t *weights)
VP6 compatible video decoder.
static void vp6_default_models_init(VP56Context *s)
static const uint8_t vp6_huff_run_map[]
int ff_vp56_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
const uint8_t ff_vp56_coeff_bit_length[]
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)
Parse a vlc code.
static int vp6_block_variance(uint8_t *src, ptrdiff_t stride)
#define vp56_rac_get_prob
static const VP56Tree vp6_pcr_tree[]
uint8_t coeff_runv[2][14]
static void comp(unsigned char *dst, ptrdiff_t dst_stride, unsigned char *src, ptrdiff_t src_stride, int add)
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
static const int8_t mv[256][2]
static av_always_inline int vp56_rac_get_prob_branchy(VP56RangeCoder *c, int prob)
void ff_vp6dsp_init(VP56DSPContext *s)
Libavcodec external API header.
static const uint8_t vp6_coeff_reorder_pct[]
const VP56Tree ff_vp56_pc_tree[]
main external API structure.
static const uint8_t vp6_fdv_pct[2][8]
static const uint8_t vp6_coord_div[]
static void permute(uint8_t *dst, const uint8_t *src, const uint8_t permutation[64])
static unsigned vp6_get_nb_null(VP56Context *s)
Read number of consecutive blocks with null DC or AC.
static const uint8_t vp6_sig_dct_pct[2][2]
const uint8_t ff_vp56_coeff_parse_table[6][11]
uint8_t coeff_dcct[2][36][5]
static unsigned int get_bits1(GetBitContext *s)
static int vp6_parse_header(VP56Context *s, const uint8_t *buf, int buf_size)
static av_cold int vp6_decode_free(AVCodecContext *avctx)
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
huffman tree builder and VLC generator
const VDPAUPixFmtMap * map
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
av_cold int ff_vp56_free_context(VP56Context *s)
static const int vp6_dccv_lc[3][5][2]
const VP56Tree ff_vp56_pva_tree[]
common internal api header.
static void vp6_parse_vector_adjustment(VP56Context *s, VP56mv *vect)
static const uint8_t vp6_coeff_groups[]
static const uint8_t vp6_def_pdv_vector_model[2][7]
static int vp6_parse_coeff_huffman(VP56Context *s)
VLC_TYPE(* table)[2]
code, bits
uint8_t coeff_index_to_idct_selector[64]
static const double coeff[2][5]
const uint8_t ff_vp56_def_mb_types_stats[3][10][2]
void ff_free_vlc(VLC *vlc)
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
static const uint8_t vp6_pdv_pct[2][7]
static int vp56_rac_gets(VP56RangeCoder *c, int bits)