36 #define BLOCK_TYPE_VLC_BITS 5
37 #define ACDC_VLC_BITS 9
39 #define CFRAME_BUFFER_COUNT 100
44 { 0, 1 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 30, 5 }, { 31, 5 }, { 0, 0 }
46 { 0, 1 }, { 0, 0 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 15, 4 }, { 0, 0 }
48 { 0, 1 }, { 2, 2 }, { 0, 0 }, { 6, 3 }, { 14, 4 }, { 15, 4 }, { 0, 0 }
50 { 0, 1 }, { 0, 0 }, { 0, 0 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 15, 4 }
54 { 1, 2 }, { 4, 3 }, { 5, 3 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
56 { 1, 2 }, { 0, 0 }, { 2, 2 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
58 { 1, 2 }, { 2, 2 }, { 0, 0 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
60 { 1, 2 }, { 0, 0 }, { 0, 0 }, { 0, 2 }, { 2, 2 }, { 6, 3 }, { 7, 3 }
72 static const int8_t
mv[256][2] = {
73 { 0, 0 }, { 0, -1 }, { -1, 0 }, { 1, 0 }, { 0, 1 }, { -1, -1 }, { 1, -1 }, { -1, 1 },
74 { 1, 1 }, { 0, -2 }, { -2, 0 }, { 2, 0 }, { 0, 2 }, { -1, -2 }, { 1, -2 }, { -2, -1 },
75 { 2, -1 }, { -2, 1 }, { 2, 1 }, { -1, 2 }, { 1, 2 }, { -2, -2 }, { 2, -2 }, { -2, 2 },
76 { 2, 2 }, { 0, -3 }, { -3, 0 }, { 3, 0 }, { 0, 3 }, { -1, -3 }, { 1, -3 }, { -3, -1 },
77 { 3, -1 }, { -3, 1 }, { 3, 1 }, { -1, 3 }, { 1, 3 }, { -2, -3 }, { 2, -3 }, { -3, -2 },
78 { 3, -2 }, { -3, 2 }, { 3, 2 }, { -2, 3 }, { 2, 3 }, { 0, -4 }, { -4, 0 }, { 4, 0 },
79 { 0, 4 }, { -1, -4 }, { 1, -4 }, { -4, -1 }, { 4, -1 }, { 4, 1 }, { -1, 4 }, { 1, 4 },
80 { -3, -3 }, { -3, 3 }, { 3, 3 }, { -2, -4 }, { -4, -2 }, { 4, -2 }, { -4, 2 }, { -2, 4 },
81 { 2, 4 }, { -3, -4 }, { 3, -4 }, { 4, -3 }, { -5, 0 }, { -4, 3 }, { -3, 4 }, { 3, 4 },
82 { -1, -5 }, { -5, -1 }, { -5, 1 }, { -1, 5 }, { -2, -5 }, { 2, -5 }, { 5, -2 }, { 5, 2 },
83 { -4, -4 }, { -4, 4 }, { -3, -5 }, { -5, -3 }, { -5, 3 }, { 3, 5 }, { -6, 0 }, { 0, 6 },
84 { -6, -1 }, { -6, 1 }, { 1, 6 }, { 2, -6 }, { -6, 2 }, { 2, 6 }, { -5, -4 }, { 5, 4 },
85 { 4, 5 }, { -6, -3 }, { 6, 3 }, { -7, 0 }, { -1, -7 }, { 5, -5 }, { -7, 1 }, { -1, 7 },
86 { 4, -6 }, { 6, 4 }, { -2, -7 }, { -7, 2 }, { -3, -7 }, { 7, -3 }, { 3, 7 }, { 6, -5 },
87 { 0, -8 }, { -1, -8 }, { -7, -4 }, { -8, 1 }, { 4, 7 }, { 2, -8 }, { -2, 8 }, { 6, 6 },
88 { -8, 3 }, { 5, -7 }, { -5, 7 }, { 8, -4 }, { 0, -9 }, { -9, -1 }, { 1, 9 }, { 7, -6 },
89 { -7, 6 }, { -5, -8 }, { -5, 8 }, { -9, 3 }, { 9, -4 }, { 7, -7 }, { 8, -6 }, { 6, 8 },
90 { 10, 1 }, { -10, 2 }, { 9, -5 }, { 10, -3 }, { -8, -7 }, { -10, -4 }, { 6, -9 }, { -11, 0 },
91 { 11, 1 }, { -11, -2 }, { -2, 11 }, { 7, -9 }, { -7, 9 }, { 10, 6 }, { -4, 11 }, { 8, -9 },
92 { 8, 9 }, { 5, 11 }, { 7, -10 }, { 12, -3 }, { 11, 6 }, { -9, -9 }, { 8, 10 }, { 5, 12 },
93 { -11, 7 }, { 13, 2 }, { 6, -12 }, { 10, 9 }, { -11, 8 }, { -7, 12 }, { 0, 14 }, { 14, -2 },
94 { -9, 11 }, { -6, 13 }, { -14, -4 }, { -5, -14 }, { 5, 14 }, { -15, -1 }, { -14, -6 }, { 3, -15 },
95 { 11, -11 }, { -7, 14 }, { -5, 15 }, { 8, -14 }, { 15, 6 }, { 3, 16 }, { 7, -15 }, { -16, 5 },
96 { 0, 17 }, { -16, -6 }, { -10, 14 }, { -16, 7 }, { 12, 13 }, { -16, 8 }, { -17, 6 }, { -18, 3 },
97 { -7, 17 }, { 15, 11 }, { 16, 10 }, { 2, -19 }, { 3, -19 }, { -11, -16 }, { -18, 8 }, { -19, -6 },
98 { 2, -20 }, { -17, -11 }, { -10, -18 }, { 8, 19 }, { -21, -1 }, { -20, 7 }, { -4, 21 }, { 21, 5 },
99 { 15, 16 }, { 2, -22 }, { -10, -20 }, { -22, 5 }, { 20, -11 }, { -7, -22 }, { -12, 20 }, { 23, -5 },
100 { 13, -20 }, { 24, -2 }, { -15, 19 }, { -11, 22 }, { 16, 19 }, { 23, -10 }, { -18, -18 }, { -9, -24 },
101 { 24, -10 }, { -3, 26 }, { -23, 13 }, { -18, -20 }, { 17, 21 }, { -4, 27 }, { 27, 6 }, { 1, -28 },
102 { -11, 26 }, { -17, -23 }, { 7, 28 }, { 11, -27 }, { 29, 5 }, { -23, -19 }, { -28, -11 }, { -21, 22 },
103 { -30, 7 }, { -17, 26 }, { -27, 16 }, { 13, 29 }, { 19, -26 }, { 10, -31 }, { -14, -30 }, { 20, -27 },
104 { -29, 18 }, { -16, -31 }, { -28, -22 }, { 21, -30 }, { -25, 28 }, { 26, -29 }, { 25, -32 }, { -32, -32 }
110 16, 15, 13, 19, 24, 31, 28, 17,
111 17, 23, 25, 31, 36, 63, 45, 21,
112 18, 24, 27, 37, 52, 59, 49, 20,
113 16, 28, 34, 40, 60, 80, 51, 20,
114 18, 31, 48, 66, 68, 86, 56, 21,
115 19, 38, 56, 59, 64, 64, 48, 20,
116 27, 48, 55, 55, 56, 51, 35, 15,
117 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++) {
265 f->
mv[i] =
mv[i][0] +
mv[i][1] * linesize / 2;
267 f->
mv[i] = (i & 15) - 8 + ((i >> 4) - 8) * linesize / 2;
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);
350 if (code < 0 || code > 6 || log2w < 0)
355 if ((ret =
decode_p_block(f, dst, src, log2w, log2h, stride)) < 0)
358 src + (stride << log2h),
359 log2w, log2h, stride);
360 }
else if (code == 2) {
362 if ((ret =
decode_p_block(f, dst , src, log2w, log2h, stride)) < 0)
366 log2w, log2h, stride);
367 }
else if (code == 6) {
369 dst[0] = bytestream2_get_le16(&f->
g2);
370 dst[1] = bytestream2_get_le16(&f->
g2);
372 dst[0] = bytestream2_get_le16(&f->
g2);
373 dst[
stride] = bytestream2_get_le16(&f->
g2);
379 src += f->
mv[bytestream2_get_byte(&f->
g)];
380 }
else if (code == 3 && f->
version >= 2) {
382 }
else if (code == 4) {
383 src += f->
mv[bytestream2_get_byte(&f->
g)];
384 dc = bytestream2_get_le16(&f->
g2);
385 }
else if (code == 5) {
387 dc = bytestream2_get_le16(&f->
g2);
390 if (start > src || src > end) {
395 mcdc(dst, src, log2w, h, stride, scale, dc);
407 unsigned int bitstream_size, bytestream_size, wordstream_size, extra,
408 bytestream_offset, wordstream_offset;
417 bitstream_size =
AV_RL32(buf + 8);
418 wordstream_size =
AV_RL32(buf + 12);
419 bytestream_size =
AV_RL32(buf + 16);
422 bitstream_size =
AV_RL16(buf - 4);
423 wordstream_size =
AV_RL16(buf - 2);
424 bytestream_size =
FFMAX(length - bitstream_size - wordstream_size, 0);
427 if (bitstream_size + bytestream_size + wordstream_size + extra != length
428 || bitstream_size > (1 << 26)
429 || bytestream_size > (1 << 26)
430 || wordstream_size > (1 << 26)) {
432 bitstream_size, bytestream_size, wordstream_size,
433 bitstream_size + bytestream_size + wordstream_size - length);
447 wordstream_offset = extra + bitstream_size;
448 bytestream_offset = extra + bitstream_size + wordstream_size;
450 length - wordstream_offset);
452 length - bytestream_offset);
456 for (y = 0; y <
height; y += 8) {
457 for (x = 0; x <
width; x += 8)
473 int code, i, j,
level, val;
521 for (i = 0; i < 4; i++) {
522 block[i][0] += 0x80 * 8 * 8;
527 for (i = 4; i < 6; i++)
535 for (y = 0; y < 8; y++) {
536 for (x = 0; x < 8; x++) {
537 int16_t *temp =
block[(x >> 2) + 2 * (y >> 2)] +
538 2 * (x & 3) + 2 * 8 * (y & 3);
539 int cb =
block[4][x + 8 * y];
540 int cr =
block[5][x + 8 * y];
541 int cg = (cb + cr) >> 1;
547 dst[0] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
549 dst[1] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
551 dst[
stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
553 dst[1 +
stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
556 dst += 2 * stride - 2 * 8;
567 for (i = 0; i < 6; i++)
578 int frequency[512] = { 0 };
587 memset(up, -1,
sizeof(up));
594 len -= end - start + 1;
596 if (end < start || len < 0)
599 for (i = start; i <= end; i++)
600 frequency[i] = *ptr++;
612 while ((ptr - buf) & 3)
615 for (j = 257; j < 512; j++) {
616 int min_freq[2] = { 256 * 256, 256 * 256 };
617 int smallest[2] = { 0, 0 };
619 for (i = 0; i < j; i++) {
620 if (frequency[i] == 0)
622 if (frequency[i] < min_freq[1]) {
623 if (frequency[i] < min_freq[0]) {
624 min_freq[1] = min_freq[0];
625 smallest[1] = smallest[0];
626 min_freq[0] = frequency[i];
629 min_freq[1] = frequency[i];
634 if (min_freq[1] == 256 * 256)
637 frequency[j] = min_freq[0] + min_freq[1];
638 flag[smallest[0]] = 0;
639 flag[smallest[1]] = 1;
642 frequency[smallest[0]] = frequency[smallest[1]] = 0;
645 for (j = 0; j < 257; j++) {
646 int node, len = 0,
bits = 0;
648 for (node = j; up[node] != -1; node = up[node]) {
654 "vlc length overflow\n");
670 int blue = 2 * (c0 & 0x001F) + (c1 & 0x001F);
671 int green = (2 * (c0 & 0x03E0) + (c1 & 0x03E0)) >> 5;
672 int red = 2 * (c0 >> 10) + (c1 >> 10);
673 return red / 3 * 1024 + green / 3 * 32 + blue / 3;
681 const int mbs = (
FFALIGN(width, 16) >> 4) * (
FFALIGN(height, 16) >> 4);
685 if (length < mbs * 8) {
691 for (y = 0; y <
height; y += 16) {
692 for (x = 0; x <
width; x += 16) {
695 color[0] = bytestream2_get_le16u(&g3);
696 color[1] = bytestream2_get_le16u(&g3);
698 if (color[0] & 0x8000)
700 if (color[1] & 0x8000)
703 color[2] =
mix(color[0], color[1]);
704 color[3] =
mix(color[1], color[0]);
706 bits = bytestream2_get_le32u(&g3);
707 for (y2 = 0; y2 < 16; y2++) {
708 for (x2 = 0; x2 < 16; x2++) {
709 int index = 2 * (x2 >> 2) + 8 * (y2 >> 2);
710 dst[y2 * width + x2] = color[(
bits >>
index) & 3];
715 dst += 16 * width - x;
726 const unsigned int bitstream_size =
AV_RL32(buf);
728 unsigned int prestream_size;
731 if (bitstream_size > (1 << 26))
734 if (length < bitstream_size + 12) {
739 token_count =
AV_RL32(buf + bitstream_size + 8);
740 prestream_size = 4 *
AV_RL32(buf + bitstream_size + 4);
741 prestream = buf + bitstream_size + 12;
743 if (prestream_size + bitstream_size + 12 != length
744 || prestream_size > (1 << 26)) {
746 prestream_size, bitstream_size, length);
758 prestream_size = length + buf - prestream;
772 for (y = 0; y <
height; y += 16) {
773 for (x = 0; x <
width; x += 16) {
791 int buf_size = avpkt->
size;
801 "Dimensions non-multiple of 16 are invalid.\n");
805 if (buf_size <
AV_RL32(buf + 4) + 8) {
813 if (frame_4cc ==
AV_RL32(
"cfrm")) {
816 const int data_size = buf_size - 20;
823 whole_size =
AV_RL32(buf + 16);
837 if (i >= CFRAME_BUFFER_COUNT) {
851 memcpy(cfrm->
data + cfrm->
size, buf + 20, data_size);
852 cfrm->
size += data_size;
854 if (cfrm->
size >= whole_size) {
856 frame_size = cfrm->
size;
865 cfrm->
size = cfrm->
id = 0;
871 frame_size = buf_size - 12;
880 if (frame_4cc ==
AV_RL32(
"ifr2")) {
884 }
else if (frame_4cc ==
AV_RL32(
"ifrm")) {
888 }
else if (frame_4cc ==
AV_RL32(
"pfrm") || frame_4cc ==
AV_RL32(
"pfr2")) {
892 }
else if (frame_4cc ==
AV_RL32(
"snd_")) {
av_cold void ff_dsputil_init(DSPContext *c, AVCodecContext *avctx)
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
This structure describes decoded (raw) audio or video data.
static void idct(int16_t block[64])
static av_cold void init_vlcs(FourXContext *f)
AVCodec ff_fourxm_decoder
static VLC block_type_vlc[2][4]
#define DECLARE_ALIGNED(n, t, v)
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)
void av_freep(void *arg)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
static int decode(MimicContext *ctx, int quality, int num_coeffs, int is_iframe)
unsigned int allocated_size
uint16_t * last_frame_buffer
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
#define CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
static const uint8_t block_type_tab[2][4][8][2]
static av_cold int decode_init(AVCodecContext *avctx)
bitstream reader API header.
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]
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
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.
void(* bswap_buf)(uint32_t *dst, const uint32_t *src, int w)
#define LE_CENTRIC_MUL(dst, src, scale, dc)
static int decode_i_block(FourXContext *f, int16_t *block)
decode block and dequantize.
#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.
reference-counted frame API
#define CFRAME_BUFFER_COUNT
#define FF_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of the image can be address...
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.
static int decode_p_block(FourXContext *f, uint16_t *dst, uint16_t *src, int log2w, int log2h, int stride)
int width
picture width / height.
void(* clear_blocks)(int16_t *blocks)
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]
#define AV_PIX_FMT_BGR555
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)
Libavcodec external API header.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
main external API structure.
static void init_mv(FourXContext *f, int linesize)
static void close(AVCodecParserContext *s)
static int get_xbits(GetBitContext *s, int n)
read mpeg1 dc style vlc (sign bit + mantisse with no MSB).
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
#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]
unsigned int bitstream_buffer_size
static av_cold int decode_end(AVCodecContext *avctx)
static const uint16_t scale[4]
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
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_p_frame(FourXContext *f, const uint8_t *buf, int length)
common internal api header.
const uint8_t ff_zigzag_direct[64]
#define CODEC_FLAG_GRAY
Only decode/encode grayscale.
GetBitContext pre_gb
ac/dc prefix
static const uint8_t color[]
static av_cold int init(AVCodecParserContext *s)
VLC_TYPE(* table)[2]
code, bits
int key_frame
1 -> keyframe, 0-> not
#define AV_PIX_FMT_RGB565
int frame_number
Frame counter, set by libavcodec.
#define BLOCK_TYPE_VLC_BITS
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31))))#defineSET_CONV_FUNC_GROUP(ofmt, ifmt) staticvoidset_generic_function(AudioConvert *ac){}voidff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, intsample_rate, intapply_map){AudioConvert *ac;intin_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) returnNULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method!=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt)>2){ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc){av_free(ac);returnNULL;}returnac;}in_planar=av_sample_fmt_is_planar(in_fmt);out_planar=av_sample_fmt_is_planar(out_fmt);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}elseif(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;elseac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);returnac;}intff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){intuse_generic=1;intlen=in->nb_samples;intp;if(ac->dc){av_dlog(ac->avr,"%dsamples-audio_convert:%sto%s(dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));returnff_convert_dither(ac-> dc
#define FFSWAP(type, a, b)
void av_image_copy_plane(uint8_t *dst, int dst_linesize, const uint8_t *src, int src_linesize, int bytewidth, int height)
Copy image plane from src to dst.
#define MULTIPLY(var, const)
This structure stores compressed data.
void ff_free_vlc(VLC *vlc)
void * av_mallocz(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...