33 #define UNCHECKED_BITSTREAM_READER 1
35 #include "config_components.h"
86 #define classic_shift_luma_table_size 42
88 34, 36, 35, 69, 135, 232, 9, 16, 10, 24, 11, 23, 12, 16, 13, 10,
89 14, 8, 15, 8, 16, 8, 17, 20, 16, 10, 207, 206, 205, 236, 11, 8,
90 10, 21, 9, 23, 8, 8, 199, 70, 69, 68, 0,
94 #define classic_shift_chroma_table_size 59
96 66, 36, 37, 38, 39, 40, 41, 75, 76, 77, 110, 239, 144, 81, 82, 83,
97 84, 85, 118, 183, 56, 57, 88, 89, 56, 89, 154, 57, 58, 57, 26, 141,
98 57, 56, 58, 57, 58, 57, 184, 119, 214, 245, 116, 83, 82, 49, 80, 79,
99 78, 77, 44, 75, 41, 40, 39, 38, 37, 36, 34, 0,
104 3, 9, 5, 12, 10, 35, 32, 29, 27, 50, 48, 45, 44, 41, 39, 37,
105 73, 70, 68, 65, 64, 61, 58, 56, 53, 50, 49, 46, 44, 41, 38, 36,
106 68, 65, 63, 61, 58, 55, 53, 51, 48, 46, 45, 43, 41, 39, 38, 36,
107 35, 33, 32, 30, 29, 27, 26, 25, 48, 47, 46, 44, 43, 41, 40, 39,
108 37, 36, 35, 34, 32, 31, 30, 28, 27, 26, 24, 23, 22, 20, 19, 37,
109 35, 34, 33, 31, 30, 29, 27, 26, 24, 23, 21, 20, 18, 17, 15, 29,
110 27, 26, 24, 22, 21, 19, 17, 16, 14, 26, 25, 23, 21, 19, 18, 16,
111 15, 27, 25, 23, 21, 19, 17, 16, 14, 26, 25, 23, 21, 18, 17, 14,
112 12, 17, 19, 13, 4, 9, 2, 11, 1, 7, 8, 0, 16, 3, 14, 6,
113 12, 10, 5, 15, 18, 11, 10, 13, 15, 16, 19, 20, 22, 24, 27, 15,
114 18, 20, 22, 24, 26, 14, 17, 20, 22, 24, 27, 15, 18, 20, 23, 25,
115 28, 16, 19, 22, 25, 28, 32, 36, 21, 25, 29, 33, 38, 42, 45, 49,
116 28, 31, 34, 37, 40, 42, 44, 47, 49, 50, 52, 54, 56, 57, 59, 60,
117 62, 64, 66, 67, 69, 35, 37, 39, 40, 42, 43, 45, 47, 48, 51, 52,
118 54, 55, 57, 59, 60, 62, 63, 66, 67, 69, 71, 72, 38, 40, 42, 43,
119 46, 47, 49, 51, 26, 28, 30, 31, 33, 34, 18, 19, 11, 13, 7, 8,
123 3, 1, 2, 2, 2, 2, 3, 3, 7, 5, 7, 5, 8, 6, 11, 9,
124 7, 13, 11, 10, 9, 8, 7, 5, 9, 7, 6, 4, 7, 5, 8, 7,
125 11, 8, 13, 11, 19, 15, 22, 23, 20, 33, 32, 28, 27, 29, 51, 77,
126 43, 45, 76, 81, 46, 82, 75, 55, 56, 144, 58, 80, 60, 74, 147, 63,
127 143, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
128 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 27, 30, 21, 22,
129 17, 14, 5, 6, 100, 54, 47, 50, 51, 53, 106, 107, 108, 109, 110, 111,
130 112, 113, 114, 115, 4, 117, 118, 92, 94, 121, 122, 3, 124, 103, 2, 1,
131 0, 129, 130, 131, 120, 119, 126, 125, 136, 137, 138, 139, 140, 141, 142, 134,
132 135, 132, 133, 104, 64, 101, 62, 57, 102, 95, 93, 59, 61, 28, 97, 96,
133 52, 49, 48, 29, 32, 25, 24, 46, 23, 98, 45, 44, 43, 20, 42, 41,
134 19, 18, 99, 40, 15, 39, 38, 16, 13, 12, 11, 37, 10, 9, 8, 36,
135 7, 128, 127, 105, 123, 116, 35, 34, 33, 145, 31, 79, 42, 146, 78, 26,
136 83, 48, 49, 50, 44, 47, 26, 31, 30, 18, 17, 19, 21, 24, 25, 13,
137 14, 16, 17, 18, 20, 21, 12, 14, 15, 9, 10, 6, 9, 6, 5, 8,
138 6, 12, 8, 10, 7, 9, 6, 4, 6, 2, 2, 3, 3, 3, 3, 2,
145 for (
i = 0;
i < n;) {
171 if (
s->bitstream_bpp < 24 ||
s->version > 2) {
172 int count = 1 +
s->alpha + 2 *
s->chroma;
174 for (p = 0; p < count; p++) {
175 int p0 =
s->version > 2 ? p : 0;
176 for (
i = y = 0; y <
s->vlc_n; y++) {
177 int len0 =
s->len[p0][y];
179 if (
limit <= 0 || !len0)
183 for (
u = 0;
u <
s->vlc_n;
u++) {
184 int len1 =
s->len[p][
u];
185 if (len1 >
limit || !len1)
190 len[
i] = len0 + len1;
191 bits[
i] = (
s->bits[p0][y] << len1) +
s->bits[p][
u];
192 symbols[
i] = (y << 8) + (
u & 0xFF);
198 bits, 2, 2, symbols, 2, 2, 0)) < 0)
202 uint8_t (*
map)[4] = (uint8_t(*)[4])
s->pix_bgr_map;
204 int p0 =
s->decorrelate;
205 int p1 = !
s->decorrelate;
209 for (
i = 0,
g = -16;
g < 16;
g++) {
210 int len0 =
s->len[p0][
g & 255];
212 if (limit0 < 2 || !len0)
214 for (
b = -16;
b < 16;
b++) {
215 int len1 =
s->len[p1][
b & 255];
216 int limit1 = limit0 - len1;
217 if (limit1 < 1 || !len1)
219 code = (
s->bits[p0][
g & 255] << len1) +
s->bits[p1][
b & 255];
220 for (
r = -16;
r < 16;
r++) {
221 int len2 =
s->len[2][
r & 255];
222 if (len2 > limit1 || !len2)
225 len[
i] = len0 + len1 + len2;
227 if (
s->decorrelate) {
261 count = 1 +
s->alpha + 2*
s->chroma;
263 for (
i = 0;
i < count;
i++) {
270 s->bits[
i], 4, 4, 0)) < 0)
295 for (
i = 0;
i < 256;
i++)
300 if (
s->bitstream_bpp >= 24) {
301 memcpy(
s->bits[1],
s->bits[0], 256 *
sizeof(uint32_t));
302 memcpy(
s->len[1],
s->len[0], 256 *
sizeof(uint8_t));
304 memcpy(
s->bits[2],
s->bits[1], 256 *
sizeof(uint32_t));
305 memcpy(
s->len[2],
s->len[1], 256 *
sizeof(uint8_t));
307 for (
i = 0;
i < 4;
i++) {
310 s->bits[
i], 4, 4, 0)) < 0)
328 for (
i = 0;
i < 8;
i++)
348 memset(
s->vlc, 0, 4 *
sizeof(
VLC));
350 s->interlaced = avctx->
height > 288;
368 if (
s->version >= 2) {
369 int method, interlace;
375 s->decorrelate = method & 64 ? 1 : 0;
376 s->predictor = method & 63;
377 if (
s->version == 2) {
379 if (
s->bitstream_bpp == 0)
386 s->chroma_v_shift = (avctx->
extradata[1] >> 2) & 3;
391 interlace = (avctx->
extradata[2] & 0x30) >> 4;
392 s->interlaced = (interlace == 1) ? 1 : (interlace == 2) ? 0 :
s->interlaced;
393 s->context = avctx->
extradata[2] & 0x40 ? 1 : 0;
428 if (
s->version <= 2) {
429 switch (
s->bitstream_bpp) {
459 switch ( (
s->chroma<<10) | (
s->yuv<<9) | (
s->alpha<<8) | ((
s->bps-1)<<4) |
s->chroma_h_shift | (
s->chroma_v_shift<<2)) {
598 "for this combination of colorspace and predictor type.\n");
609 #define VLC_INTERN(dst, table, gb, name, bits, max_depth) \
610 code = table[index].sym; \
611 n = table[index].len; \
612 if (max_depth > 1 && n < 0) { \
613 LAST_SKIP_BITS(name, gb, bits); \
614 UPDATE_CACHE(name, gb); \
617 index = SHOW_UBITS(name, gb, nb_bits) + code; \
618 code = table[index].sym; \
619 n = table[index].len; \
620 if (max_depth > 2 && n < 0) { \
621 LAST_SKIP_BITS(name, gb, nb_bits); \
622 UPDATE_CACHE(name, gb); \
625 index = SHOW_UBITS(name, gb, nb_bits) + code; \
626 code = table[index].sym; \
627 n = table[index].len; \
631 LAST_SKIP_BITS(name, gb, n)
634 #define GET_VLC_DUAL(dst0, dst1, name, gb, dtable, table1, table2, \
635 bits, max_depth, OP) \
637 unsigned int index = SHOW_UBITS(name, gb, bits); \
638 int code, n = dtable[index].len; \
642 VLC_INTERN(dst0, table1, gb, name, bits, max_depth); \
644 UPDATE_CACHE(re, gb); \
645 index = SHOW_UBITS(name, gb, bits); \
646 VLC_INTERN(dst1, table2, gb, name, bits, max_depth); \
648 code = dtable[index].sym; \
649 OP(dst0, dst1, code); \
650 LAST_SKIP_BITS(name, gb, n); \
654 #define OP8bits(dst0, dst1, code) dst0 = code>>8; dst1 = code
656 #define READ_2PIX(dst0, dst1, plane1) \
657 UPDATE_CACHE(re, &s->gb); \
658 GET_VLC_DUAL(dst0, dst1, re, &s->gb, s->vlc[4+plane1].table, \
659 s->vlc[0].table, s->vlc[plane1].table, VLC_BITS, 3, OP8bits)
668 if (count >= icount) {
669 for (
i = 0;
i < icount;
i++) {
678 for (;
i < count;
i++)
679 s->temp[0][2 *
i ] =
s->temp[1][
i] =
680 s->temp[0][2 *
i + 1] =
s->temp[2][
i] = 0;
682 for (
i = 0;
i < count;
i++) {
690 #define READ_2PIX_PLANE(dst0, dst1, plane, OP) \
691 UPDATE_CACHE(re, &s->gb); \
692 GET_VLC_DUAL(dst0, dst1, re, &s->gb, s->vlc[4+plane].table, \
693 s->vlc[plane].table, s->vlc[plane].table, VLC_BITS, 3, OP)
695 #define OP14bits(dst0, dst1, code) dst0 = code>>8; dst1 = sign_extend(code, 8)
699 #define READ_2PIX_PLANE16(dst0, dst1, plane){\
700 dst0 = get_vlc2(&s->gb, s->vlc[plane].table, VLC_BITS, 3)*4;\
701 dst0 += get_bits(&s->gb, 2);\
702 dst1 = get_vlc2(&s->gb, s->vlc[plane].table, VLC_BITS, 3)*4;\
703 dst1 += get_bits(&s->gb, 2);\
716 for(
i=0;
i<count;
i++){
722 int nb_bits,
code, n;
729 }
else if (
s->bps <= 14) {
736 for(
i=0;
i<count;
i++){
742 int nb_bits,
code, n;
755 for(
i=0;
i<count;
i++){
777 for (
i = 0;
i < count;
i++) {
792 int code, n, nb_bits;
796 n =
s->vlc[4].table[
index].len;
800 *(uint32_t *) &
s->temp[0][4 *
i] =
s->pix_bgr_map[
code];
810 s->temp[0][4 *
i +
B] =
code +
s->temp[0][4 *
i +
G];
815 s->temp[0][4 *
i +
R] =
code +
s->temp[0][4 *
i +
G];
837 s->temp[0][4 *
i +
A] = 0;
844 if (
s->decorrelate) {
845 if (
s->bitstream_bpp == 24)
850 if (
s->bitstream_bpp == 24)
865 h = y -
s->last_slice_end;
868 if (
s->bitstream_bpp == 12)
882 s->last_slice_end = y +
h;
888 return s->llviddsp.add_left_pred(dst,
src,
w,
acc);
890 return s->llviddsp.add_left_pred_int16(( uint16_t *)dst, (
const uint16_t *)
src,
s->n-1,
w,
acc);
897 s->llviddsp.add_bytes(dst,
src,
w);
899 s->hdsp.add_int16((uint16_t*)dst, (
const uint16_t*)
src,
s->n - 1,
w);
906 s->llviddsp.add_median_pred(dst,
src,
diff,
w,
left, left_top);
908 s->hdsp.add_hfyu_median_pred_int16((uint16_t *)dst, (
const uint16_t *)
src, (
const uint16_t *)
diff,
s->n-1,
w,
left, left_top);
913 int buf_size,
int y_offset,
int table_size)
916 int fake_ystride, fake_ustride, fake_vstride;
918 const int width2 = avctx->
width >> 1;
921 if ((
ret =
init_get_bits8(&
s->gb,
s->bitstream_buffer + table_size, buf_size - table_size)) < 0)
928 if (
s->version > 2) {
930 for(plane = 0; plane < 1 + 2*
s->chroma +
s->alpha; plane++) {
931 int left, lefttop, y;
934 int fake_stride = fake_ystride;
936 if (
s->chroma && (plane == 1 || plane == 2)) {
937 w >>=
s->chroma_h_shift;
938 h >>=
s->chroma_v_shift;
939 fake_stride = plane == 1 ? fake_ustride : fake_vstride;
942 switch (
s->predictor) {
948 for (y = 1; y <
h; y++) {
953 if (
s->predictor ==
PLANE) {
954 if (y >
s->interlaced) {
978 lefttop = p->
data[plane][0];
997 }
else if (
s->bitstream_bpp < 24) {
999 int lefty, leftu, leftv;
1000 int lefttopy, lefttopu, lefttopv;
1009 "YUY2 output is not implemented yet\n");
1020 switch (
s->predictor) {
1024 lefty =
s->llviddsp.add_left_pred(p->
data[0] + p->
linesize[0] * y_offset + 2,
s->temp[0],
1027 leftu =
s->llviddsp.add_left_pred(p->
data[1] + p->
linesize[1] * y_offset + 1,
s->temp[1], width2 - 1, leftu);
1028 leftv =
s->llviddsp.add_left_pred(p->
data[2] + p->
linesize[2] * y_offset + 1,
s->temp[2], width2 - 1, leftv);
1031 for (cy = y = 1; y <
height; y++, cy++) {
1032 uint8_t *ydst, *udst, *vdst;
1034 if (
s->bitstream_bpp == 12) {
1039 lefty =
s->llviddsp.add_left_pred(ydst,
s->temp[0],
1041 if (
s->predictor ==
PLANE) {
1042 if (y >
s->interlaced)
1043 s->llviddsp.add_bytes(ydst, ydst - fake_ystride,
width);
1057 lefty =
s->llviddsp.add_left_pred(ydst,
s->temp[0],
1060 leftu =
s->llviddsp.add_left_pred(udst,
s->temp[1], width2, leftu);
1061 leftv =
s->llviddsp.add_left_pred(vdst,
s->temp[2], width2, leftv);
1063 if (
s->predictor ==
PLANE) {
1064 if (cy >
s->interlaced) {
1065 s->llviddsp.add_bytes(ydst, ydst - fake_ystride,
width);
1067 s->llviddsp.add_bytes(udst, udst - fake_ustride, width2);
1068 s->llviddsp.add_bytes(vdst, vdst - fake_vstride, width2);
1079 lefty =
s->llviddsp.add_left_pred(p->
data[0] + 2,
s->temp[0],
1082 leftu =
s->llviddsp.add_left_pred(p->
data[1] + 1,
s->temp[1], width2 - 1, leftu);
1083 leftv =
s->llviddsp.add_left_pred(p->
data[2] + 1,
s->temp[2], width2 - 1, leftv);
1091 if (
s->interlaced) {
1093 lefty =
s->llviddsp.add_left_pred(p->
data[0] + p->
linesize[0],
1094 s->temp[0],
width, lefty);
1096 leftu =
s->llviddsp.add_left_pred(p->
data[1] + p->
linesize[2],
s->temp[1], width2, leftu);
1097 leftv =
s->llviddsp.add_left_pred(p->
data[2] + p->
linesize[1],
s->temp[2], width2, leftv);
1107 lefty =
s->llviddsp.add_left_pred(p->
data[0] + fake_ystride,
1108 s->temp[0], 4, lefty);
1110 leftu =
s->llviddsp.add_left_pred(p->
data[1] + fake_ustride,
s->temp[1], 2, leftu);
1111 leftv =
s->llviddsp.add_left_pred(p->
data[2] + fake_vstride,
s->temp[2], 2, leftv);
1115 lefttopy = p->
data[0][3];
1117 s->llviddsp.add_median_pred(p->
data[0] + fake_ystride + 4,
1118 p->
data[0] + 4,
s->temp[0],
1119 width - 4, &lefty, &lefttopy);
1121 lefttopu = p->
data[1][1];
1122 lefttopv = p->
data[2][1];
1123 s->llviddsp.add_median_pred(p->
data[1] + fake_ustride + 2, p->
data[1] + 2,
s->temp[1], width2 - 2, &leftu, &lefttopu);
1124 s->llviddsp.add_median_pred(p->
data[2] + fake_vstride + 2, p->
data[2] + 2,
s->temp[2], width2 - 2, &leftv, &lefttopv);
1129 for (; y <
height; y++, cy++) {
1130 uint8_t *ydst, *udst, *vdst;
1132 if (
s->bitstream_bpp == 12) {
1133 while (2 * cy > y) {
1136 s->llviddsp.add_median_pred(ydst, ydst - fake_ystride,
1152 s->llviddsp.add_median_pred(ydst, ydst - fake_ystride,
1156 s->llviddsp.add_median_pred(udst, udst - fake_ustride,
s->temp[1], width2, &leftu, &lefttopu);
1157 s->llviddsp.add_median_pred(vdst, vdst - fake_vstride,
s->temp[2], width2, &leftv, &lefttopv);
1170 if (
s->bitstream_bpp == 32) {
1184 switch (
s->predictor) {
1188 s->hdsp.add_hfyu_left_pred_bgr32(p->
data[0] + last_line + 4,
1191 for (y =
height - 2; y >= 0; y--) {
1194 s->hdsp.add_hfyu_left_pred_bgr32(p->
data[0] + p->
linesize[0] * (y + y_offset),
1196 if (
s->predictor ==
PLANE) {
1197 if (
s->bitstream_bpp != 32)
1200 s->llviddsp.add_bytes(p->
data[0] + p->
linesize[0] * (y + y_offset),
1202 fake_ystride, 4 *
width);
1211 "prediction type not supported!\n");
1215 "BGR24 output is not implemented yet\n");
1226 const uint8_t *buf = avpkt->
data;
1227 int buf_size = avpkt->
size;
1231 int slice, table_size = 0,
ret, nb_slices;
1232 unsigned slices_info_offset;
1239 &
s->bitstream_buffer_size,
1241 if (!
s->bitstream_buffer)
1244 s->bdsp.bswap_buf((uint32_t *)
s->bitstream_buffer,
1245 (
const uint32_t *) buf, buf_size / 4);
1256 if ((
unsigned) (buf_size - table_size) >= INT_MAX / 8)
1259 s->last_slice_end = 0;
1262 (buf_size > 32 &&
AV_RL32(avpkt->
data + buf_size - 16) == 0)) {
1263 slices_info_offset =
AV_RL32(avpkt->
data + buf_size - 4);
1264 slice_height =
AV_RL32(avpkt->
data + buf_size - 8);
1266 if (nb_slices * 8LL + slices_info_offset > buf_size - 16 ||
1267 s->chroma_v_shift ||
1268 slice_height <= 0 || nb_slices * (uint64_t)slice_height >
height)
1275 for (slice = 0; slice < nb_slices; slice++) {
1276 int y_offset, slice_offset, slice_size;
1278 if (nb_slices > 1) {
1279 slice_offset =
AV_RL32(avpkt->
data + slices_info_offset + slice * 8);
1280 slice_size =
AV_RL32(avpkt->
data + slices_info_offset + slice * 8 + 4);
1282 if (slice_offset < 0 || slice_size <= 0 || (slice_offset&3) ||
1283 slice_offset + (int64_t)slice_size > buf_size)
1286 y_offset =
height - (slice + 1) * slice_height;
1287 s->bdsp.bswap_buf((uint32_t *)
s->bitstream_buffer,
1288 (
const uint32_t *)(buf + slice_offset), slice_size / 4);
1292 slice_size = buf_size;
1295 ret =
decode_slice(avctx, p, slice_height, slice_size, y_offset, table_size);
1307 .
p.
name =
"huffyuv",
1320 #if CONFIG_FFVHUFF_DECODER
1322 .
p.
name =
"ffvhuff",
1336 #if CONFIG_HYMT_DECODER