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)
344 const int h = 1 << log2h;
349 uint16_t *end = start + stride * (f->
avctx->
height - h + 1) - (1 << log2w);
354 if (code < 0 || code > 6 || log2w < 0)
359 if ((ret =
decode_p_block(f, dst, src, log2w, log2h, stride)) < 0)
362 src + (stride << log2h),
363 log2w, log2h, stride);
364 }
else if (code == 2) {
366 if ((ret =
decode_p_block(f, dst , src, log2w, log2h, stride)) < 0)
370 log2w, log2h, stride);
371 }
else if (code == 6) {
373 dst[0] = bytestream2_get_le16(&f->
g2);
374 dst[1] = bytestream2_get_le16(&f->
g2);
376 dst[0] = bytestream2_get_le16(&f->
g2);
377 dst[
stride] = bytestream2_get_le16(&f->
g2);
383 src += f->
mv[bytestream2_get_byte(&f->
g)];
384 }
else if (code == 3 && f->
version >= 2) {
386 }
else if (code == 4) {
387 src += f->
mv[bytestream2_get_byte(&f->
g)];
388 dc = bytestream2_get_le16(&f->
g2);
389 }
else if (code == 5) {
391 dc = bytestream2_get_le16(&f->
g2);
394 if (start > src || src > end) {
399 mcdc(dst, src, log2w, h, stride, scale, dc);
411 unsigned int bitstream_size, bytestream_size, wordstream_size, extra,
412 bytestream_offset, wordstream_offset;
421 bitstream_size =
AV_RL32(buf + 8);
422 wordstream_size =
AV_RL32(buf + 12);
423 bytestream_size =
AV_RL32(buf + 16);
426 bitstream_size =
AV_RL16(buf - 4);
427 wordstream_size =
AV_RL16(buf - 2);
428 bytestream_size =
FFMAX(length - bitstream_size - wordstream_size, 0);
431 if (bitstream_size + bytestream_size + wordstream_size + extra != length
432 || bitstream_size > (1 << 26)
433 || bytestream_size > (1 << 26)
434 || wordstream_size > (1 << 26)) {
436 bitstream_size, bytestream_size, wordstream_size,
437 bitstream_size + bytestream_size + wordstream_size - length);
451 wordstream_offset = extra + bitstream_size;
452 bytestream_offset = extra + bitstream_size + wordstream_size;
454 length - wordstream_offset);
456 length - bytestream_offset);
460 for (y = 0; y <
height; y += 8) {
461 for (x = 0; x <
width; x += 8)
477 int code, i, j,
level, val;
525 for (i = 0; i < 4; i++) {
526 block[i][0] += 0x80 * 8 * 8;
531 for (i = 4; i < 6; i++)
539 for (y = 0; y < 8; y++) {
540 for (x = 0; x < 8; x++) {
541 int16_t *temp =
block[(x >> 2) + 2 * (y >> 2)] +
542 2 * (x & 3) + 2 * 8 * (y & 3);
543 int cb =
block[4][x + 8 * y];
544 int cr =
block[5][x + 8 * y];
545 int cg = (cb + cr) >> 1;
551 dst[0] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
553 dst[1] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
555 dst[
stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
557 dst[1 +
stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
560 dst += 2 * stride - 2 * 8;
571 for (i = 0; i < 6; i++)
582 int frequency[512] = { 0 };
591 memset(up, -1,
sizeof(up));
598 len -= end - start + 1;
600 if (end < start || len < 0)
603 for (i = start; i <= end; i++)
604 frequency[i] = *ptr++;
616 while ((ptr - buf) & 3)
619 for (j = 257; j < 512; j++) {
620 int min_freq[2] = { 256 * 256, 256 * 256 };
621 int smallest[2] = { 0, 0 };
623 for (i = 0; i < j; i++) {
624 if (frequency[i] == 0)
626 if (frequency[i] < min_freq[1]) {
627 if (frequency[i] < min_freq[0]) {
628 min_freq[1] = min_freq[0];
629 smallest[1] = smallest[0];
630 min_freq[0] = frequency[i];
633 min_freq[1] = frequency[i];
638 if (min_freq[1] == 256 * 256)
641 frequency[j] = min_freq[0] + min_freq[1];
642 flag[smallest[0]] = 0;
643 flag[smallest[1]] = 1;
646 frequency[smallest[0]] = frequency[smallest[1]] = 0;
649 for (j = 0; j < 257; j++) {
650 int node, len = 0,
bits = 0;
652 for (node = j; up[node] != -1; node = up[node]) {
658 "vlc length overflow\n");
672 static int mix(
int c0,
int c1)
674 int blue = 2 * (c0 & 0x001F) + (c1 & 0x001F);
675 int green = (2 * (c0 & 0x03E0) + (c1 & 0x03E0)) >> 5;
676 int red = 2 * (c0 >> 10) + (c1 >> 10);
677 return red / 3 * 1024 + green / 3 * 32 + blue / 3;
685 const int mbs = (
FFALIGN(width, 16) >> 4) * (
FFALIGN(height, 16) >> 4);
689 if (length < mbs * 8) {
695 for (y = 0; y <
height; y += 16) {
696 for (x = 0; x <
width; x += 16) {
699 color[0] = bytestream2_get_le16u(&g3);
700 color[1] = bytestream2_get_le16u(&g3);
702 if (color[0] & 0x8000)
704 if (color[1] & 0x8000)
707 color[2] =
mix(color[0], color[1]);
708 color[3] =
mix(color[1], color[0]);
710 bits = bytestream2_get_le32u(&g3);
711 for (y2 = 0; y2 < 16; y2++) {
712 for (x2 = 0; x2 < 16; x2++) {
713 int index = 2 * (x2 >> 2) + 8 * (y2 >> 2);
714 dst[y2 * width + x2] = color[(
bits >>
index) & 3];
719 dst += 16 * width - x;
730 const unsigned int bitstream_size =
AV_RL32(buf);
732 unsigned int prestream_size;
735 if (bitstream_size > (1 << 26))
738 if (length < bitstream_size + 12) {
743 token_count =
AV_RL32(buf + bitstream_size + 8);
744 prestream_size = 4 *
AV_RL32(buf + bitstream_size + 4);
745 prestream = buf + bitstream_size + 12;
747 if (prestream_size + bitstream_size + 12 != length
748 || prestream_size > (1 << 26)) {
750 prestream_size, bitstream_size, length);
762 prestream_size = length + buf - prestream;
776 for (y = 0; y <
height; y += 16) {
777 for (x = 0; x <
width; x += 16) {
795 int buf_size = avpkt->
size;
805 "Dimensions non-multiple of 16 are invalid.\n");
809 if (buf_size <
AV_RL32(buf + 4) + 8) {
817 if (frame_4cc ==
AV_RL32(
"cfrm")) {
820 const int data_size = buf_size - 20;
827 whole_size =
AV_RL32(buf + 16);
841 if (i >= CFRAME_BUFFER_COUNT) {
855 memcpy(cfrm->
data + cfrm->
size, buf + 20, data_size);
856 cfrm->
size += data_size;
858 if (cfrm->
size >= whole_size) {
860 frame_size = cfrm->
size;
869 cfrm->
size = cfrm->
id = 0;
875 frame_size = buf_size - 12;
884 if (frame_4cc ==
AV_RL32(
"ifr2")) {
888 }
else if (frame_4cc ==
AV_RL32(
"ifrm")) {
892 }
else if (frame_4cc ==
AV_RL32(
"pfrm") || frame_4cc ==
AV_RL32(
"pfr2")) {
896 }
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 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)
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.
#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.
#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. ...
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
av_cold void ff_bswapdsp_init(BswapDSPContext *c)
#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.
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.
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 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]
const uint8_t ff_zigzag_direct[64]
unsigned int bitstream_buffer_size
static av_cold int decode_end(AVCodecContext *avctx)
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
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=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;}elseif(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;elseac->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);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
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 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
#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 ...