27 #define BITSTREAM_READER_LE
45 #define MAX_INDEX (64 - 1)
51 #define ALPHA_VLC_BITS 5
65 16, 16, 19, 22, 26, 27, 29, 34,
66 16, 16, 22, 24, 27, 29, 34, 37,
67 19, 22, 26, 27, 29, 34, 34, 38,
68 22, 22, 26, 27, 29, 34, 37, 40,
69 22, 26, 27, 29, 32, 35, 40, 48,
70 26, 27, 29, 32, 35, 40, 48, 58,
71 26, 27, 29, 34, 38, 46, 56, 69,
72 27, 29, 35, 38, 46, 56, 69, 83
86 if (component == 0 || component == 3) {
128 for (y = 0; y < 8; y++) {
129 for (x = 0; x < 16; x++) {
130 last_alpha[x] -=
block[y * 16 + x];
132 memcpy(dest, last_alpha, 16);
141 const int *quant_matrix =
s->quant_matrix;
142 const uint8_t *scantable =
s->permutated_intra_scantable;
146 s->bdsp.clear_block(
block);
149 last_dc[component] -= dc_offset;
150 block[scantable[0]] = last_dc[component];
173 #if MIN_CACHE_BITS < 6 + 6 + 12
174 #error MIN_CACHE_BITS is too small for the escape code, add UPDATE_CACHE
191 s->idsp.idct_put(dest, linesize,
block);
198 int linesize_y =
frame->linesize[0] * line_stride;
199 int linesize_cb =
frame->linesize[1] * line_stride;
200 int linesize_cr =
frame->linesize[2] * line_stride;
204 if (
s->alpha_type != SHQ_NO_ALPHA)
205 linesize_a =
frame->linesize[3] * line_stride;
207 for (
int y = 0; y <
frame->height; y += 16 * line_stride) {
208 int last_dc[4] = { 1024, 1024, 1024, 1024 };
209 uint8_t *dest_y, *dest_cb, *dest_cr, *dest_a;
210 uint8_t last_alpha[16];
211 int x =
frame->width - 8;
213 dest_y =
frame->data[0] +
frame->linesize[0] * (y + field_number) + x;
214 if (
s->subsampling == SHQ_SUBSAMPLING_420) {
215 dest_cb =
frame->data[1] +
frame->linesize[1] * (y/2 + field_number) + x / 2;
216 dest_cr =
frame->data[2] +
frame->linesize[2] * (y/2 + field_number) + x / 2;
219 dest_cb =
frame->data[1] +
frame->linesize[1] * (y + field_number) + x / 2;
220 dest_cr =
frame->data[2] +
frame->linesize[2] * (y + field_number) + x / 2;
222 if (
s->alpha_type != SHQ_NO_ALPHA) {
223 memset(last_alpha, 255,
sizeof(last_alpha));
224 dest_a =
frame->data[3] +
frame->linesize[3] * (y + field_number) + x;
240 if (
s->subsampling != SHQ_SUBSAMPLING_420) {
247 if (
s->alpha_type == SHQ_RLE_ALPHA) {
253 }
else if (
s->alpha_type == SHQ_DCT_ALPHA) {
271 int ret, slice_number, slice_offsets[5];
272 int linesize_y =
frame->linesize[0] * line_stride;
273 int linesize_cb =
frame->linesize[1] * line_stride;
274 int linesize_cr =
frame->linesize[2] * line_stride;
278 if (
s->alpha_type != SHQ_NO_ALPHA)
279 linesize_a =
frame->linesize[3] * line_stride;
281 if (end < start || end - start < 3 || end > buf_size)
284 slice_offsets[0] = start;
285 slice_offsets[4] = end;
286 for (slice_number = 1; slice_number < 4; slice_number++) {
287 uint32_t last_offset, slice_len;
289 last_offset = slice_offsets[slice_number - 1];
290 slice_len =
AV_RL24(buf + last_offset);
291 slice_offsets[slice_number] = last_offset + slice_len;
293 if (slice_len < 3 || slice_offsets[slice_number] > end - 3)
297 for (slice_number = 0; slice_number < 4; slice_number++) {
301 slice_begin = slice_offsets[slice_number];
302 slice_end = slice_offsets[slice_number + 1];
307 for (y = slice_number * 16 * line_stride; y <
frame->height; y += line_stride * 64) {
308 uint8_t *dest_y, *dest_cb, *dest_cr, *dest_a;
309 int last_dc[4] = { 1024, 1024, 1024, 1024 };
310 uint8_t last_alpha[16];
312 memset(last_alpha, 255,
sizeof(last_alpha));
314 dest_y =
frame->data[0] +
frame->linesize[0] * (y + field_number);
315 if (
s->subsampling == SHQ_SUBSAMPLING_420) {
316 dest_cb =
frame->data[1] +
frame->linesize[1] * (y/2 + field_number);
317 dest_cr =
frame->data[2] +
frame->linesize[2] * (y/2 + field_number);
319 dest_cb =
frame->data[1] +
frame->linesize[1] * (y + field_number);
320 dest_cr =
frame->data[2] +
frame->linesize[2] * (y + field_number);
322 if (
s->alpha_type != SHQ_NO_ALPHA) {
323 dest_a =
frame->data[3] +
frame->linesize[3] * (y + field_number);
326 for (x = 0; x <
frame->width - 8 * (
s->subsampling != SHQ_SUBSAMPLING_444); x += 16) {
346 if (
s->subsampling != SHQ_SUBSAMPLING_420) {
353 if (
s->subsampling == SHQ_SUBSAMPLING_444) {
359 if ((
ret =
decode_dct_block(
s, &gb, last_dc, 1, dest_cb + 8 * linesize_cb + 8, linesize_cb)) < 0)
361 if ((
ret =
decode_dct_block(
s, &gb, last_dc, 2, dest_cr + 8 * linesize_cr + 8, linesize_cr)) < 0)
372 if (
s->alpha_type == SHQ_RLE_ALPHA) {
379 }
else if (
s->alpha_type == SHQ_DCT_ALPHA) {
395 if (
s->subsampling != SHQ_SUBSAMPLING_444 && (
frame->width & 15))
411 const uint8_t *buf = avpkt->
data;
412 int buf_size = avpkt->
size;
414 uint32_t second_field_offset;
417 if (buf_size < 4 || avctx->width < 8 || avctx->
width % 8 != 0)
419 if (buf_size < avctx->
width*avctx->
height / 64 / 4)
432 second_field_offset =
AV_RL24(buf + 1);
433 if (second_field_offset >= buf_size - 3) {
445 if (second_field_offset == 4 || second_field_offset == (buf_size-4)) {
475 uint16_t run_code[134], level_code[266];
476 uint8_t
run_bits[134], level_bits[266];
477 int16_t run_symbols[134], level_symbols[266];
486 run_symbols[
entry] = 0;
490 for (
i = 0;
i < 4; ++
i) {
491 run_code[
entry] = (
i << 2) | 1;
493 run_symbols[
entry] =
i + 1;
498 for (
i = 0;
i < 128; ++
i) {
499 run_code[
entry] = (
i << 3) | 7;
508 run_symbols[
entry] = -1;
522 for (sign = 0; sign <= 1; ++sign) {
524 level_code[
entry] = (sign << 1) | 1;
525 level_bits[
entry] = 2;
526 level_symbols[
entry] = sign ? -1 : 1;
530 for (
i = 0;
i < 4; ++
i) {
531 level_code[
entry] = (
i << 3) | (sign << 2) | 2;
532 level_bits[
entry] = 5;
533 level_symbols[
entry] = sign ? -(
i + 2) : (
i + 2);
544 for (
i = 0;
i < 256; ++
i) {
545 level_code[
entry] =
i << 2;
546 level_bits[
entry] = 10;
592 s->idsp.idct_permutation);
595 case MKTAG(
'S',
'H',
'Q',
'0'):
596 s->subsampling = SHQ_SUBSAMPLING_420;
597 s->alpha_type = SHQ_NO_ALPHA;
600 case MKTAG(
'S',
'H',
'Q',
'1'):
601 s->subsampling = SHQ_SUBSAMPLING_420;
602 s->alpha_type = SHQ_RLE_ALPHA;
605 case MKTAG(
'S',
'H',
'Q',
'2'):
606 s->subsampling = SHQ_SUBSAMPLING_422;
607 s->alpha_type = SHQ_NO_ALPHA;
610 case MKTAG(
'S',
'H',
'Q',
'3'):
611 s->subsampling = SHQ_SUBSAMPLING_422;
612 s->alpha_type = SHQ_RLE_ALPHA;
615 case MKTAG(
'S',
'H',
'Q',
'4'):
616 s->subsampling = SHQ_SUBSAMPLING_444;
617 s->alpha_type = SHQ_NO_ALPHA;
620 case MKTAG(
'S',
'H',
'Q',
'5'):
621 s->subsampling = SHQ_SUBSAMPLING_444;
622 s->alpha_type = SHQ_RLE_ALPHA;
625 case MKTAG(
'S',
'H',
'Q',
'7'):
626 s->subsampling = SHQ_SUBSAMPLING_422;
627 s->alpha_type = SHQ_DCT_ALPHA;
630 case MKTAG(
'S',
'H',
'Q',
'9'):
631 s->subsampling = SHQ_SUBSAMPLING_444;
632 s->alpha_type = SHQ_DCT_ALPHA;