42 #define BLOCK_TYPE_VLC_BITS 5
43 #define ACDC_VLC_BITS 9
45 #define CFRAME_BUFFER_COUNT 100
50 { 0, 1 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 30, 5 }, { 31, 5 }, { 0, 0 }
52 { 0, 1 }, { 0, 0 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 15, 4 }, { 0, 0 }
54 { 0, 1 }, { 2, 2 }, { 0, 0 }, { 6, 3 }, { 14, 4 }, { 15, 4 }, { 0, 0 }
56 { 0, 1 }, { 0, 0 }, { 0, 0 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 15, 4 }
60 { 1, 2 }, { 4, 3 }, { 5, 3 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
62 { 1, 2 }, { 0, 0 }, { 2, 2 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
64 { 1, 2 }, { 2, 2 }, { 0, 0 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
66 { 1, 2 }, { 0, 0 }, { 0, 0 }, { 0, 2 }, { 2, 2 }, { 6, 3 }, { 7, 3 }
78 static const int8_t
mv[256][2] = {
79 { 0, 0 }, { 0, -1 }, { -1, 0 }, { 1, 0 }, { 0, 1 }, { -1, -1 }, { 1, -1 }, { -1, 1 },
80 { 1, 1 }, { 0, -2 }, { -2, 0 }, { 2, 0 }, { 0, 2 }, { -1, -2 }, { 1, -2 }, { -2, -1 },
81 { 2, -1 }, { -2, 1 }, { 2, 1 }, { -1, 2 }, { 1, 2 }, { -2, -2 }, { 2, -2 }, { -2, 2 },
82 { 2, 2 }, { 0, -3 }, { -3, 0 }, { 3, 0 }, { 0, 3 }, { -1, -3 }, { 1, -3 }, { -3, -1 },
83 { 3, -1 }, { -3, 1 }, { 3, 1 }, { -1, 3 }, { 1, 3 }, { -2, -3 }, { 2, -3 }, { -3, -2 },
84 { 3, -2 }, { -3, 2 }, { 3, 2 }, { -2, 3 }, { 2, 3 }, { 0, -4 }, { -4, 0 }, { 4, 0 },
85 { 0, 4 }, { -1, -4 }, { 1, -4 }, { -4, -1 }, { 4, -1 }, { 4, 1 }, { -1, 4 }, { 1, 4 },
86 { -3, -3 }, { -3, 3 }, { 3, 3 }, { -2, -4 }, { -4, -2 }, { 4, -2 }, { -4, 2 }, { -2, 4 },
87 { 2, 4 }, { -3, -4 }, { 3, -4 }, { 4, -3 }, { -5, 0 }, { -4, 3 }, { -3, 4 }, { 3, 4 },
88 { -1, -5 }, { -5, -1 }, { -5, 1 }, { -1, 5 }, { -2, -5 }, { 2, -5 }, { 5, -2 }, { 5, 2 },
89 { -4, -4 }, { -4, 4 }, { -3, -5 }, { -5, -3 }, { -5, 3 }, { 3, 5 }, { -6, 0 }, { 0, 6 },
90 { -6, -1 }, { -6, 1 }, { 1, 6 }, { 2, -6 }, { -6, 2 }, { 2, 6 }, { -5, -4 }, { 5, 4 },
91 { 4, 5 }, { -6, -3 }, { 6, 3 }, { -7, 0 }, { -1, -7 }, { 5, -5 }, { -7, 1 }, { -1, 7 },
92 { 4, -6 }, { 6, 4 }, { -2, -7 }, { -7, 2 }, { -3, -7 }, { 7, -3 }, { 3, 7 }, { 6, -5 },
93 { 0, -8 }, { -1, -8 }, { -7, -4 }, { -8, 1 }, { 4, 7 }, { 2, -8 }, { -2, 8 }, { 6, 6 },
94 { -8, 3 }, { 5, -7 }, { -5, 7 }, { 8, -4 }, { 0, -9 }, { -9, -1 }, { 1, 9 }, { 7, -6 },
95 { -7, 6 }, { -5, -8 }, { -5, 8 }, { -9, 3 }, { 9, -4 }, { 7, -7 }, { 8, -6 }, { 6, 8 },
96 { 10, 1 }, { -10, 2 }, { 9, -5 }, { 10, -3 }, { -8, -7 }, { -10, -4 }, { 6, -9 }, { -11, 0 },
97 { 11, 1 }, { -11, -2 }, { -2, 11 }, { 7, -9 }, { -7, 9 }, { 10, 6 }, { -4, 11 }, { 8, -9 },
98 { 8, 9 }, { 5, 11 }, { 7, -10 }, { 12, -3 }, { 11, 6 }, { -9, -9 }, { 8, 10 }, { 5, 12 },
99 { -11, 7 }, { 13, 2 }, { 6, -12 }, { 10, 9 }, { -11, 8 }, { -7, 12 }, { 0, 14 }, { 14, -2 },
100 { -9, 11 }, { -6, 13 }, { -14, -4 }, { -5, -14 }, { 5, 14 }, { -15, -1 }, { -14, -6 }, { 3, -15 },
101 { 11, -11 }, { -7, 14 }, { -5, 15 }, { 8, -14 }, { 15, 6 }, { 3, 16 }, { 7, -15 }, { -16, 5 },
102 { 0, 17 }, { -16, -6 }, { -10, 14 }, { -16, 7 }, { 12, 13 }, { -16, 8 }, { -17, 6 }, { -18, 3 },
103 { -7, 17 }, { 15, 11 }, { 16, 10 }, { 2, -19 }, { 3, -19 }, { -11, -16 }, { -18, 8 }, { -19, -6 },
104 { 2, -20 }, { -17, -11 }, { -10, -18 }, { 8, 19 }, { -21, -1 }, { -20, 7 }, { -4, 21 }, { 21, 5 },
105 { 15, 16 }, { 2, -22 }, { -10, -20 }, { -22, 5 }, { 20, -11 }, { -7, -22 }, { -12, 20 }, { 23, -5 },
106 { 13, -20 }, { 24, -2 }, { -15, 19 }, { -11, 22 }, { 16, 19 }, { 23, -10 }, { -18, -18 }, { -9, -24 },
107 { 24, -10 }, { -3, 26 }, { -23, 13 }, { -18, -20 }, { 17, 21 }, { -4, 27 }, { 27, 6 }, { 1, -28 },
108 { -11, 26 }, { -17, -23 }, { 7, 28 }, { 11, -27 }, { 29, 5 }, { -23, -19 }, { -28, -11 }, { -21, 22 },
109 { -30, 7 }, { -17, 26 }, { -27, 16 }, { 13, 29 }, { 19, -26 }, { 10, -31 }, { -14, -30 }, { 20, -27 },
110 { -29, 18 }, { -16, -31 }, { -28, -22 }, { 21, -30 }, { -25, 28 }, { 26, -29 }, { 25, -32 }, { -32, -32 }
116 16, 15, 13, 19, 24, 31, 28, 17,
117 17, 23, 25, 31, 36, 63, 45, 21,
118 18, 24, 27, 37, 52, 59, 49, 20,
119 16, 28, 34, 40, 60, 80, 51, 20,
120 18, 31, 48, 66, 68, 86, 56, 21,
121 19, 38, 56, 59, 64, 64, 48, 20,
122 27, 48, 55, 55, 56, 51, 35, 15,
123 20, 35, 34, 32, 31, 22, 15, 8,
157 #define FIX_1_082392200 70936
158 #define FIX_1_414213562 92682
159 #define FIX_1_847759065 121095
160 #define FIX_2_613125930 171254
162 #define MULTIPLY(var, const) ((int)((var) * (unsigned)(const)) >> 16)
166 int tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
167 int tmp10, tmp11, tmp12, tmp13;
168 int z5, z10, z11, z12, z13;
172 for (
i = 0;
i < 8;
i++) {
179 tmp0 = tmp10 + tmp13;
180 tmp3 = tmp10 - tmp13;
181 tmp1 = tmp11 + tmp12;
182 tmp2 = tmp11 - tmp12;
200 temp[8 * 0 +
i] = tmp0 + tmp7;
201 temp[8 * 7 +
i] = tmp0 - tmp7;
202 temp[8 * 1 +
i] = tmp1 + tmp6;
203 temp[8 * 6 +
i] = tmp1 - tmp6;
204 temp[8 * 2 +
i] = tmp2 + tmp5;
205 temp[8 * 5 +
i] = tmp2 - tmp5;
206 temp[8 * 4 +
i] = tmp3 + tmp4;
207 temp[8 * 3 +
i] = tmp3 - tmp4;
210 for (
i = 0;
i < 8 * 8;
i += 8) {
217 tmp0 = tmp10 + tmp13;
218 tmp3 = tmp10 - tmp13;
219 tmp1 = tmp11 + tmp12;
220 tmp2 = tmp11 - tmp12;
238 block[0 +
i] = (tmp0 + tmp7) >> 6;
239 block[7 +
i] = (tmp0 - tmp7) >> 6;
240 block[1 +
i] = (tmp1 + tmp6) >> 6;
241 block[6 +
i] = (tmp1 - tmp6) >> 6;
242 block[2 +
i] = (tmp2 + tmp5) >> 6;
243 block[5 +
i] = (tmp2 - tmp5) >> 6;
244 block[4 +
i] = (tmp3 + tmp4) >> 6;
245 block[3 +
i] = (tmp3 - tmp4) >> 6;
254 for (
i = 0;
i < 2;
i++) {
255 for (j = 0; j < 4; j++) {
270 for (
i = 0;
i < 256;
i++) {
272 f->mv[
i] =
mv[
i][0] +
mv[
i][1] * linesize / 2;
274 f->mv[
i] = (
i & 15) - 8 + ((
i >> 4) - 8) * linesize / 2;
279 #define LE_CENTRIC_MUL(dst, src, scale, dc) \
281 unsigned tmpval = AV_RN32(src); \
282 tmpval = (tmpval << 16) | (tmpval >> 16); \
283 tmpval = tmpval * (scale) + (dc); \
284 tmpval = (tmpval << 16) | (tmpval >> 16); \
285 AV_WN32A(dst, tmpval); \
288 #define LE_CENTRIC_MUL(dst, src, scale, dc) \
290 unsigned tmpval = AV_RN32(src) * (scale) + (dc); \
291 AV_WN32A(dst, tmpval); \
295 static inline void mcdc(uint16_t *dst,
const uint16_t *
src,
int log2w,
296 int h,
int stride,
int scale,
unsigned dc)
303 for (
i = 0;
i <
h;
i++) {
304 dst[0] = scale *
src[0] +
dc;
311 for (
i = 0;
i <
h;
i++) {
319 for (
i = 0;
i <
h;
i++) {
328 for (
i = 0;
i <
h;
i++) {
344 int log2w,
int log2h,
int stride)
347 uint16_t *start, *end;
362 start =
f->last_frame_buffer;
363 end = start +
stride * (
f->avctx->height -
h + 1) - (1 << log2w);
372 }
else if (
code == 2) {
379 }
else if (
code == 6) {
385 dst[0] = bytestream2_get_le16u(&
f->g2);
386 dst[1] = bytestream2_get_le16u(&
f->g2);
388 dst[0] = bytestream2_get_le16u(&
f->g2);
389 dst[
stride] = bytestream2_get_le16u(&
f->g2);
400 src +=
f->mv[bytestream2_get_byte(&
f->g)];
401 }
else if (
code == 3 &&
f->version >= 2) {
403 }
else if (
code == 4) {
404 src +=
f->mv[bytestream2_get_byte(&
f->g)];
409 dc = bytestream2_get_le16(&
f->g2);
410 }
else if (
code == 5) {
417 dc = bytestream2_get_le16(&
f->g2);
420 if (start >
src ||
src > end) {
433 const int width =
f->avctx->width;
434 const int height =
f->avctx->height;
435 uint16_t *dst =
f->frame_buffer;
437 unsigned int bitstream_size, bytestream_size, wordstream_size, extra,
438 bytestream_offset, wordstream_offset;
441 src =
f->last_frame_buffer;
443 if (
f->version > 1) {
447 bitstream_size =
AV_RL32(buf + 8);
448 wordstream_size =
AV_RL32(buf + 12);
449 bytestream_size =
AV_RL32(buf + 16);
452 bitstream_size =
AV_RL16(buf - 4);
453 wordstream_size =
AV_RL16(buf - 2);
454 bytestream_size =
FFMAX(length - bitstream_size - wordstream_size, 0);
457 if (bitstream_size > length || bitstream_size >= INT_MAX/8 ||
458 bytestream_size > length - bitstream_size ||
459 wordstream_size > length - bytestream_size - bitstream_size ||
460 extra > length - bytestream_size - bitstream_size - wordstream_size) {
461 av_log(
f->avctx,
AV_LOG_ERROR,
"lengths %d %d %d %d\n", bitstream_size, bytestream_size, wordstream_size,
462 bitstream_size+ bytestream_size+ wordstream_size - length);
468 if (!
f->bitstream_buffer)
470 f->bbdsp.bswap_buf(
f->bitstream_buffer, (
const uint32_t *) (buf + extra),
474 wordstream_offset = extra + bitstream_size;
475 bytestream_offset = extra + bitstream_size + wordstream_size;
477 length - wordstream_offset);
479 length - bytestream_offset);
483 for (y = 0; y <
height; y += 8) {
484 for (x = 0; x <
width; x += 8)
559 int16_t (*
block)[64] =
f->block;
562 uint16_t *dst =
f->frame_buffer + y *
stride + x;
564 for (
i = 0;
i < 4;
i++) {
565 block[
i][0] += 0x80 * 8 * 8;
570 for (
i = 4;
i < 6;
i++)
578 for (y = 0; y < 8; y++) {
579 for (x = 0; x < 8; x++) {
580 int16_t *
temp =
block[(x >> 2) + 2 * (y >> 2)] +
581 2 * (x & 3) + 2 * 8 * (y & 3);
584 int cg = (
cb +
cr) >> 1;
590 dst[0] = ((y +
cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y +
cr) & 0xF8) << 8);
592 dst[1] = ((y +
cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y +
cr) & 0xF8) << 8);
594 dst[
stride] = ((y +
cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y +
cr) & 0xF8) << 8);
596 dst[1 +
stride] = ((y +
cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y +
cr) & 0xF8) << 8);
599 dst += 2 *
stride - 2 * 8;
608 f->bdsp.clear_blocks(
f->block[0]);
610 for (
i = 0;
i < 6;
i++)
621 int frequency[512] = { 0 };
628 const uint8_t *ptr_end = buf + buf_size;
631 memset(up, -1,
sizeof(up));
638 if (ptr_end - ptr <
FFMAX(end - start + 1, 0) + 1) {
643 for (
i = start;
i <= end;
i++)
644 frequency[
i] = *ptr++;
653 while ((ptr - buf) & 3)
661 for (j = 257; j < 512; j++) {
662 int min_freq[2] = { 256 * 256, 256 * 256 };
663 int smallest[2] = { 0, 0 };
665 for (
i = 0;
i < j;
i++) {
666 if (frequency[
i] == 0)
668 if (frequency[
i] < min_freq[1]) {
669 if (frequency[
i] < min_freq[0]) {
670 min_freq[1] = min_freq[0];
671 smallest[1] = smallest[0];
672 min_freq[0] = frequency[
i];
675 min_freq[1] = frequency[
i];
680 if (min_freq[1] == 256 * 256)
683 frequency[j] = min_freq[0] + min_freq[1];
684 flag[smallest[0]] = 0;
685 flag[smallest[1]] = 1;
688 frequency[smallest[0]] = frequency[smallest[1]] = 0;
691 for (j = 0; j < 257; j++) {
694 for (node = j; up[node] != -1; node = up[node]) {
700 "vlc length overflow\n");
717 int blue = 2 * (c0 & 0x001F) + (
c1 & 0x001F);
718 int green = (2 * (c0 & 0x03E0) + (
c1 & 0x03E0)) >> 5;
719 int red = 2 * (c0 >> 10) + (
c1 >> 10);
720 return red / 3 * 1024 + green / 3 * 32 + blue / 3;
726 const int width =
f->avctx->width;
727 const int height =
f->avctx->height;
729 uint16_t *dst =
f->frame_buffer;
730 const uint8_t *buf_end = buf + length;
733 if (length < mbs * 8) {
739 for (y = 0; y <
height; y += 16) {
740 for (x = 0; x <
width; x += 16) {
742 if (buf_end - buf < 8)
745 color[0] = bytestream2_get_le16u(&g3);
746 color[1] = bytestream2_get_le16u(&g3);
748 if (
color[0] & 0x8000)
750 if (
color[1] & 0x8000)
756 bits = bytestream2_get_le32u(&g3);
757 for (y2 = 0; y2 < 16; y2++) {
758 for (x2 = 0; x2 < 16; x2++) {
759 int index = 2 * (x2 >> 2) + 8 * (y2 >> 2);
765 dst += 16 *
width - x;
774 const int width =
f->avctx->width;
775 const int height =
f->avctx->height;
776 const unsigned int bitstream_size =
AV_RL32(buf);
777 unsigned int prestream_size;
780 if (bitstream_size > (1 << 26))
783 if (length < bitstream_size + 12) {
788 prestream_size = 4 *
AV_RL32(buf + bitstream_size + 4);
789 prestream = buf + bitstream_size + 12;
791 if (prestream_size + bitstream_size + 12 != length
792 || prestream_size > (1 << 26)) {
794 prestream_size, bitstream_size, length);
808 prestream_size = length + buf - prestream;
812 if (!
f->bitstream_buffer)
814 f->bbdsp.bswap_buf(
f->bitstream_buffer, (
const uint32_t *) prestream,
818 f->last_dc = 0 * 128 * 8 * 8;
820 for (y = 0; y <
height; y += 16) {
821 for (x = 0; x <
width; x += 16) {
839 int buf_size = avpkt->
size;
849 if (buf_size <
AV_RL32(buf + 4) + 8) {
857 if (frame_4cc ==
AV_RL32(
"cfrm")) {
860 const int data_size = buf_size - 20;
863 if (
f->version <= 1) {
869 whole_size =
AV_RL32(buf + 16);
871 if (data_size < 0 || whole_size < 0) {
882 if (
f->cfrm[
i].id ==
id)
884 if (
f->cfrm[
i].size == 0)
905 memcpy(cfrm->
data + cfrm->
size, buf + 20, data_size);
906 cfrm->
size += data_size;
908 if (cfrm->
size >= whole_size) {
919 cfrm->
size = cfrm->
id = 0;
931 if (frame_4cc ==
AV_RL32(
"ifr2")) {
937 }
else if (frame_4cc ==
AV_RL32(
"ifrm")) {
943 }
else if (frame_4cc ==
AV_RL32(
"pfrm") || frame_4cc ==
AV_RL32(
"pfr2")) {
949 }
else if (frame_4cc ==
AV_RL32(
"snd_")) {
962 FFSWAP(uint16_t *,
f->frame_buffer,
f->last_frame_buffer);
979 f->bitstream_buffer_size = 0;
982 f->cfrm[
i].allocated_size = 0;
1009 if (!
f->frame_buffer || !
f->last_frame_buffer) {
static double val(void *priv, double ch)
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)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> dc
simple assert() macros that are a bit more flexible than ISO C assert().
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Libavcodec external API header.
static av_cold int init(AVCodecContext *avctx)
void ff_free_vlc(VLC *vlc)
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
#define FFSWAP(type, a, b)
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
reference-counted frame API
bitstream reader API header.
static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)
Parse a vlc code.
static int get_bits_left(GetBitContext *gb)
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
static int get_xbits(GetBitContext *s, int n)
Read MPEG-1 dc-style VLC (sign bit + mantissa with no MSB).
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding.
void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size)
Same behaviour av_fast_malloc but the buffer has additional AV_INPUT_BUFFER_PADDING_SIZE at the end w...
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
void * av_fast_realloc(void *ptr, unsigned int *size, size_t min_size)
Reallocate the given buffer if it is not large enough, otherwise do nothing.
#define DECLARE_ALIGNED(n, t, v)
Declare a variable that is aligned in memory.
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...
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.
@ AV_PICTURE_TYPE_I
Intra.
@ AV_PICTURE_TYPE_P
Predicted.
static const int8_t mv[256][2]
static void idct_put(FourXContext *f, int x, int y)
static const uint8_t * read_huffman_tables(FourXContext *f, const uint8_t *const buf, int buf_size)
static void init_mv(FourXContext *f, int linesize)
static int decode_i_frame(FourXContext *f, const uint8_t *buf, int length)
static const uint8_t dequant_table[64]
static int decode_p_frame(FourXContext *f, const uint8_t *buf, int length)
static int decode_p_block(FourXContext *f, uint16_t *dst, const uint16_t *src, int log2w, int log2h, int stride)
AVCodec ff_fourxm_decoder
static av_cold int decode_init(AVCodecContext *avctx)
static const uint8_t block_type_tab[2][4][8][2]
static void idct(int16_t block[64])
static int decode_i_block(FourXContext *f, int16_t *block)
decode block and dequantize.
static int mix(int c0, int c1)
static av_cold int decode_end(AVCodecContext *avctx)
#define CFRAME_BUFFER_COUNT
static const uint8_t size2index[4][4]
#define MULTIPLY(var, const)
static int decode_i_mb(FourXContext *f)
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
static int decode_i2_frame(FourXContext *f, const uint8_t *buf, int length)
static VLC block_type_vlc[2][4]
static av_cold void init_vlcs(FourXContext *f)
#define LE_CENTRIC_MUL(dst, src, scale, dc)
static void mcdc(uint16_t *dst, const uint16_t *src, int log2w, int h, int stride, int scale, unsigned dc)
#define BLOCK_TYPE_VLC_BITS
av_cold void ff_blockdsp_init(BlockDSPContext *c, AVCodecContext *avctx)
av_cold void ff_bswapdsp_init(BswapDSPContext *c)
common internal API header
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
const uint8_t ff_zigzag_direct[64]
#define AV_PIX_FMT_BGR555
#define AV_PIX_FMT_RGB565
static const uint16_t table[]
main external API structure.
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
int width
picture width / height.
int frame_number
Frame counter, set by libavcodec.
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
const char * name
Name of the codec implementation.
This structure describes decoded (raw) audio or video data.
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
int key_frame
1 -> keyframe, 0-> not
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
enum AVPictureType pict_type
Picture type of the frame.
This structure stores compressed data.
unsigned int allocated_size
CFrameBuffer cfrm[CFRAME_BUFFER_COUNT]
uint16_t * last_frame_buffer
GetBitContext pre_gb
ac/dc prefix
unsigned int bitstream_buffer_size
VLC_TYPE(* table)[2]
code, bits
static double cr(void *priv, double x, double y)
static double cb(void *priv, double x, double y)
#define init_vlc(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size, codes, codes_wrap, codes_size, flags)
#define INIT_VLC_USE_NEW_STATIC