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;
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];
553 for (y=0; y<8; y+=2) {
554 for (x=0; x<8; x+=2) {
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
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)
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_RB16
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]
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
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 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)
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[]
GLint GLenum GLboolean GLsizei stride
common internal api header.
static float square_sum(const float *x, const float *y, int size)
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]
static double val(void *priv, double ch)
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)