43 #define HQX_HEADER_SIZE 59
50 { 0x1, 0x2, 0x4, 0x8 }, { 0x1, 0x3, 0x6, 0xC },
51 { 0x2, 0x4, 0x8, 0x10 }, { 0x3, 0x6, 0xC, 0x18 },
52 { 0x4, 0x8, 0x10, 0x20 }, { 0x6, 0xC, 0x18, 0x30 },
53 { 0x8, 0x10, 0x20, 0x40 },
54 { 0xA, 0x14, 0x28, 0x50 },
55 { 0xC, 0x18, 0x30, 0x60 },
56 { 0x10, 0x20, 0x40, 0x80 }, { 0x18, 0x30, 0x60, 0xC0 },
57 { 0x20, 0x40, 0x80, 0x100 }, { 0x30, 0x60, 0xC0, 0x180 },
58 { 0x40, 0x80, 0x100, 0x200 }, { 0x60, 0xC0, 0x180, 0x300 },
59 { 0x80, 0x100, 0x200, 0x400 }
63 16, 16, 16, 19, 19, 19, 42, 44,
64 16, 16, 19, 19, 19, 38, 43, 45,
65 16, 19, 19, 19, 40, 41, 45, 48,
66 19, 19, 19, 40, 41, 42, 46, 49,
67 19, 19, 40, 41, 42, 43, 48, 101,
68 19, 38, 41, 42, 43, 44, 98, 104,
69 42, 43, 45, 46, 48, 98, 109, 116,
70 44, 45, 48, 49, 101, 104, 116, 123,
74 16, 16, 19, 25, 26, 26, 42, 44,
75 16, 19, 25, 25, 26, 38, 43, 91,
76 19, 25, 26, 27, 40, 41, 91, 96,
77 25, 25, 27, 40, 41, 84, 93, 197,
78 26, 26, 40, 41, 84, 86, 191, 203,
79 26, 38, 41, 84, 86, 177, 197, 209,
80 42, 43, 91, 93, 191, 197, 219, 232,
81 44, 91, 96, 197, 203, 209, 232, 246,
85 int x,
int y,
int ilace,
86 int16_t *block0, int16_t *
block1,
89 int fields = ilace ? 2 : 1;
90 int lsize =
ctx->pic->linesize[plane];
93 ctx->hqxdsp.idct_put((uint16_t *)(p + y * lsize),
94 lsize * fields, block0,
quant);
95 ctx->hqxdsp.idct_put((uint16_t *)(p + (y + (ilace ? 1 : 8)) * lsize),
116 const int *quants,
int dcb,
117 int16_t
block[64],
int *last_dc)
170 for (
i = 0;
i < 8;
i++) {
171 int vlc_index =
ctx->dcb - 9;
172 if (
i == 0 ||
i == 4 ||
i == 6)
200 for (
i = 0;
i < 12;
i++)
201 memset(slice->
block[
i], 0,
sizeof(**slice->
block) * 64);
202 for (
i = 0;
i < 12;
i++)
203 slice->
block[
i][0] = -0x800;
215 for (
i = 0;
i < 12;
i++) {
216 if (
i == 0 ||
i == 4 ||
i == 8 ||
i == 10)
218 if (cbp & (1 <<
i)) {
219 int vlc_index =
ctx->dcb - 9;
254 for (
i = 0;
i < 12;
i++) {
255 int vlc_index =
ctx->dcb - 9;
256 if (
i == 0 ||
i == 4 ||
i == 8)
286 for (
i = 0;
i < 16;
i++)
287 memset(slice->
block[
i], 0,
sizeof(**slice->
block) * 64);
288 for (
i = 0;
i < 16;
i++)
289 slice->
block[
i][0] = -0x800;
298 for (
i = 0;
i < 16;
i++) {
299 if (
i == 0 ||
i == 4 ||
i == 8 ||
i == 12)
301 if (cbp & (1 <<
i)) {
302 int vlc_index =
ctx->dcb - 9;
324 0, 5, 11, 14, 2, 7, 9, 13, 1, 4, 10, 15, 3, 6, 8, 12
329 int mb_w = (
ctx->width + 15) >> 4;
330 int mb_h = (
ctx->height + 15) >> 4;
331 int grp_w = (mb_w + 4) / 5;
332 int grp_h = (mb_h + 4) / 5;
333 int grp_h_edge = grp_w * (mb_w / grp_w);
334 int grp_v_edge = grp_h * (mb_h / grp_h);
335 int grp_v_rest = mb_w - grp_h_edge;
336 int grp_h_rest = mb_h - grp_v_edge;
337 int num_mbs = mb_w * mb_h;
338 int num_tiles = (num_mbs + 479) / 480;
339 int std_tile_blocks = num_mbs / (16 * num_tiles);
340 int g_tile = slice_no * num_tiles;
341 int blk_addr, loc_addr, mb_x, mb_y,
pos, loc_row,
i;
342 int tile_blocks, tile_limit, tile_no;
344 for (tile_no = 0; tile_no < num_tiles; tile_no++, g_tile++) {
345 tile_blocks = std_tile_blocks;
347 if (g_tile < num_mbs - std_tile_blocks * 16 * num_tiles) {
348 tile_limit = num_mbs / (16 * num_tiles);
351 for (
i = 0;
i < tile_blocks;
i++) {
353 blk_addr = g_tile + 16 * num_tiles *
i;
355 blk_addr = tile_no + 16 * num_tiles *
i +
357 loc_row = grp_h * (blk_addr / (grp_h * mb_w));
358 loc_addr = blk_addr % (grp_h * mb_w);
359 if (loc_row >= grp_v_edge) {
360 mb_x = grp_w * (loc_addr / (grp_h_rest * grp_w));
361 pos = loc_addr % (grp_h_rest * grp_w);
363 mb_x = grp_w * (loc_addr / (grp_h * grp_w));
364 pos = loc_addr % (grp_h * grp_w);
366 if (mb_x >= grp_h_edge) {
367 mb_x +=
pos % grp_v_rest;
368 mb_y = loc_row + (
pos / grp_v_rest);
371 mb_y = loc_row + (
pos / grp_w);
373 ctx->decode_func(
ctx, slice_no, mb_x * 16, mb_y * 16);
381 int slice_no,
int threadnr)
384 uint32_t *slice_off =
ctx->slice_off;
388 slice_off[slice_no] >= slice_off[slice_no + 1] ||
389 slice_off[slice_no + 1] >
ctx->data_size) {
395 ctx->src + slice_off[slice_no],
396 slice_off[slice_no + 1] - slice_off[slice_no]);
404 int *got_picture_ptr,
AVPacket *avpkt)
413 if (avpkt->
size < 4 + 4) {
419 if (info_tag ==
MKTAG(
'I',
'N',
'F',
'O')) {
421 if (info_offset > INT_MAX || info_offset + 8 > avpkt->
size) {
423 "Invalid INFO header offset: 0x%08"PRIX32
" is too large.\n",
433 data_start =
src - avpkt->
data;
434 ctx->data_size = avpkt->
size - data_start;
443 if (
src[0] !=
'H' ||
src[1] !=
'Q') {
447 ctx->interlaced = !(
src[2] & 0x80);
449 ctx->dcb = (
src[3] & 3) + 8;
452 for (
i = 0;
i < 17;
i++)
480 switch (
ctx->format) {
508 ctx->pic->key_frame = 1;
511 *got_picture_ptr = 1;
522 for (
i = 0;
i < 3;
i++) {
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
Libavcodec external API header.
static av_cold int init(AVCodecContext *avctx)
void ff_free_vlc(VLC *vlc)
int ff_canopus_parse_info_tag(AVCodecContext *avctx, const uint8_t *src, size_t size)
static LevelCodes lev[4+3+3]
#define MKTAG(a, b, c, d)
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
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 unsigned int get_bits1(GetBitContext *s)
static void skip_bits(GetBitContext *s, int n)
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
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...
@ AV_PICTURE_TYPE_I
Intra.
static int decode_slice(HQXContext *ctx, int slice_no)
static const uint8_t hqx_quant_luma[64]
static int decode_slice_thread(AVCodecContext *avctx, void *arg, int slice_no, int threadnr)
static int hqx_decode_444a(HQXContext *ctx, int slice_no, int x, int y)
static void put_blocks(HQXContext *ctx, int plane, int x, int y, int ilace, int16_t *block0, int16_t *block1, const uint8_t *quant)
static int hqx_decode_frame(AVCodecContext *avctx, void *data, int *got_picture_ptr, AVPacket *avpkt)
static int hqx_decode_422a(HQXContext *ctx, int slice_no, int x, int y)
static const int shuffle_16[16]
static const int hqx_quants[16][4]
static int decode_block(GetBitContext *gb, VLC *vlc, const int *quants, int dcb, int16_t block[64], int *last_dc)
static void hqx_get_ac(GetBitContext *gb, const HQXAC *ac, int *run, int *lev)
static int hqx_decode_422(HQXContext *ctx, int slice_no, int x, int y)
static int hqx_decode_444(HQXContext *ctx, int slice_no, int x, int y)
static av_cold int hqx_decode_close(AVCodecContext *avctx)
static const uint8_t hqx_quant_chroma[64]
static av_cold int hqx_decode_init(AVCodecContext *avctx)
int ff_hqx_init_vlcs(HQXContext *ctx)
const HQXAC ff_hqx_ac[NUM_HQX_AC]
av_cold void ff_hqxdsp_init(HQXDSPContext *c)
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
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]
static av_const int sign_extend(int val, unsigned bits)
#define AV_PIX_FMT_YUV422P16
#define AV_PIX_FMT_YUVA444P16
#define AV_PIX_FMT_YUVA422P16
#define AV_PIX_FMT_YUV444P16
FF_ENABLE_DEPRECATION_WARNINGS int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
Wrapper around get_buffer() for frame-multithreaded codecs.
main external API structure.
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
int width
picture width / height.
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
int discard_damaged_percentage
The percentage of damaged samples to discard a frame.
int(* execute2)(struct AVCodecContext *c, int(*func)(struct AVCodecContext *c2, void *arg, int jobnr, int threadnr), void *arg2, int *ret, int count)
The codec may call this to execute several independent things.
int coded_width
Bitstream width / height, may be different from width/height e.g.
const char * name
Name of the codec implementation.
This structure stores compressed data.
VLC_TYPE(* table)[2]
code, bits
static int16_t block1[64]