37 #define BLOCK_TYPE_VLC_BITS 5
38 #define ACDC_VLC_BITS 9
40 #define CFRAME_BUFFER_COUNT 100
45 { 0, 1 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 30, 5 }, { 31, 5 }, { 0, 0 }
47 { 0, 1 }, { 0, 0 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 15, 4 }, { 0, 0 }
49 { 0, 1 }, { 2, 2 }, { 0, 0 }, { 6, 3 }, { 14, 4 }, { 15, 4 }, { 0, 0 }
51 { 0, 1 }, { 0, 0 }, { 0, 0 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 15, 4 }
55 { 1, 2 }, { 4, 3 }, { 5, 3 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
57 { 1, 2 }, { 0, 0 }, { 2, 2 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
59 { 1, 2 }, { 2, 2 }, { 0, 0 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
61 { 1, 2 }, { 0, 0 }, { 0, 0 }, { 0, 2 }, { 2, 2 }, { 6, 3 }, { 7, 3 }
73 static const int8_t
mv[256][2] = {
74 { 0, 0 }, { 0, -1 }, { -1, 0 }, { 1, 0 }, { 0, 1 }, { -1, -1 }, { 1, -1 }, { -1, 1 },
75 { 1, 1 }, { 0, -2 }, { -2, 0 }, { 2, 0 }, { 0, 2 }, { -1, -2 }, { 1, -2 }, { -2, -1 },
76 { 2, -1 }, { -2, 1 }, { 2, 1 }, { -1, 2 }, { 1, 2 }, { -2, -2 }, { 2, -2 }, { -2, 2 },
77 { 2, 2 }, { 0, -3 }, { -3, 0 }, { 3, 0 }, { 0, 3 }, { -1, -3 }, { 1, -3 }, { -3, -1 },
78 { 3, -1 }, { -3, 1 }, { 3, 1 }, { -1, 3 }, { 1, 3 }, { -2, -3 }, { 2, -3 }, { -3, -2 },
79 { 3, -2 }, { -3, 2 }, { 3, 2 }, { -2, 3 }, { 2, 3 }, { 0, -4 }, { -4, 0 }, { 4, 0 },
80 { 0, 4 }, { -1, -4 }, { 1, -4 }, { -4, -1 }, { 4, -1 }, { 4, 1 }, { -1, 4 }, { 1, 4 },
81 { -3, -3 }, { -3, 3 }, { 3, 3 }, { -2, -4 }, { -4, -2 }, { 4, -2 }, { -4, 2 }, { -2, 4 },
82 { 2, 4 }, { -3, -4 }, { 3, -4 }, { 4, -3 }, { -5, 0 }, { -4, 3 }, { -3, 4 }, { 3, 4 },
83 { -1, -5 }, { -5, -1 }, { -5, 1 }, { -1, 5 }, { -2, -5 }, { 2, -5 }, { 5, -2 }, { 5, 2 },
84 { -4, -4 }, { -4, 4 }, { -3, -5 }, { -5, -3 }, { -5, 3 }, { 3, 5 }, { -6, 0 }, { 0, 6 },
85 { -6, -1 }, { -6, 1 }, { 1, 6 }, { 2, -6 }, { -6, 2 }, { 2, 6 }, { -5, -4 }, { 5, 4 },
86 { 4, 5 }, { -6, -3 }, { 6, 3 }, { -7, 0 }, { -1, -7 }, { 5, -5 }, { -7, 1 }, { -1, 7 },
87 { 4, -6 }, { 6, 4 }, { -2, -7 }, { -7, 2 }, { -3, -7 }, { 7, -3 }, { 3, 7 }, { 6, -5 },
88 { 0, -8 }, { -1, -8 }, { -7, -4 }, { -8, 1 }, { 4, 7 }, { 2, -8 }, { -2, 8 }, { 6, 6 },
89 { -8, 3 }, { 5, -7 }, { -5, 7 }, { 8, -4 }, { 0, -9 }, { -9, -1 }, { 1, 9 }, { 7, -6 },
90 { -7, 6 }, { -5, -8 }, { -5, 8 }, { -9, 3 }, { 9, -4 }, { 7, -7 }, { 8, -6 }, { 6, 8 },
91 { 10, 1 }, { -10, 2 }, { 9, -5 }, { 10, -3 }, { -8, -7 }, { -10, -4 }, { 6, -9 }, { -11, 0 },
92 { 11, 1 }, { -11, -2 }, { -2, 11 }, { 7, -9 }, { -7, 9 }, { 10, 6 }, { -4, 11 }, { 8, -9 },
93 { 8, 9 }, { 5, 11 }, { 7, -10 }, { 12, -3 }, { 11, 6 }, { -9, -9 }, { 8, 10 }, { 5, 12 },
94 { -11, 7 }, { 13, 2 }, { 6, -12 }, { 10, 9 }, { -11, 8 }, { -7, 12 }, { 0, 14 }, { 14, -2 },
95 { -9, 11 }, { -6, 13 }, { -14, -4 }, { -5, -14 }, { 5, 14 }, { -15, -1 }, { -14, -6 }, { 3, -15 },
96 { 11, -11 }, { -7, 14 }, { -5, 15 }, { 8, -14 }, { 15, 6 }, { 3, 16 }, { 7, -15 }, { -16, 5 },
97 { 0, 17 }, { -16, -6 }, { -10, 14 }, { -16, 7 }, { 12, 13 }, { -16, 8 }, { -17, 6 }, { -18, 3 },
98 { -7, 17 }, { 15, 11 }, { 16, 10 }, { 2, -19 }, { 3, -19 }, { -11, -16 }, { -18, 8 }, { -19, -6 },
99 { 2, -20 }, { -17, -11 }, { -10, -18 }, { 8, 19 }, { -21, -1 }, { -20, 7 }, { -4, 21 }, { 21, 5 },
100 { 15, 16 }, { 2, -22 }, { -10, -20 }, { -22, 5 }, { 20, -11 }, { -7, -22 }, { -12, 20 }, { 23, -5 },
101 { 13, -20 }, { 24, -2 }, { -15, 19 }, { -11, 22 }, { 16, 19 }, { 23, -10 }, { -18, -18 }, { -9, -24 },
102 { 24, -10 }, { -3, 26 }, { -23, 13 }, { -18, -20 }, { 17, 21 }, { -4, 27 }, { 27, 6 }, { 1, -28 },
103 { -11, 26 }, { -17, -23 }, { 7, 28 }, { 11, -27 }, { 29, 5 }, { -23, -19 }, { -28, -11 }, { -21, 22 },
104 { -30, 7 }, { -17, 26 }, { -27, 16 }, { 13, 29 }, { 19, -26 }, { 10, -31 }, { -14, -30 }, { 20, -27 },
105 { -29, 18 }, { -16, -31 }, { -28, -22 }, { 21, -30 }, { -25, 28 }, { 26, -29 }, { 25, -32 }, { -32, -32 }
111 16, 15, 13, 19, 24, 31, 28, 17,
112 17, 23, 25, 31, 36, 63, 45, 21,
113 18, 24, 27, 37, 52, 59, 49, 20,
114 16, 28, 34, 40, 60, 80, 51, 20,
115 18, 31, 48, 66, 68, 86, 56, 21,
116 19, 38, 56, 59, 64, 64, 48, 20,
117 27, 48, 55, 55, 56, 51, 35, 15,
118 20, 35, 34, 32, 31, 22, 15, 8,
150 #define FIX_1_082392200 70936
151 #define FIX_1_414213562 92682
152 #define FIX_1_847759065 121095
153 #define FIX_2_613125930 171254
155 #define MULTIPLY(var, const) (((var) * (const)) >> 16)
159 int tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
160 int tmp10, tmp11, tmp12, tmp13;
161 int z5, z10, z11, z12, z13;
165 for (i = 0; i < 8; i++) {
166 tmp10 = block[8 * 0 + i] + block[8 * 4 + i];
167 tmp11 = block[8 * 0 + i] - block[8 * 4 + i];
169 tmp13 = block[8 * 2 + i] + block[8 * 6 + i];
172 tmp0 = tmp10 + tmp13;
173 tmp3 = tmp10 - tmp13;
174 tmp1 = tmp11 + tmp12;
175 tmp2 = tmp11 - tmp12;
177 z13 = block[8 * 5 + i] + block[8 * 3 + i];
178 z10 = block[8 * 5 + i] - block[8 * 3 + i];
179 z11 = block[8 * 1 + i] + block[8 * 7 + i];
180 z12 = block[8 * 1 + i] - block[8 * 7 + i];
193 temp[8 * 0 + i] = tmp0 + tmp7;
194 temp[8 * 7 + i] = tmp0 - tmp7;
195 temp[8 * 1 + i] = tmp1 + tmp6;
196 temp[8 * 6 + i] = tmp1 - tmp6;
197 temp[8 * 2 + i] = tmp2 + tmp5;
198 temp[8 * 5 + i] = tmp2 - tmp5;
199 temp[8 * 4 + i] = tmp3 + tmp4;
200 temp[8 * 3 + i] = tmp3 - tmp4;
203 for (i = 0; i < 8 * 8; i += 8) {
204 tmp10 = temp[0 + i] + temp[4 + i];
205 tmp11 = temp[0 + i] - temp[4 + i];
207 tmp13 = temp[2 + i] + temp[6 + i];
210 tmp0 = tmp10 + tmp13;
211 tmp3 = tmp10 - tmp13;
212 tmp1 = tmp11 + tmp12;
213 tmp2 = tmp11 - tmp12;
215 z13 = temp[5 + i] + temp[3 + i];
216 z10 = temp[5 + i] - temp[3 + i];
217 z11 = temp[1 + i] + temp[7 + i];
218 z12 = temp[1 + i] - temp[7 + i];
231 block[0 + i] = (tmp0 + tmp7) >> 6;
232 block[7 + i] = (tmp0 - tmp7) >> 6;
233 block[1 + i] = (tmp1 + tmp6) >> 6;
234 block[6 + i] = (tmp1 - tmp6) >> 6;
235 block[2 + i] = (tmp2 + tmp5) >> 6;
236 block[5 + i] = (tmp2 - tmp5) >> 6;
237 block[4 + i] = (tmp3 + tmp4) >> 6;
238 block[3 + i] = (tmp3 - tmp4) >> 6;
247 for (i = 0; i < 2; i++) {
248 for (j = 0; j < 4; j++) {
249 block_type_vlc[i][j].
table = table[i][j];
263 for (i = 0; i < 256; i++) {
272 #define LE_CENTRIC_MUL(dst, src, scale, dc) \
274 unsigned tmpval = AV_RN32(src); \
275 tmpval = (tmpval << 16) | (tmpval >> 16); \
276 tmpval = tmpval * (scale) + (dc); \
277 tmpval = (tmpval << 16) | (tmpval >> 16); \
278 AV_WN32A(dst, tmpval); \
281 #define LE_CENTRIC_MUL(dst, src, scale, dc) \
283 unsigned tmpval = AV_RN32(src) * (scale) + (dc); \
284 AV_WN32A(dst, tmpval); \
288 static inline void mcdc(uint16_t *dst, uint16_t *src,
int log2w,
296 for (i = 0; i < h; i++) {
297 dst[0] = scale * src[0] + dc;
304 for (i = 0; i < h; i++) {
312 for (i = 0; i < h; i++) {
321 for (i = 0; i < h; i++) {
337 int log2w,
int log2h,
int stride)
340 const int h = 1 << log2h;
345 uint16_t *end = start + stride * (f->
avctx->
height - h + 1) - (1 << log2w);
348 if (code < 0 || code > 6 || log2w < 0)
352 src += f->
mv[bytestream2_get_byte(&f->
g)];
353 if (start > src || src > end) {
357 mcdc(dst, src, log2w, h, stride, 1, 0);
358 }
else if (code == 1) {
360 if ((ret =
decode_p_block(f, dst, src, log2w, log2h, stride)) < 0)
363 src + (stride << log2h),
364 log2w, log2h, stride)) < 0)
366 }
else if (code == 2) {
368 if ((ret =
decode_p_block(f, dst , src, log2w, log2h, stride)) < 0)
372 log2w, log2h, stride)) < 0)
374 }
else if (code == 3 && f->
version < 2) {
375 if (start > src || src > end) {
379 mcdc(dst, src, log2w, h, stride, 1, 0);
380 }
else if (code == 4) {
381 src += f->
mv[bytestream2_get_byte(&f->
g)];
382 if (start > src || src > end) {
386 mcdc(dst, src, log2w, h, stride, 1, bytestream2_get_le16(&f->
g2));
387 }
else if (code == 5) {
388 if (start > src || src > end) {
392 mcdc(dst, src, log2w, h, stride, 0, bytestream2_get_le16(&f->
g2));
393 }
else if (code == 6) {
395 dst[0] = bytestream2_get_le16(&f->
g2);
396 dst[1] = bytestream2_get_le16(&f->
g2);
398 dst[0] = bytestream2_get_le16(&f->
g2);
399 dst[
stride] = bytestream2_get_le16(&f->
g2);
413 unsigned int bitstream_size, bytestream_size, wordstream_size, extra,
414 bytestream_offset, wordstream_offset;
430 bitstream_size =
AV_RL32(buf + 8);
431 wordstream_size =
AV_RL32(buf + 12);
432 bytestream_size =
AV_RL32(buf + 16);
435 bitstream_size =
AV_RL16(buf - 4);
436 wordstream_size =
AV_RL16(buf - 2);
437 bytestream_size =
FFMAX(length - bitstream_size - wordstream_size, 0);
440 if (bitstream_size + bytestream_size + wordstream_size + extra != length
441 || bitstream_size > (1 << 26)
442 || bytestream_size > (1 << 26)
443 || wordstream_size > (1 << 26)) {
445 bitstream_size, bytestream_size, wordstream_size,
446 bitstream_size + bytestream_size + wordstream_size - length);
460 wordstream_offset = extra + bitstream_size;
461 bytestream_offset = extra + bitstream_size + wordstream_size;
463 length - wordstream_offset);
465 length - bytestream_offset);
469 for (y = 0; y <
height; y += 8) {
470 for (x = 0; x <
width; x += 8)
471 if ((ret =
decode_p_block(f, dst + x, src + x, 3, 3, stride)) < 0)
486 int code, i, j,
level, val;
534 for (i = 0; i < 4; i++) {
535 block[i][0] += 0x80 * 8 * 8;
540 for (i = 4; i < 6; i++)
548 for (y = 0; y < 8; y++) {
549 for (x = 0; x < 8; x++) {
551 2 * (x & 3) + 2 * 8 * (y & 3);
552 int cb =
block[4][x + 8 * y];
553 int cr =
block[5][x + 8 * y];
554 int cg = (cb + cr) >> 1;
560 dst[0] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
562 dst[1] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
564 dst[
stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
566 dst[1 +
stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
569 dst += 2 * stride - 2 * 8;
579 for (i = 0; i < 6; i++)
590 int frequency[512] = { 0 };
599 memset(up, -1,
sizeof(up));
606 len -= end - start + 1;
608 if (end < start || len < 0)
611 for (i = start; i <= end; i++)
612 frequency[i] = *ptr++;
624 while ((ptr - buf) & 3)
627 for (j = 257; j < 512; j++) {
628 int min_freq[2] = { 256 * 256, 256 * 256 };
629 int smallest[2] = { 0, 0 };
631 for (i = 0; i < j; i++) {
632 if (frequency[i] == 0)
634 if (frequency[i] < min_freq[1]) {
635 if (frequency[i] < min_freq[0]) {
636 min_freq[1] = min_freq[0];
637 smallest[1] = smallest[0];
638 min_freq[0] = frequency[i];
641 min_freq[1] = frequency[i];
646 if (min_freq[1] == 256 * 256)
649 frequency[j] = min_freq[0] + min_freq[1];
650 flag[smallest[0]] = 0;
651 flag[smallest[1]] = 1;
654 frequency[smallest[0]] = frequency[smallest[1]] = 0;
657 for (j = 0; j < 257; j++) {
658 int node, len = 0,
bits = 0;
660 for (node = j; up[node] != -1; node = up[node]) {
666 "vlc length overflow\n");
682 int blue = 2 * (c0 & 0x001F) + (c1 & 0x001F);
683 int green = (2 * (c0 & 0x03E0) + (c1 & 0x03E0)) >> 5;
684 int red = 2 * (c0 >> 10) + (c1 >> 10);
685 return red / 3 * 1024 + green / 3 * 32 + blue / 3;
693 const int mbs = (
FFALIGN(width, 16) >> 4) * (
FFALIGN(height, 16) >> 4);
698 if (length < mbs * 8) {
704 for (y = 0; y <
height; y += 16) {
705 for (x = 0; x <
width; x += 16) {
708 color[0] = bytestream2_get_le16u(&g3);
709 color[1] = bytestream2_get_le16u(&g3);
711 if (color[0] & 0x8000)
713 if (color[1] & 0x8000)
716 color[2] =
mix(color[0], color[1]);
717 color[3] =
mix(color[1], color[0]);
719 bits = bytestream2_get_le32u(&g3);
720 for (y2 = 0; y2 < 16; y2++) {
721 for (x2 = 0; x2 < 16; x2++) {
722 int index = 2 * (x2 >> 2) + 8 * (y2 >> 2);
739 const unsigned int bitstream_size =
AV_RL32(buf);
741 unsigned int prestream_size;
744 if (bitstream_size > (1 << 26))
747 if (length < bitstream_size + 12) {
752 token_count =
AV_RL32(buf + bitstream_size + 8);
753 prestream_size = 4 *
AV_RL32(buf + bitstream_size + 4);
754 prestream = buf + bitstream_size + 12;
756 if (prestream_size + bitstream_size + 12 != length
757 || prestream_size > (1 << 26)) {
759 prestream_size, bitstream_size, length);
771 prestream_size = length + buf - prestream;
785 for (y = 0; y <
height; y += 16) {
786 for (x = 0; x <
width; x += 16) {
804 int buf_size = avpkt->
size;
815 "Dimensions non-multiple of 16 are invalid.\n");
819 if (buf_size <
AV_RL32(buf + 4) + 8) {
827 if (frame_4cc ==
AV_RL32(
"cfrm")) {
830 const int data_size = buf_size - 20;
837 whole_size =
AV_RL32(buf + 16);
851 if (i >= CFRAME_BUFFER_COUNT) {
865 memcpy(cfrm->
data + cfrm->
size, buf + 20, data_size);
866 cfrm->
size += data_size;
868 if (cfrm->
size >= whole_size) {
870 frame_size = cfrm->
size;
879 cfrm->
size = cfrm->
id = 0;
885 frame_size = buf_size - 12;
907 if (frame_4cc ==
AV_RL32(
"ifr2")) {
911 }
else if (frame_4cc ==
AV_RL32(
"ifrm")) {
915 }
else if (frame_4cc ==
AV_RL32(
"pfrm") || frame_4cc ==
AV_RL32(
"pfr2")) {
920 }
else if (frame_4cc ==
AV_RL32(
"snd_")) {
av_cold void ff_dsputil_init(DSPContext *c, AVCodecContext *avctx)
const uint8_t ff_zigzag_direct[64]
This structure describes decoded (raw) audio or video data.
static void idct(DCTELEM block[64])
void(* release_buffer)(struct AVCodecContext *c, AVFrame *pic)
Called to release buffers which were allocated with get_buffer.
AVFrame * coded_frame
the picture in the bitstream
#define AV_PIX_FMT_BGR555
static av_cold void init_vlcs(FourXContext *f)
AVCodec ff_fourxm_decoder
static VLC block_type_vlc[2][4]
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
static void init_mv(FourXContext *f)
void av_freep(void *arg)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size)
Allocate a buffer, reusing the given one if large enough.
static int decode(MimicContext *ctx, int quality, int num_coeffs, int is_iframe)
unsigned int allocated_size
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
struct CFrameBuffer CFrameBuffer
static const uint8_t block_type_tab[2][4][8][2]
static av_cold int decode_init(AVCodecContext *avctx)
bitstream reader API header.
#define AV_PIX_FMT_RGB565
static int init(AVCodecParserContext *s)
static int decode_i_block(FourXContext *f, DCTELEM *block)
decode block and dequantize.
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
static int decode_i_mb(FourXContext *f)
static const uint8_t frame_size[4]
void * av_fast_realloc(void *ptr, unsigned int *size, size_t min_size)
Reallocate the given block if it is not large enough, otherwise do nothing.
int reference
is this picture used as reference The values for this are the same as the MpegEncContext.picture_structure variable, that is 1->top field, 2->bottom field, 3->frame/both fields.
void(* bswap_buf)(uint32_t *dst, const uint32_t *src, int w)
#define LE_CENTRIC_MUL(dst, src, scale, dc)
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
void av_log(void *avcl, int level, const char *fmt,...)
static const uint8_t size2index[4][4]
const char * name
Name of the codec implementation.
#define CODEC_FLAG_EMU_EDGE
#define CFRAME_BUFFER_COUNT
static int decode_i_frame(FourXContext *f, const uint8_t *buf, int length)
static const uint8_t * read_huffman_tables(FourXContext *f, const uint8_t *const buf, int len)
enum AVPictureType pict_type
Picture type of the frame, see ?_TYPE below.
static int decode_p_block(FourXContext *f, uint16_t *dst, uint16_t *src, int log2w, int log2h, int stride)
int width
picture width / height.
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame)
Get a buffer for a frame.
static void mcdc(uint16_t *dst, uint16_t *src, int log2w, int h, int stride, int scale, unsigned dc)
static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)
Parse a vlc code.
#define INIT_VLC_USE_NEW_STATIC
static const int8_t mv[256][2]
struct FourXContext FourXContext
static void idct_put(FourXContext *f, int x, int y)
static int mix(int c0, int c1)
static int decode_i2_frame(FourXContext *f, const uint8_t *buf, int length)
int linesize[AV_NUM_DATA_POINTERS]
Size, in bytes, of the data for each picture/channel plane.
static av_cold void common_init(AVCodecContext *avctx)
main external API structure.
static void close(AVCodecParserContext *s)
static int get_xbits(GetBitContext *s, int n)
read mpeg1 dc style vlc (sign bit + mantisse with no MSB).
#define init_vlc(vlc, nb_bits, nb_codes,bits, bits_wrap, bits_size,codes, codes_wrap, codes_size,flags)
static const uint8_t dequant_table[64]
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
CFrameBuffer cfrm[CFRAME_BUFFER_COUNT]
#define FF_INPUT_BUFFER_PADDING_SIZE
unsigned int bitstream_buffer_size
static av_cold int decode_end(AVCodecContext *avctx)
static const uint16_t scale[4]
#define DECLARE_ALIGNED(n, t, v)
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
void(* clear_blocks)(DCTELEM *blocks)
static int decode_p_frame(FourXContext *f, const uint8_t *buf, int length)
common internal api header.
GetBitContext pre_gb
ac/dc prefix
#define AVERROR_INVALIDDATA
static const uint8_t color[]
VLC_TYPE(* table)[2]
code, bits
int key_frame
1 -> keyframe, 0-> not
int frame_number
Frame counter, set by libavcodec.
#define BLOCK_TYPE_VLC_BITS
#define MULTIPLY(var, const)
This structure stores compressed data.
void ff_free_vlc(VLC *vlc)
if(!(ptr_align%ac->ptr_align)&&samples_align >=aligned_len)