27 #define BITSTREAM_READER_LE
42 #define MAX_INDEX (64 - 1)
48 #define ALPHA_VLC_BITS 5
64 {0x0001, 2}, {0x0003, 3}, {0x000E, 4}, {0x0007, 5},
65 {0x0017, 5}, {0x0028, 6}, {0x0008, 6}, {0x006F, 7},
66 {0x001F, 7}, {0x00C4, 8}, {0x0044, 8}, {0x005F, 8},
67 {0x00DF, 8}, {0x007F, 8}, {0x00FF, 8}, {0x3E00, 14},
68 {0x1E00, 14}, {0x2E00, 14}, {0x0E00, 14}, {0x3600, 14},
69 {0x1600, 14}, {0x2600, 14}, {0x0600, 14}, {0x3A00, 14},
70 {0x1A00, 14}, {0x2A00, 14}, {0x0A00, 14}, {0x3200, 14},
71 {0x1200, 14}, {0x2200, 14}, {0x0200, 14}, {0x0C00, 15},
72 {0x7400, 15}, {0x3400, 15}, {0x5400, 15}, {0x1400, 15},
73 {0x6400, 15}, {0x2400, 15}, {0x4400, 15}, {0x0400, 15},
74 {0x0002, 3}, {0x000C, 5}, {0x004F, 7}, {0x00E4, 8},
75 {0x0004, 8}, {0x0D00, 13}, {0x1500, 13}, {0x7C00, 15},
76 {0x3C00, 15}, {0x5C00, 15}, {0x1C00, 15}, {0x6C00, 15},
77 {0x2C00, 15}, {0x4C00, 15}, {0xC800, 16}, {0x4800, 16},
78 {0x8800, 16}, {0x0800, 16}, {0x0300, 13}, {0x1D00, 13},
79 {0x0014, 5}, {0x0070, 7}, {0x003F, 8}, {0x00C0, 10},
80 {0x0500, 13}, {0x0180, 12}, {0x0280, 12}, {0x0C80, 12},
81 {0x0080, 12}, {0x0B00, 13}, {0x1300, 13}, {0x001C, 5},
82 {0x0064, 8}, {0x0380, 12}, {0x1900, 13}, {0x0D80, 12},
83 {0x0018, 6}, {0x00BF, 8}, {0x0480, 12}, {0x0B80, 12},
84 {0x0038, 6}, {0x0040, 9}, {0x0900, 13}, {0x0030, 7},
85 {0x0780, 12}, {0x2800, 16}, {0x0010, 7}, {0x0A80, 12},
86 {0x0050, 7}, {0x0880, 12}, {0x000F, 7}, {0x1100, 13},
87 {0x002F, 7}, {0x0100, 13}, {0x0084, 8}, {0x5800, 16},
88 {0x00A4, 8}, {0x9800, 16}, {0x0024, 8}, {0x1800, 16},
89 {0x0140, 9}, {0xE800, 16}, {0x01C0, 9}, {0x6800, 16},
90 {0x02C0, 10}, {0xA800, 16}, {0x0F80, 12}, {0x0580, 12},
91 {0x0980, 12}, {0x0E80, 12}, {0x0680, 12}, {0x1F00, 13},
92 {0x0F00, 13}, {0x1700, 13}, {0x0700, 13}, {0x1B00, 13},
93 {0xF800, 16}, {0x7800, 16}, {0xB800, 16}, {0x3800, 16},
100 1, 2, 3, 4, 5, 6, 7, 8,
101 9, 10, 11, 12, 13, 14, 15, 16,
102 17, 18, 19, 20, 21, 22, 23, 24,
103 25, 26, 27, 28, 29, 30, 31, 32,
104 33, 34, 35, 36, 37, 38, 39, 40,
105 1, 2, 3, 4, 5, 6, 7, 8,
106 9, 10, 11, 12, 13, 14, 15, 16,
107 17, 18, 19, 20, 1, 2, 3, 4,
108 5, 6, 7, 8, 9, 10, 11, 1,
109 2, 3, 4, 5, 1, 2, 3, 4,
110 1, 2, 3, 1, 2, 3, 1, 2,
111 1, 2, 1, 2, 1, 2, 1, 2,
112 1, 2, 1, 2, 1, 2, 1, 2,
113 1, 2, 1, 1, 1, 1, 1, 1,
114 1, 1, 1, 1, 1, 1, 1, 1,
119 0, 0, 0, 0, 0, 0, 0, 0,
120 0, 0, 0, 0, 0, 0, 0, 0,
121 0, 0, 0, 0, 0, 0, 0, 0,
122 0, 0, 0, 0, 0, 0, 0, 0,
123 0, 0, 0, 0, 0, 0, 0, 0,
124 1, 1, 1, 1, 1, 1, 1, 1,
125 1, 1, 1, 1, 1, 1, 1, 1,
126 1, 1, 1, 1, 2, 2, 2, 2,
127 2, 2, 2, 2, 2, 2, 2, 3,
128 3, 3, 3, 3, 4, 4, 4, 4,
129 5, 5, 5, 6, 6, 6, 7, 7,
130 8, 8, 9, 9, 10, 10, 11, 11,
131 12, 12, 13, 13, 14, 14, 15, 15,
132 16, 16, 17, 18, 19, 20, 21, 22,
133 23, 24, 25, 26, 27, 28, 29, 30,
145 #if CONFIG_SPEEDHQ_DECODER
147 static const uint8_t unscaled_quant_matrix[64] = {
148 16, 16, 19, 22, 26, 27, 29, 34,
149 16, 16, 22, 24, 27, 29, 34, 37,
150 19, 22, 26, 27, 29, 34, 34, 38,
151 22, 22, 26, 27, 29, 34, 37, 40,
152 22, 26, 27, 29, 32, 35, 40, 48,
153 26, 27, 29, 32, 35, 40, 48, 58,
154 26, 27, 29, 34, 38, 46, 56, 69,
155 27, 29, 35, 38, 46, 56, 69, 83
160 static VLC dc_lum_vlc_le;
161 static VLC dc_chroma_vlc_le;
162 static VLC dc_alpha_run_vlc_le;
163 static VLC dc_alpha_level_vlc_le;
165 static inline int decode_dc_le(
GetBitContext *gb,
int component)
169 if (component == 0 || component == 3) {
211 for (y = 0; y < 8; y++) {
212 for (x = 0; x < 16; x++) {
213 last_alpha[x] -=
block[y * 16 + x];
215 memcpy(dest, last_alpha, 16);
224 const int *quant_matrix =
s->quant_matrix;
225 const uint8_t *scantable =
s->intra_scantable.permutated;
229 s->bdsp.clear_block(
block);
231 dc_offset = decode_dc_le(gb, component);
232 last_dc[component] -= dc_offset;
233 block[scantable[0]] = last_dc[component];
256 #if MIN_CACHE_BITS < 6 + 6 + 12
257 #error MIN_CACHE_BITS is too small for the escape code, add UPDATE_CACHE
274 s->idsp.idct_put(dest, linesize,
block);
287 if (
s->alpha_type != SHQ_NO_ALPHA)
290 for (
int y = 0; y <
frame->
height; y += 16 * line_stride) {
291 int last_dc[4] = { 1024, 1024, 1024, 1024 };
292 uint8_t *dest_y, *dest_cb, *dest_cr, *dest_a;
297 if (
s->subsampling == SHQ_SUBSAMPLING_420) {
300 }
else if (
s->subsampling == SHQ_SUBSAMPLING_422) {
304 if (
s->alpha_type != SHQ_NO_ALPHA) {
305 memset(last_alpha, 255,
sizeof(last_alpha));
313 if ((ret =
decode_dct_block(
s, gb, last_dc, 0, dest_y + 8 * linesize_y, linesize_y)) < 0)
315 if ((ret =
decode_dct_block(
s, gb, last_dc, 0, dest_y + 8 * linesize_y + 8, linesize_y)) < 0)
322 if (
s->subsampling != SHQ_SUBSAMPLING_420) {
323 if ((ret =
decode_dct_block(
s, gb, last_dc, 1, dest_cb + 8 * linesize_cb, linesize_cb)) < 0)
325 if ((ret =
decode_dct_block(
s, gb, last_dc, 2, dest_cr + 8 * linesize_cr, linesize_cr)) < 0)
329 if (
s->alpha_type == SHQ_RLE_ALPHA) {
331 if ((ret = decode_alpha_block(
s, gb, last_alpha, dest_a, linesize_a)) < 0)
333 if ((ret = decode_alpha_block(
s, gb, last_alpha, dest_a + 8 * linesize_a, linesize_a)) < 0)
335 }
else if (
s->alpha_type == SHQ_DCT_ALPHA) {
341 if ((ret =
decode_dct_block(
s, gb, last_dc, 3, dest_a + 8 * linesize_a, linesize_a)) < 0)
343 if ((ret =
decode_dct_block(
s, gb, last_dc, 3, dest_a + 8 * linesize_a + 8, linesize_a)) < 0)
351 static int decode_speedhq_field(
const SHQContext *
s,
const uint8_t *buf,
int buf_size,
AVFrame *
frame,
int field_number,
int start,
int end,
int line_stride)
353 int ret, slice_number, slice_offsets[5];
360 if (
s->alpha_type != SHQ_NO_ALPHA)
363 if (end < start || end - start < 3 || end > buf_size)
366 slice_offsets[0] = start;
367 slice_offsets[4] = end;
368 for (slice_number = 1; slice_number < 4; slice_number++) {
369 uint32_t last_offset, slice_len;
371 last_offset = slice_offsets[slice_number - 1];
372 slice_len =
AV_RL24(buf + last_offset);
373 slice_offsets[slice_number] = last_offset + slice_len;
375 if (slice_len < 3 || slice_offsets[slice_number] > end - 3)
379 for (slice_number = 0; slice_number < 4; slice_number++) {
383 slice_begin = slice_offsets[slice_number];
384 slice_end = slice_offsets[slice_number + 1];
389 for (y = slice_number * 16 * line_stride; y <
frame->
height; y += line_stride * 64) {
390 uint8_t *dest_y, *dest_cb, *dest_cr, *dest_a;
391 int last_dc[4] = { 1024, 1024, 1024, 1024 };
394 memset(last_alpha, 255,
sizeof(last_alpha));
397 if (
s->subsampling == SHQ_SUBSAMPLING_420) {
404 if (
s->alpha_type != SHQ_NO_ALPHA) {
408 for (x = 0; x <
frame->
width - 8 * (
s->subsampling != SHQ_SUBSAMPLING_444); x += 16) {
414 if ((ret =
decode_dct_block(
s, &gb, last_dc, 0, dest_y + 8 * linesize_y, linesize_y)) < 0)
416 if ((ret =
decode_dct_block(
s, &gb, last_dc, 0, dest_y + 8 * linesize_y + 8, linesize_y)) < 0)
428 if (
s->subsampling != SHQ_SUBSAMPLING_420) {
430 if ((ret =
decode_dct_block(
s, &gb, last_dc, 1, dest_cb + 8 * linesize_cb, linesize_cb)) < 0)
432 if ((ret =
decode_dct_block(
s, &gb, last_dc, 2, dest_cr + 8 * linesize_cr, linesize_cr)) < 0)
435 if (
s->subsampling == SHQ_SUBSAMPLING_444) {
441 if ((ret =
decode_dct_block(
s, &gb, last_dc, 1, dest_cb + 8 * linesize_cb + 8, linesize_cb)) < 0)
443 if ((ret =
decode_dct_block(
s, &gb, last_dc, 2, dest_cr + 8 * linesize_cr + 8, linesize_cr)) < 0)
454 if (
s->alpha_type == SHQ_RLE_ALPHA) {
456 if ((ret = decode_alpha_block(
s, &gb, last_alpha, dest_a, linesize_a)) < 0)
458 if ((ret = decode_alpha_block(
s, &gb, last_alpha, dest_a + 8 * linesize_a, linesize_a)) < 0)
461 }
else if (
s->alpha_type == SHQ_DCT_ALPHA) {
467 if ((ret =
decode_dct_block(
s, &gb, last_dc, 3, dest_a + 8 * linesize_a, linesize_a)) < 0)
469 if ((ret =
decode_dct_block(
s, &gb, last_dc, 3, dest_a + 8 * linesize_a + 8, linesize_a)) < 0)
477 if (
s->subsampling != SHQ_SUBSAMPLING_444 && (
frame->
width & 15))
478 return decode_speedhq_border(
s, &gb,
frame, field_number, line_stride);
490 void *
data,
int *got_frame,
495 int buf_size = avpkt->
size;
498 uint32_t second_field_offset;
501 if (buf_size < 4 || avctx->
width < 8)
505 if (quality >= 100) {
511 second_field_offset =
AV_RL24(buf + 1);
512 if (second_field_offset >= buf_size - 3) {
524 if (second_field_offset == 4 || second_field_offset == (buf_size-4)) {
534 if ((ret = decode_speedhq_field(
s, buf, buf_size,
frame, 0, 4, buf_size, 1)) < 0)
537 if ((ret = decode_speedhq_field(
s, buf, buf_size,
frame, 0, 4, second_field_offset, 2)) < 0)
539 if ((ret = decode_speedhq_field(
s, buf, buf_size,
frame, 1, second_field_offset, buf_size, 2)) < 0)
552 static av_cold void compute_alpha_vlcs(
void)
554 uint16_t run_code[134], level_code[266];
556 int16_t run_symbols[134], level_symbols[266];
565 run_symbols[entry] = 0;
569 for (
i = 0;
i < 4; ++
i) {
570 run_code[entry] = (
i << 2) | 1;
572 run_symbols[entry] =
i + 1;
577 for (
i = 0;
i < 128; ++
i) {
578 run_code[entry] = (
i << 3) | 7;
580 run_symbols[entry] =
i;
587 run_symbols[entry] = -1;
596 run_symbols, 2, 2, 160);
601 for (sign = 0; sign <= 1; ++sign) {
603 level_code[entry] = (sign << 1) | 1;
604 level_bits[entry] = 2;
605 level_symbols[entry] = sign ? -1 : 1;
609 for (
i = 0;
i < 4; ++
i) {
610 level_code[entry] = (
i << 3) | (sign << 2) | 2;
611 level_bits[entry] = 5;
612 level_symbols[entry] = sign ? -(
i + 2) : (
i + 2);
623 for (
i = 0;
i < 256; ++
i) {
624 level_code[entry] =
i << 2;
625 level_bits[entry] = 10;
626 level_symbols[entry] =
i;
636 level_symbols, 2, 2, 288);
639 static av_cold void speedhq_static_init(
void)
654 compute_alpha_vlcs();
674 case MKTAG(
'S',
'H',
'Q',
'0'):
675 s->subsampling = SHQ_SUBSAMPLING_420;
676 s->alpha_type = SHQ_NO_ALPHA;
679 case MKTAG(
'S',
'H',
'Q',
'1'):
680 s->subsampling = SHQ_SUBSAMPLING_420;
681 s->alpha_type = SHQ_RLE_ALPHA;
684 case MKTAG(
'S',
'H',
'Q',
'2'):
685 s->subsampling = SHQ_SUBSAMPLING_422;
686 s->alpha_type = SHQ_NO_ALPHA;
689 case MKTAG(
'S',
'H',
'Q',
'3'):
690 s->subsampling = SHQ_SUBSAMPLING_422;
691 s->alpha_type = SHQ_RLE_ALPHA;
694 case MKTAG(
'S',
'H',
'Q',
'4'):
695 s->subsampling = SHQ_SUBSAMPLING_444;
696 s->alpha_type = SHQ_NO_ALPHA;
699 case MKTAG(
'S',
'H',
'Q',
'5'):
700 s->subsampling = SHQ_SUBSAMPLING_444;
701 s->alpha_type = SHQ_RLE_ALPHA;
704 case MKTAG(
'S',
'H',
'Q',
'7'):
705 s->subsampling = SHQ_SUBSAMPLING_422;
706 s->alpha_type = SHQ_DCT_ALPHA;
709 case MKTAG(
'S',
'H',
'Q',
'9'):
710 s->subsampling = SHQ_SUBSAMPLING_444;
711 s->alpha_type = SHQ_DCT_ALPHA;
733 .
init = speedhq_decode_init,
734 .
decode = speedhq_decode_frame,
static void compute_quant_matrix(AGMContext *s, double qscale)
AVCodec ff_speedhq_decoder
Macro definitions for various function/variable attributes.
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Libavcodec external API header.
static av_cold int init(AVCodecContext *avctx)
#define MKTAG(a, b, c, d)
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)
bitstream reader API header.
#define GET_VLC(code, name, gb, table, bits, max_depth)
If the vlc code is invalid and max_depth=1, then no bits will be removed.
static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)
Parse a vlc code.
#define CLOSE_READER(name, gb)
static int get_xbits_le(GetBitContext *s, int n)
#define SHOW_UBITS(name, gb, num)
#define SHOW_SBITS(name, gb, num)
#define OPEN_READER(name, gb)
#define SKIP_BITS(name, gb, num)
#define GET_RL_VLC(level, run, name, gb, table, bits, max_depth, need_update)
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
#define LAST_SKIP_BITS(name, gb, num)
#define UPDATE_CACHE_LE(name, gb)
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
static const uint8_t run_bits[7][16]
av_cold void ff_idctdsp_init(IDCTDSPContext *c, AVCodecContext *avctx)
av_cold void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable)
av_cold void ff_blockdsp_init(BlockDSPContext *c, AVCodecContext *avctx)
common internal API header
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
static int ff_thread_once(char *control, void(*routine)(void))
const uint8_t ff_zigzag_direct[64]
#define LOCAL_ALIGNED_32(t, v,...)
#define INIT_2D_VLC_RL(rl, static_size, flags)
const uint16_t ff_mpeg12_vlc_dc_chroma_code[12]
const uint16_t ff_mpeg12_vlc_dc_lum_code[12]
const unsigned char ff_mpeg12_vlc_dc_chroma_bits[12]
const unsigned char ff_mpeg12_vlc_dc_lum_bits[12]
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
static void decode_dct_block(RangeCoder *c, DCTBlockCoder *bc, uint8_t *dst, ptrdiff_t stride, int block_size, int *block, int mb_x, int mb_y)
@ AVCHROMA_LOC_CENTER
MPEG-1 4:2:0, JPEG 4:2:0, H.263 4:2:0.
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
@ AV_PIX_FMT_YUVA420P
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
@ AV_PIX_FMT_YUVA444P
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
@ AV_PIX_FMT_YUVA422P
planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
@ AVCOL_SPC_BT470BG
also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM / IEC 61966-2-4 xvYCC601
av_cold void ff_rl_init(RLTable *rl, uint8_t static_store[2][2 *MAX_RUN+MAX_LEVEL+3])
#define FF_ARRAY_ELEMS(a)
static const uint8_t speedhq_run[121]
static const uint8_t speedhq_level[121]
static const uint16_t speedhq_vlc[123][2]
static uint8_t speedhq_static_rl_table_store[2][2 *MAX_RUN+MAX_LEVEL+3]
main external API structure.
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
int width
picture width / height.
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
enum AVColorSpace colorspace
YUV colorspace type.
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
int coded_width
Bitstream width / height, may be different from width/height e.g.
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.
This structure stores compressed data.
RL_VLC_ELEM * rl_vlc[32]
decoding only
enum SHQContext::@133 alpha_type
ScanTable intra_scantable
enum SHQContext::@132 subsampling
VLC_TYPE(* table)[2]
code, bits
static av_always_inline int diff(const uint32_t a, const uint32_t b)
#define INIT_CUSTOM_VLC_STATIC(vlc, bits, a, b, c, d, e, f, g, flags, static_size)
#define INIT_VLC_OUTPUT_LE
#define INIT_LE_VLC_SPARSE_STATIC(vlc, bits, a, b, c, d, e, f, g, h, i, j, static_size)