39 #define BLOCK_TYPE_VLC_BITS 5 40 #define ACDC_VLC_BITS 9 42 #define CFRAME_BUFFER_COUNT 100 47 { 0, 1 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 30, 5 }, { 31, 5 }, { 0, 0 }
49 { 0, 1 }, { 0, 0 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 15, 4 }, { 0, 0 }
51 { 0, 1 }, { 2, 2 }, { 0, 0 }, { 6, 3 }, { 14, 4 }, { 15, 4 }, { 0, 0 }
53 { 0, 1 }, { 0, 0 }, { 0, 0 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 15, 4 }
57 { 1, 2 }, { 4, 3 }, { 5, 3 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
59 { 1, 2 }, { 0, 0 }, { 2, 2 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
61 { 1, 2 }, { 2, 2 }, { 0, 0 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
63 { 1, 2 }, { 0, 0 }, { 0, 0 }, { 0, 2 }, { 2, 2 }, { 6, 3 }, { 7, 3 }
75 static const int8_t
mv[256][2] = {
76 { 0, 0 }, { 0, -1 }, { -1, 0 }, { 1, 0 }, { 0, 1 }, { -1, -1 }, { 1, -1 }, { -1, 1 },
77 { 1, 1 }, { 0, -2 }, { -2, 0 }, { 2, 0 }, { 0, 2 }, { -1, -2 }, { 1, -2 }, { -2, -1 },
78 { 2, -1 }, { -2, 1 }, { 2, 1 }, { -1, 2 }, { 1, 2 }, { -2, -2 }, { 2, -2 }, { -2, 2 },
79 { 2, 2 }, { 0, -3 }, { -3, 0 }, { 3, 0 }, { 0, 3 }, { -1, -3 }, { 1, -3 }, { -3, -1 },
80 { 3, -1 }, { -3, 1 }, { 3, 1 }, { -1, 3 }, { 1, 3 }, { -2, -3 }, { 2, -3 }, { -3, -2 },
81 { 3, -2 }, { -3, 2 }, { 3, 2 }, { -2, 3 }, { 2, 3 }, { 0, -4 }, { -4, 0 }, { 4, 0 },
82 { 0, 4 }, { -1, -4 }, { 1, -4 }, { -4, -1 }, { 4, -1 }, { 4, 1 }, { -1, 4 }, { 1, 4 },
83 { -3, -3 }, { -3, 3 }, { 3, 3 }, { -2, -4 }, { -4, -2 }, { 4, -2 }, { -4, 2 }, { -2, 4 },
84 { 2, 4 }, { -3, -4 }, { 3, -4 }, { 4, -3 }, { -5, 0 }, { -4, 3 }, { -3, 4 }, { 3, 4 },
85 { -1, -5 }, { -5, -1 }, { -5, 1 }, { -1, 5 }, { -2, -5 }, { 2, -5 }, { 5, -2 }, { 5, 2 },
86 { -4, -4 }, { -4, 4 }, { -3, -5 }, { -5, -3 }, { -5, 3 }, { 3, 5 }, { -6, 0 }, { 0, 6 },
87 { -6, -1 }, { -6, 1 }, { 1, 6 }, { 2, -6 }, { -6, 2 }, { 2, 6 }, { -5, -4 }, { 5, 4 },
88 { 4, 5 }, { -6, -3 }, { 6, 3 }, { -7, 0 }, { -1, -7 }, { 5, -5 }, { -7, 1 }, { -1, 7 },
89 { 4, -6 }, { 6, 4 }, { -2, -7 }, { -7, 2 }, { -3, -7 }, { 7, -3 }, { 3, 7 }, { 6, -5 },
90 { 0, -8 }, { -1, -8 }, { -7, -4 }, { -8, 1 }, { 4, 7 }, { 2, -8 }, { -2, 8 }, { 6, 6 },
91 { -8, 3 }, { 5, -7 }, { -5, 7 }, { 8, -4 }, { 0, -9 }, { -9, -1 }, { 1, 9 }, { 7, -6 },
92 { -7, 6 }, { -5, -8 }, { -5, 8 }, { -9, 3 }, { 9, -4 }, { 7, -7 }, { 8, -6 }, { 6, 8 },
93 { 10, 1 }, { -10, 2 }, { 9, -5 }, { 10, -3 }, { -8, -7 }, { -10, -4 }, { 6, -9 }, { -11, 0 },
94 { 11, 1 }, { -11, -2 }, { -2, 11 }, { 7, -9 }, { -7, 9 }, { 10, 6 }, { -4, 11 }, { 8, -9 },
95 { 8, 9 }, { 5, 11 }, { 7, -10 }, { 12, -3 }, { 11, 6 }, { -9, -9 }, { 8, 10 }, { 5, 12 },
96 { -11, 7 }, { 13, 2 }, { 6, -12 }, { 10, 9 }, { -11, 8 }, { -7, 12 }, { 0, 14 }, { 14, -2 },
97 { -9, 11 }, { -6, 13 }, { -14, -4 }, { -5, -14 }, { 5, 14 }, { -15, -1 }, { -14, -6 }, { 3, -15 },
98 { 11, -11 }, { -7, 14 }, { -5, 15 }, { 8, -14 }, { 15, 6 }, { 3, 16 }, { 7, -15 }, { -16, 5 },
99 { 0, 17 }, { -16, -6 }, { -10, 14 }, { -16, 7 }, { 12, 13 }, { -16, 8 }, { -17, 6 }, { -18, 3 },
100 { -7, 17 }, { 15, 11 }, { 16, 10 }, { 2, -19 }, { 3, -19 }, { -11, -16 }, { -18, 8 }, { -19, -6 },
101 { 2, -20 }, { -17, -11 }, { -10, -18 }, { 8, 19 }, { -21, -1 }, { -20, 7 }, { -4, 21 }, { 21, 5 },
102 { 15, 16 }, { 2, -22 }, { -10, -20 }, { -22, 5 }, { 20, -11 }, { -7, -22 }, { -12, 20 }, { 23, -5 },
103 { 13, -20 }, { 24, -2 }, { -15, 19 }, { -11, 22 }, { 16, 19 }, { 23, -10 }, { -18, -18 }, { -9, -24 },
104 { 24, -10 }, { -3, 26 }, { -23, 13 }, { -18, -20 }, { 17, 21 }, { -4, 27 }, { 27, 6 }, { 1, -28 },
105 { -11, 26 }, { -17, -23 }, { 7, 28 }, { 11, -27 }, { 29, 5 }, { -23, -19 }, { -28, -11 }, { -21, 22 },
106 { -30, 7 }, { -17, 26 }, { -27, 16 }, { 13, 29 }, { 19, -26 }, { 10, -31 }, { -14, -30 }, { 20, -27 },
107 { -29, 18 }, { -16, -31 }, { -28, -22 }, { 21, -30 }, { -25, 28 }, { 26, -29 }, { 25, -32 }, { -32, -32 }
113 16, 15, 13, 19, 24, 31, 28, 17,
114 17, 23, 25, 31, 36, 63, 45, 21,
115 18, 24, 27, 37, 52, 59, 49, 20,
116 16, 28, 34, 40, 60, 80, 51, 20,
117 18, 31, 48, 66, 68, 86, 56, 21,
118 19, 38, 56, 59, 64, 64, 48, 20,
119 27, 48, 55, 55, 56, 51, 35, 15,
120 20, 35, 34, 32, 31, 22, 15, 8,
154 #define FIX_1_082392200 70936 155 #define FIX_1_414213562 92682 156 #define FIX_1_847759065 121095 157 #define FIX_2_613125930 171254 159 #define MULTIPLY(var, const) (((var) * (const)) >> 16) 163 int tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
164 int tmp10, tmp11, tmp12, tmp13;
165 int z5, z10, z11, z12, z13;
169 for (i = 0; i < 8; i++) {
170 tmp10 = block[8 * 0 + i] + block[8 * 4 + i];
171 tmp11 = block[8 * 0 + i] - block[8 * 4 + i];
173 tmp13 = block[8 * 2 + i] + block[8 * 6 + i];
176 tmp0 = tmp10 + tmp13;
177 tmp3 = tmp10 - tmp13;
178 tmp1 = tmp11 + tmp12;
179 tmp2 = tmp11 - tmp12;
181 z13 = block[8 * 5 + i] + block[8 * 3 + i];
182 z10 = block[8 * 5 + i] - block[8 * 3 + i];
183 z11 = block[8 * 1 + i] + block[8 * 7 + i];
184 z12 = block[8 * 1 + i] - block[8 * 7 + i];
197 temp[8 * 0 + i] = tmp0 + tmp7;
198 temp[8 * 7 + i] = tmp0 - tmp7;
199 temp[8 * 1 + i] = tmp1 + tmp6;
200 temp[8 * 6 + i] = tmp1 - tmp6;
201 temp[8 * 2 + i] = tmp2 + tmp5;
202 temp[8 * 5 + i] = tmp2 - tmp5;
203 temp[8 * 4 + i] = tmp3 + tmp4;
204 temp[8 * 3 + i] = tmp3 - tmp4;
207 for (i = 0; i < 8 * 8; i += 8) {
208 tmp10 = temp[0 + i] + temp[4 + i];
209 tmp11 = temp[0 + i] - temp[4 + i];
211 tmp13 = temp[2 + i] + temp[6 + i];
214 tmp0 = tmp10 + tmp13;
215 tmp3 = tmp10 - tmp13;
216 tmp1 = tmp11 + tmp12;
217 tmp2 = tmp11 - tmp12;
219 z13 = temp[5 + i] + temp[3 + i];
220 z10 = temp[5 + i] - temp[3 + i];
221 z11 = temp[1 + i] + temp[7 + i];
222 z12 = temp[1 + i] - temp[7 + i];
235 block[0 + i] = (tmp0 + tmp7) >> 6;
236 block[7 + i] = (tmp0 - tmp7) >> 6;
237 block[1 + i] = (tmp1 + tmp6) >> 6;
238 block[6 + i] = (tmp1 - tmp6) >> 6;
239 block[2 + i] = (tmp2 + tmp5) >> 6;
240 block[5 + i] = (tmp2 - tmp5) >> 6;
241 block[4 + i] = (tmp3 + tmp4) >> 6;
242 block[3 + i] = (tmp3 - tmp4) >> 6;
251 for (i = 0; i < 2; i++) {
252 for (j = 0; j < 4; j++) {
253 block_type_vlc[i][j].
table = table[i][j];
267 for (i = 0; i < 256; i++) {
269 f->
mv[i] =
mv[i][0] +
mv[i][1] * linesize / 2;
271 f->
mv[i] = (i & 15) - 8 + ((i >> 4) - 8) * linesize / 2;
276 #define LE_CENTRIC_MUL(dst, src, scale, dc) \ 278 unsigned tmpval = AV_RN32(src); \ 279 tmpval = (tmpval << 16) | (tmpval >> 16); \ 280 tmpval = tmpval * (scale) + (dc); \ 281 tmpval = (tmpval << 16) | (tmpval >> 16); \ 282 AV_WN32A(dst, tmpval); \ 285 #define LE_CENTRIC_MUL(dst, src, scale, dc) \ 287 unsigned tmpval = AV_RN32(src) * (scale) + (dc); \ 288 AV_WN32A(dst, tmpval); \ 292 static inline void mcdc(uint16_t *dst, uint16_t *
src,
int log2w,
293 int h,
int stride,
int scale,
unsigned dc)
300 for (i = 0; i < h; i++) {
301 dst[0] = scale * src[0] +
dc;
308 for (i = 0; i < h; i++) {
316 for (i = 0; i < h; i++) {
325 for (i = 0; i < h; i++) {
341 int log2w,
int log2h,
int stride)
343 int index, h, code, ret, scale = 1;
344 uint16_t *start, *end;
347 if (log2h < 0 || log2w < 0)
357 if (code < 0 || code > 6)
361 end = start + stride * (f->
avctx->
height - h + 1) - (1 << log2w);
366 if ((ret =
decode_p_block(f, dst, src, log2w, log2h, stride)) < 0)
369 src + (stride << log2h),
370 log2w, log2h, stride);
371 }
else if (code == 2) {
373 if ((ret =
decode_p_block(f, dst , src, log2w, log2h, stride)) < 0)
377 log2w, log2h, stride);
378 }
else if (code == 6) {
380 dst[0] = bytestream2_get_le16(&f->
g2);
381 dst[1] = bytestream2_get_le16(&f->
g2);
383 dst[0] = bytestream2_get_le16(&f->
g2);
384 dst[
stride] = bytestream2_get_le16(&f->
g2);
390 src += f->
mv[bytestream2_get_byte(&f->
g)];
391 }
else if (code == 3 && f->
version >= 2) {
393 }
else if (code == 4) {
394 src += f->
mv[bytestream2_get_byte(&f->
g)];
395 dc = bytestream2_get_le16(&f->
g2);
396 }
else if (code == 5) {
398 dc = bytestream2_get_le16(&f->
g2);
401 if (start > src || src > end) {
406 mcdc(dst, src, log2w, h, stride, scale, dc);
418 unsigned int bitstream_size, bytestream_size, wordstream_size, extra,
419 bytestream_offset, wordstream_offset;
428 bitstream_size =
AV_RL32(buf + 8);
429 wordstream_size =
AV_RL32(buf + 12);
430 bytestream_size =
AV_RL32(buf + 16);
433 bitstream_size =
AV_RL16(buf - 4);
434 wordstream_size =
AV_RL16(buf - 2);
435 bytestream_size =
FFMAX(length - bitstream_size - wordstream_size, 0);
438 if (bitstream_size + bytestream_size + wordstream_size + extra != length
439 || bitstream_size > (1 << 26)
440 || bytestream_size > (1 << 26)
441 || wordstream_size > (1 << 26)) {
443 bitstream_size, bytestream_size, wordstream_size,
444 bitstream_size + bytestream_size + wordstream_size - length);
458 wordstream_offset = extra + bitstream_size;
459 bytestream_offset = extra + bitstream_size + wordstream_size;
461 length - wordstream_offset);
463 length - bytestream_offset);
467 for (y = 0; y <
height; y += 8) {
468 for (x = 0; x <
width; x += 8)
484 int code, i, j,
level, val;
532 for (i = 0; i < 4; i++) {
533 block[i][0] += 0x80 * 8 * 8;
538 for (i = 4; i < 6; i++)
546 for (y = 0; y < 8; y++) {
547 for (x = 0; x < 8; x++) {
548 int16_t *temp =
block[(x >> 2) + 2 * (y >> 2)] +
549 2 * (x & 3) + 2 * 8 * (y & 3);
550 int cb =
block[4][x + 8 * y];
551 int cr =
block[5][x + 8 * y];
552 int cg = (cb + cr) >> 1;
558 dst[0] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
560 dst[1] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
562 dst[
stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
564 dst[1 +
stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
567 dst += 2 * stride - 2 * 8;
578 for (i = 0; i < 6; i++)
589 int frequency[512] = { 0 };
598 memset(up, -1,
sizeof(up));
605 len -= end - start + 1;
607 if (end < start || len < 0)
610 for (i = start; i <= end; i++)
611 frequency[i] = *ptr++;
623 while ((ptr - buf) & 3)
626 for (j = 257; j < 512; j++) {
627 int min_freq[2] = { 256 * 256, 256 * 256 };
628 int smallest[2] = { 0, 0 };
630 for (i = 0; i < j; i++) {
631 if (frequency[i] == 0)
633 if (frequency[i] < min_freq[1]) {
634 if (frequency[i] < min_freq[0]) {
635 min_freq[1] = min_freq[0];
636 smallest[1] = smallest[0];
637 min_freq[0] = frequency[i];
640 min_freq[1] = frequency[i];
645 if (min_freq[1] == 256 * 256)
648 frequency[j] = min_freq[0] + min_freq[1];
649 flag[smallest[0]] = 0;
650 flag[smallest[1]] = 1;
653 frequency[smallest[0]] = frequency[smallest[1]] = 0;
656 for (j = 0; j < 257; j++) {
657 int node, len = 0,
bits = 0;
659 for (node = j; up[node] != -1; node = up[node]) {
665 "vlc length overflow\n");
679 static int mix(
int c0,
int c1)
681 int blue = 2 * (c0 & 0x001F) + (c1 & 0x001F);
682 int green = (2 * (c0 & 0x03E0) + (c1 & 0x03E0)) >> 5;
683 int red = 2 * (c0 >> 10) + (c1 >> 10);
684 return red / 3 * 1024 + green / 3 * 32 + blue / 3;
692 const int mbs = (
FFALIGN(width, 16) >> 4) * (
FFALIGN(height, 16) >> 4);
696 if (length < mbs * 8) {
702 for (y = 0; y <
height; y += 16) {
703 for (x = 0; x <
width; x += 16) {
706 color[0] = bytestream2_get_le16u(&g3);
707 color[1] = bytestream2_get_le16u(&g3);
709 if (color[0] & 0x8000)
711 if (color[1] & 0x8000)
714 color[2] =
mix(color[0], color[1]);
715 color[3] =
mix(color[1], color[0]);
717 bits = bytestream2_get_le32u(&g3);
718 for (y2 = 0; y2 < 16; y2++) {
719 for (x2 = 0; x2 < 16; x2++) {
720 int index = 2 * (x2 >> 2) + 8 * (y2 >> 2);
721 dst[y2 * width + x2] = color[(
bits >>
index) & 3];
726 dst += 16 * width - x;
737 const unsigned int bitstream_size =
AV_RL32(buf);
739 unsigned int prestream_size;
742 if (bitstream_size > (1 << 26))
745 if (length < bitstream_size + 12) {
750 token_count =
AV_RL32(buf + bitstream_size + 8);
751 prestream_size = 4 *
AV_RL32(buf + bitstream_size + 4);
752 prestream = buf + bitstream_size + 12;
754 if (prestream_size + bitstream_size + 12 != length
755 || prestream_size > (1 << 26)) {
757 prestream_size, bitstream_size, length);
769 prestream_size = length + buf - prestream;
783 for (y = 0; y <
height; y += 16) {
784 for (x = 0; x <
width; x += 16) {
802 int buf_size = avpkt->
size;
812 "Dimensions non-multiple of 16 are invalid.\n");
816 if (buf_size <
AV_RL32(buf + 4) + 8) {
824 if (frame_4cc ==
AV_RL32(
"cfrm")) {
827 const int data_size = buf_size - 20;
831 whole_size =
AV_RL32(buf + 16);
845 if (i >= CFRAME_BUFFER_COUNT) {
859 memcpy(cfrm->
data + cfrm->
size, buf + 20, data_size);
860 cfrm->
size += data_size;
862 if (cfrm->
size >= whole_size) {
864 frame_size = cfrm->
size;
873 cfrm->
size = cfrm->
id = 0;
879 frame_size = buf_size - 12;
888 if (frame_4cc ==
AV_RL32(
"ifr2")) {
892 }
else if (frame_4cc ==
AV_RL32(
"ifrm")) {
896 }
else if (frame_4cc ==
AV_RL32(
"pfrm") || frame_4cc ==
AV_RL32(
"pfr2")) {
900 }
else if (frame_4cc ==
AV_RL32(
"snd_")) {
#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 const uint8_t frame_size[4]
static av_cold void init_vlcs(FourXContext *f)
AVCodec ff_fourxm_decoder
av_log(ac->avr, AV_LOG_TRACE, "%d samples - audio_convert: %s to %s (%s)\, len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt), use_generic ? ac->func_descr_generic :ac->func_descr)
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)
#define init_vlc(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size, codes, codes_wrap, codes_size, flags)
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(* bswap_buf)(uint32_t *dst, const uint32_t *src, int w)
unsigned int allocated_size
uint16_t * last_frame_buffer
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
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_CODEC_FLAG_GRAY
Only decode/encode grayscale.
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
static int decode_i_mb(FourXContext *f)
#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.
#define LE_CENTRIC_MUL(dst, src, scale, dc)
void(* clear_blocks)(int16_t *blocks)
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. ...
int flags
AV_CODEC_FLAG_*.
static const uint8_t size2index[4][4]
const char * name
Name of the codec implementation.
reference-counted frame API
#define CFRAME_BUFFER_COUNT
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.
static int decode(AVCodecContext *avctx, AVFrame *frame, int *got_frame, AVPacket *pkt)
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.
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.
av_cold void ff_blockdsp_init(BlockDSPContext *c, AVCodecContext *avctx)
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 int get_xbits(GetBitContext *s, int n)
Read MPEG-1 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.
static const uint8_t dequant_table[64]
static const uint8_t color[NB_LEVELS]
CFrameBuffer cfrm[CFRAME_BUFFER_COUNT]
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
const uint8_t ff_zigzag_direct[64]
unsigned int bitstream_buffer_size
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(const int16_t *) pi >> 8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(const int32_t *) pi >> 24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) #define SET_CONV_FUNC_GROUP(ofmt, ifmt) static void set_generic_function(AudioConvert *ac) { } void ff_audio_convert_free(AudioConvert **ac) { if(! *ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);} AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map) { AudioConvert *ac;int in_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) return NULL;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);return NULL;} return ac;} in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar) { ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar ? ac->channels :1;} else if(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;else ac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);return ac;} int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in) { int use_generic=1;int len=in->nb_samples;int p;if(ac->dc) { av_log(ac->avr, AV_LOG_TRACE, "%d samples - audio_convert: %s to %s (dithered)\", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> dc
static av_cold int decode_end(AVCodecContext *avctx)
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.
#define INIT_VLC_USE_NEW_STATIC
GetBitContext pre_gb
ac/dc prefix
static av_cold int init(AVCodecParserContext *s)
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
av_cold void ff_bswapdsp_init(BswapDSPContext *c)
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
#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 ...
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.