Go to the documentation of this file.
43 #define VP6_MAX_HUFF_SIZE 12
51 int parse_filter_info = 0;
58 int separated_coeff = buf[0] & 1;
67 sub_version = buf[1] >> 3;
70 s->filter_header = buf[1] & 0x06;
71 s->interlaced = buf[1] & 1;
76 if (separated_coeff || !
s->filter_header) {
77 coeff_offset =
AV_RB16(buf+2) - 2;
91 if (!
s->macroblocks ||
92 16*cols !=
s->avctx->coded_width ||
93 16*rows !=
s->avctx->coded_height) {
94 if (
s->avctx->extradata_size == 0 &&
95 FFALIGN(
s->avctx->width, 16) == 16 * cols &&
96 FFALIGN(
s->avctx->height, 16) == 16 * rows) {
100 s->avctx->coded_width = 16 * cols;
101 s->avctx->coded_height = 16 * rows;
107 if (
s->avctx->extradata_size == 1) {
108 s->avctx->width -=
s->avctx->extradata[0] >> 4;
109 s->avctx->height -=
s->avctx->extradata[0] & 0x0F;
120 parse_filter_info =
s->filter_header;
123 s->sub_version = sub_version;
126 if (!
s->sub_version || !
s->avctx->coded_width || !
s->avctx->coded_height)
129 if (separated_coeff || !
s->filter_header) {
130 coeff_offset =
AV_RB16(buf+1) - 2;
139 if (
s->filter_header) {
141 if (
s->deblock_filtering)
143 if (
s->sub_version > 7)
148 if (parse_filter_info) {
158 if (
s->sub_version > 7)
161 s->filter_selection = 16;
169 buf_size -= coeff_offset;
174 if (
s->use_huffman) {
200 s->modelp->coeff_index_to_pos[0] = 0;
203 if (
s->modelp->coeff_reorder[
pos] ==
i)
204 s->modelp->coeff_index_to_pos[idx++] =
pos;
206 for (idx = 0; idx < 64; idx++) {
208 for (
i = 0;
i <= idx;
i++) {
209 int v =
s->modelp->coeff_index_to_pos[
i];
213 if (
s->sub_version > 6)
215 s->modelp->coeff_index_to_idct_selector[idx] =
max;
251 for (node=0; node<7; node++)
256 for (node=0; node<8; node++)
264 const Node *
a = va, *
b = vb;
265 return (
a->count -
b->count)*16 + (
b->sym -
a->sym);
277 a =
tmp[
i].count * coeff_model[
i] >> 8;
278 b =
tmp[
i].count * (255 - coeff_model[
i]) >> 8;
299 memset(def_prob, 0x80,
sizeof(def_prob));
302 for (node=0; node<11; node++)
317 for (cg=0; cg<2; cg++)
318 for (node=0; node<14; node++)
322 for (ct=0; ct<3; ct++)
324 for (cg=0; cg<6; cg++)
325 for (node=0; node<11; node++)
333 if (
s->use_huffman) {
341 for (ct=0; ct<3; ct++)
342 for (cg = 0; cg < 6; cg++)
345 &
s->ract_vlc[
pt][ct][cg]))
348 memset(
s->nb_null, 0,
sizeof(
s->nb_null));
353 for (node=0; node<5; node++)
366 if (
s->vector_candidate_pos < 2)
367 *vect =
s->vector_candidate[0];
373 static const uint8_t prob_order[] = {0, 1, 2, 7, 6, 5, 4};
374 for (
i=0;
i<
sizeof(prob_order);
i++) {
375 int j = prob_order[
i];
416 uint8_t *
permute =
s->idct_scantable;
418 int coeff, sign, coeff_idx;
422 for (
b=0;
b<6;
b++) {
425 vlc_coeff = &
s->dccv_vlc[
pt];
427 for (coeff_idx = 0;;) {
429 if (coeff_idx<2 && s->nb_null[coeff_idx][
pt]) {
430 s->nb_null[coeff_idx][
pt]--;
439 int pt = (coeff_idx >= 6);
446 }
else if (
coeff == 11) {
454 ct = 1 + (coeff2 > 1);
456 coeff2 = (coeff2 ^ -sign) + sign;
458 coeff2 *=
s->dequant_ac;
460 s->block_coeff[
b][
permute[idx]] = coeff2;
467 vlc_coeff = &
s->ract_vlc[
pt][ct][cg];
478 uint8_t *
permute =
s->idct_scantable;
479 uint8_t *model1, *model2, *model3;
480 int coeff, sign, coeff_idx;
481 int b,
i, cg, idx,
ctx;
489 for (
b=0;
b<6;
b++) {
496 +
s->above_blocks[
s->above_block_idx[
b]].not_null_dc;
538 for (
run=9,
i=0;
i<6;
i++)
550 s->above_blocks[
s->above_block_idx[
b]].not_null_dc = !!
s->block_coeff[
b][0];
558 int sum = 0, square_sum = 0;
561 for (y=0; y<8; y+=2) {
562 for (x=0; x<8; x+=2) {
564 square_sum +=
src[x]*
src[x];
568 return (16*square_sum - sum*sum) >> 8;
576 for (y=0; y<8; y++) {
577 for (x=0; x<8; x++) {
589 ptrdiff_t
stride,
int h_weight,
int v_weight)
591 uint8_t *
tmp =
s->edge_emu_buffer+16;
592 s->h264chroma.put_h264_chroma_pixels_tab[0](
tmp,
src,
stride, 9, h_weight, 0);
593 s->h264chroma.put_h264_chroma_pixels_tab[0](
dst,
tmp,
stride, 8, 0, v_weight);
597 int offset1,
int offset2, ptrdiff_t
stride,
607 filter4 =
s->filter_mode;
609 if (
s->max_vector_length &&
610 (
FFABS(
mv.x) >
s->max_vector_length ||
611 FFABS(
mv.y) >
s->max_vector_length)) {
613 }
else if (
s->sample_variance_threshold
615 <
s->sample_variance_threshold)) {
621 if ((y8 && (offset2-offset1)*
s->flip<0) || (!y8 && offset1 > offset2)) {
639 s->h264chroma.put_h264_chroma_pixels_tab[0](
dst,
src + offset1,
stride, 8, x8, y8);
647 VP56Context *
s,
int flip,
int has_alpha)
655 s->deblock_filtering = 0;
679 s->alpha_context = &
s[1];
681 s->flip == -1,
s->has_alpha);
697 if (
s->alpha_context) {
699 s->alpha_context =
NULL;
714 for (ct=0; ct<3; ct++)
715 for (cg=0; cg<6; cg++)
725 .priv_data_size =
sizeof(VP56Context),
739 .priv_data_size =
sizeof(VP56Context),
753 .priv_data_size = 2 *
sizeof(VP56Context),
static av_always_inline int vp56_rac_get_tree(VPXRangeCoder *c, const VP56Tree *tree, const uint8_t *probs)
static const uint8_t vp6_def_fdv_vector_model[2][8]
static const int16_t vp6_block_copy_filter[17][8][4]
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
static int get_bits_left(GetBitContext *gb)
static av_cold int vp6_decode_free(AVCodecContext *avctx)
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]
av_cold int ff_vp56_init_context(AVCodecContext *avctx, VP56Context *s, int flip, int has_alpha)
Initializes an VP56Context.
static void permute(int16_t dst[64], const int16_t src[64], enum idct_permutation_type perm_type)
const FFCodec ff_vp6f_decoder
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]
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 coeff_ract[2][3][6][11]
const FFCodec ff_vp6_decoder
static const uint8_t vp6_def_coeff_reorder[]
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
AVCodec p
The public AVCodec.
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 av_unused int vp56_rac_gets_nn(VPXRangeCoder *c, int bits)
#define AV_FRAME_FLAG_KEY
A flag to mark frames that are keyframes.
static const uint8_t vp6_huff_coeff_map[]
#define FF_CODEC_DECODE_CB(func)
static const uint8_t vp6_huff_run_map[]
static const uint8_t vp6_dccv_pct[2][11]
static const uint8_t vp6_def_runv_coeff_model[2][14]
const FFCodec ff_vp6a_decoder
av_cold int ff_vp56_free_context(VP56Context *s)
uint8_t coeff_dccv[2][11]
uint8_t coeff_dcct[2][36][5]
#define CODEC_LONG_NAME(str)
#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 unsigned vp6_get_nb_null(VP56Context *s)
Read number of consecutive blocks with null DC or AC.
uint8_t coeff_runv[2][14]
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 av_cold int vp6_decode_init_context(AVCodecContext *avctx, VP56Context *s, int flip, int has_alpha)
static unsigned int get_bits1(GetBitContext *s)
void ff_vp6dsp_init(VP56DSPContext *s)
static void vp6_parse_vector_adjustment(VP56Context *s, VP56mv *vect)
static const uint8_t vp6_sig_dct_pct[2][2]
static const uint8_t vp6_fdv_pct[2][8]
static av_always_inline int get_vlc2(GetBitContext *s, const VLCElem *table, int bits, int max_depth)
Parse a vlc code.
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)
int(* init)(AVBSFContext *ctx)
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
static void flip(AVCodecContext *avctx, AVFrame *frame)
static void vp6_default_models_init(VP56Context *s)
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
const uint8_t ff_vp56_coeff_parse_table[6][11]
static int vp6_parse_coeff_models(VP56Context *s)
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.
static int vp56_rac_gets(VPXRangeCoder *c, int bits)
vp56 specific range coder implementation
const VP56Tree ff_vp56_pva_tree[]
uint8_t coeff_index_to_idct_selector[64]
static av_always_inline int vpx_rac_is_end(VPXRangeCoder *c)
returns 1 if the end of the stream has been reached, 0 otherwise.
#define i(width, name, range_min, range_max)
static av_cold int vp6_decode_init(AVCodecContext *avctx)
static const uint8_t vp6_il_coeff_reorder[]
static const int weights[]
static av_always_inline int vpx_rac_get_prob_branchy(VPXRangeCoder *c, int prob)
const VP56Tree ff_vp56_pc_tree[]
const char * name
Name of the codec implementation.
void ff_vlc_free(VLC *vlc)
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[]
int ff_vpx_init_range_decoder(VPXRangeCoder *c, const uint8_t *buf, int buf_size)
int ff_vp56_decode_frame(AVCodecContext *avctx, AVFrame *rframe, int *got_frame, AVPacket *avpkt)
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]
static const uint8_t vp6_pdv_pct[2][7]
static av_always_inline int vpx_rac_get(VPXRangeCoder *c)
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)
#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]