Go to the documentation of this file.
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) {
152 if (
s->sub_version > 7)
155 s->filter_selection = 16;
163 buf_size -= coeff_offset;
168 if (
s->use_huffman) {
194 s->modelp->coeff_index_to_pos[0] = 0;
197 if (
s->modelp->coeff_reorder[
pos] ==
i)
198 s->modelp->coeff_index_to_pos[idx++] =
pos;
200 for (idx = 0; idx < 64; idx++) {
202 for (
i = 0;
i <= idx;
i++) {
203 int v =
s->modelp->coeff_index_to_pos[
i];
207 if (
s->sub_version > 6)
209 s->modelp->coeff_index_to_idct_selector[idx] =
max;
245 for (node=0; node<7; node++)
250 for (node=0; node<8; node++)
258 const Node *
a = va, *
b = vb;
259 return (
a->count -
b->count)*16 + (
b->sym -
a->sym);
271 a =
tmp[
i].count * coeff_model[
i] >> 8;
272 b =
tmp[
i].count * (255 - coeff_model[
i]) >> 8;
293 memset(def_prob, 0x80,
sizeof(def_prob));
296 for (node=0; node<11; node++)
311 for (cg=0; cg<2; cg++)
312 for (node=0; node<14; node++)
316 for (ct=0; ct<3; ct++)
318 for (cg=0; cg<6; cg++)
319 for (node=0; node<11; node++)
327 if (
s->use_huffman) {
335 for (ct=0; ct<3; ct++)
336 for (cg = 0; cg < 6; cg++)
339 &
s->ract_vlc[
pt][ct][cg]))
342 memset(
s->nb_null, 0,
sizeof(
s->nb_null));
347 for (node=0; node<5; node++)
360 if (
s->vector_candidate_pos < 2)
361 *vect =
s->vector_candidate[0];
367 static const uint8_t prob_order[] = {0, 1, 2, 7, 6, 5, 4};
368 for (
i=0;
i<
sizeof(prob_order);
i++) {
369 int j = prob_order[
i];
410 uint8_t *
permute =
s->idct_scantable;
412 int coeff, sign, coeff_idx;
416 for (
b=0;
b<6;
b++) {
419 vlc_coeff = &
s->dccv_vlc[
pt];
421 for (coeff_idx = 0;;) {
423 if (coeff_idx<2 && s->nb_null[coeff_idx][
pt]) {
424 s->nb_null[coeff_idx][
pt]--;
433 int pt = (coeff_idx >= 6);
440 }
else if (
coeff == 11) {
448 ct = 1 + (coeff2 > 1);
450 coeff2 = (coeff2 ^ -sign) + sign;
452 coeff2 *=
s->dequant_ac;
454 s->block_coeff[
b][
permute[idx]] = coeff2;
461 vlc_coeff = &
s->ract_vlc[
pt][ct][cg];
472 uint8_t *
permute =
s->idct_scantable;
473 uint8_t *model1, *model2, *model3;
474 int coeff, sign, coeff_idx;
475 int b,
i, cg, idx,
ctx;
483 for (
b=0;
b<6;
b++) {
490 +
s->above_blocks[
s->above_block_idx[
b]].not_null_dc;
532 for (
run=9,
i=0;
i<6;
i++)
544 s->above_blocks[
s->above_block_idx[
b]].not_null_dc = !!
s->block_coeff[
b][0];
552 int sum = 0, square_sum = 0;
555 for (y=0; y<8; y+=2) {
556 for (x=0; x<8; x+=2) {
558 square_sum +=
src[x]*
src[x];
562 return (16*square_sum - sum*sum) >> 8;
570 for (y=0; y<8; y++) {
571 for (x=0; x<8; x++) {
583 ptrdiff_t
stride,
int h_weight,
int v_weight)
585 uint8_t *
tmp =
s->edge_emu_buffer+16;
586 s->h264chroma.put_h264_chroma_pixels_tab[0](
tmp,
src,
stride, 9, h_weight, 0);
587 s->h264chroma.put_h264_chroma_pixels_tab[0](dst,
tmp,
stride, 8, 0, v_weight);
591 int offset1,
int offset2, ptrdiff_t
stride,
601 filter4 =
s->filter_mode;
603 if (
s->max_vector_length &&
604 (
FFABS(
mv.x) >
s->max_vector_length ||
605 FFABS(
mv.y) >
s->max_vector_length)) {
607 }
else if (
s->sample_variance_threshold
609 <
s->sample_variance_threshold)) {
615 if ((y8 && (offset2-offset1)*
s->flip<0) || (!y8 && offset1 > offset2)) {
627 s->vp56dsp.vp6_filter_diag4(dst,
src+offset1+((
mv.x^
mv.y)>>31),
stride,
633 s->h264chroma.put_h264_chroma_pixels_tab[0](dst,
src + offset1,
stride, 8, x8, y8);
655 s->alpha_context =
av_mallocz(
sizeof(VP56Context));
657 s->flip == -1,
s->has_alpha);
667 s->deblock_filtering = 0;
686 if (
s->alpha_context) {
702 for (ct=0; ct<3; ct++)
703 for (cg=0; cg<6; cg++)
713 .priv_data_size =
sizeof(VP56Context),
726 .priv_data_size =
sizeof(VP56Context),
739 .priv_data_size =
sizeof(VP56Context),
static av_always_inline int vp56_rac_get(VP56RangeCoder *c)
av_cold int ff_vp56_init(AVCodecContext *avctx, int flip, int has_alpha)
static const uint8_t vp6_def_fdv_vector_model[2][8]
static const int16_t vp6_block_copy_filter[17][8][4]
static int get_bits_left(GetBitContext *gb)
static av_cold int vp6_decode_free(AVCodecContext *avctx)
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 void comp(unsigned char *dst, ptrdiff_t dst_stride, unsigned char *src, ptrdiff_t src_stride, int add)
uint8_t mb_types_stats[3][10][2]
static void vp6_coeff_order_table_init(VP56Context *s)
const uint8_t ff_vp56_coeff_bit_length[]
static const int8_t mv[256][2]
const AVCodec ff_vp6f_decoder
av_cold int ff_vp56_init_context(AVCodecContext *avctx, VP56Context *s, int flip, int has_alpha)
static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)
Parse a vlc code.
static void vp6_filter_diag2(VP56Context *s, uint8_t *dst, uint8_t *src, ptrdiff_t stride, int h_weight, int v_weight)
uint8_t coeff_index_to_pos[64]
uint8_t coeff_ract[2][3][6][11]
static av_unused int vp56_rac_gets_nn(VP56RangeCoder *c, int bits)
static const uint8_t vp6_def_coeff_reorder[]
static av_always_inline int vp56_rac_get_prob_branchy(VP56RangeCoder *c, int prob)
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
const struct AVCodec * codec
static double val(void *priv, double ch)
const uint8_t ff_vp56_b6to4[]
static int vp6_huff_cmp(const void *va, const void *vb)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
static const uint16_t mask[17]
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
static const uint8_t vp6_huff_coeff_map[]
static const uint8_t vp6_huff_run_map[]
static void permute(uint8_t *dst, const uint8_t *src, const uint8_t permutation[64])
static const uint8_t vp6_dccv_pct[2][11]
static const uint8_t vp6_def_runv_coeff_model[2][14]
static int vp56_rac_gets(VP56RangeCoder *c, int bits)
av_cold int ff_vp56_free_context(VP56Context *s)
void ff_free_vlc(VLC *vlc)
uint8_t coeff_dccv[2][11]
uint8_t coeff_dcct[2][36][5]
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
static const VP56Tree vp6_pcr_tree[]
static av_cold void vp6_decode_init_context(VP56Context *s)
static unsigned vp6_get_nb_null(VP56Context *s)
Read number of consecutive blocks with null DC or AC.
uint8_t coeff_runv[2][14]
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
const uint8_t ff_vp56_def_mb_types_stats[3][10][2]
static int vp6_parse_header(VP56Context *s, const uint8_t *buf, int buf_size)
static unsigned int get_bits1(GetBitContext *s)
void ff_vp6dsp_init(VP56DSPContext *s)
static void vp6_parse_vector_adjustment(VP56Context *s, VP56mv *vect)
const AVCodec ff_vp6a_decoder
static const uint8_t vp6_sig_dct_pct[2][2]
static const uint8_t vp6_fdv_pct[2][8]
static const uint8_t vp6_coord_div[]
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 void vp6_filter_hv4(uint8_t *dst, uint8_t *src, ptrdiff_t stride, int delta, const int16_t *weights)
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
static void vp6_default_models_init(VP56Context *s)
const uint8_t ff_vp56_coeff_parse_table[6][11]
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
static int vp6_parse_coeff_models(VP56Context *s)
static av_always_inline int vp56_rac_get_tree(VP56RangeCoder *c, const VP56Tree *tree, const uint8_t *probs)
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
#define VP6_MAX_HUFF_SIZE
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
const VP56Tree ff_vp56_pva_tree[]
int ff_vp56_init_range_decoder(VP56RangeCoder *c, const uint8_t *buf, int buf_size)
uint8_t coeff_index_to_idct_selector[64]
#define i(width, name, range_min, range_max)
static av_cold int vp6_decode_init(AVCodecContext *avctx)
static const int weights[]
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
const VP56Tree ff_vp56_pc_tree[]
const char * name
Name of the codec implementation.
int ff_huff_build_tree(void *logctx, 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 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_coeff_bias[]
main external API structure.
static int vp6_block_variance(uint8_t *src, ptrdiff_t stride)
static const uint8_t vp6_coeff_reorder_pct[]
static void vp6_parse_vector_models(VP56Context *s)
void ff_vp56_init_dequant(VP56Context *s, int quantizer)
static const int vp6_dccv_lc[3][5][2]
const AVCodec ff_vp6_decoder
static const uint8_t vp6_pdv_pct[2][7]
int ff_vp56_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
av_cold int ff_vp56_free(AVCodecContext *avctx)
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.
#define vp56_rac_get_prob
static int vp6_build_huff_tree(VP56Context *s, uint8_t coeff_model[], const uint8_t *map, unsigned size, VLC *vlc)
const VDPAUPixFmtMap * map
static const uint8_t vp6_coeff_groups[]
static const uint8_t vp6_def_pdv_vector_model[2][7]
static const double coeff[2][5]
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
static int vp6_parse_coeff_huffman(VP56Context *s)
static av_cold void vp6_decode_free_context(VP56Context *s)
static int vp6_parse_coeff(VP56Context *s)
VLC_TYPE(* table)[2]
code, bits
#define FF_HUFFMAN_FLAG_HNODE_FIRST
static const uint8_t vp6_runv_pct[2][14]
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_ract_pct[3][2][6][11]
uint8_t coeff_reorder[64]