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;
94 lsize * fields, block0, quant);
95 ctx->
hqxdsp.
idct_put((uint16_t *)(p + (y + (ilace ? 1 : 8)) * lsize),
96 lsize * fields, block1, quant);
116 const int *quants,
int dcb,
117 int16_t
block[64],
int *last_dc)
123 memset(block, 0, 64 *
sizeof(*block));
127 block[0] =
sign_extend(*last_dc << (12 - dcb), 12);
170 for (i = 0; i < 8; i++) {
171 int vlc_index = ctx->
dcb - 9;
172 if (i == 0 || i == 4 || i == 6)
175 ctx->
dcb, slice->
block[i], &last_dc);
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;
221 ctx->
dcb, slice->
block[i], &last_dc);
254 for (i = 0; i < 12; i++) {
255 int vlc_index = ctx->
dcb - 9;
256 if (i == 0 || i == 4 || i == 8)
259 ctx->
dcb, slice->
block[i], &last_dc);
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;
304 ctx->
dcb, slice->
block[i], &last_dc);
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)
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')) {
420 uint32_t info_offset =
AV_RL32(src + 4);
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;
443 if (src[0] !=
'H' || src[1] !=
'Q') {
449 ctx->
dcb = (src[3] & 3) + 8;
452 for (i = 0; i < 17; i++)
511 *got_picture_ptr = 1;
522 for (i = 0; i < 3; i++) {
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
#define AV_PIX_FMT_YUVA422P16
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
ptrdiff_t const GLvoid * data
int coded_width
Bitstream width / height, may be different from width/height e.g.
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
static void hqx_get_ac(GetBitContext *gb, const HQXAC *ac, int *run, int *lev)
static av_cold int init(AVCodecContext *avctx)
int ff_canopus_parse_info_tag(AVCodecContext *avctx, const uint8_t *src, size_t size)
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
mb_decode_func decode_func
int ff_hqx_init_vlcs(HQXContext *ctx)
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_RB16
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
static av_cold int hqx_decode_init(AVCodecContext *avctx)
static int hqx_decode_frame(AVCodecContext *avctx, void *data, int *got_picture_ptr, AVPacket *avpkt)
const HQXAC ff_hqx_ac[NUM_HQX_AC]
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
The exact code depends on how similar the blocks are and how related they are to the block
Multithreading support functions.
static int hqx_decode_422a(HQXContext *ctx, int slice_no, int x, int y)
static const uint8_t hqx_quant_luma[64]
static const int hqx_quants[16][4]
bitstream reader API header.
#define AV_PIX_FMT_YUV444P16
static const uint8_t hqx_quant_chroma[64]
static int hqx_decode_422(HQXContext *ctx, int slice_no, int x, int y)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
static av_cold int hqx_decode_close(AVCodecContext *avctx)
static int decode_slice(HQXContext *ctx, int slice_no)
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
static int decode_block(GetBitContext *gb, VLC *vlc, const int *quants, int dcb, int16_t block[64], int *last_dc)
#define AV_PIX_FMT_YUVA444P16
const char * name
Name of the codec implementation.
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before as well as code calling up to before the decode process starts Call have so the codec calls ff_thread_report set FF_CODEC_CAP_ALLOCATE_PROGRESS in AVCodec caps_internal and use ff_thread_get_buffer() to allocate frames.The frames must then be freed with ff_thread_release_buffer().Otherwise decode directly into the user-supplied frames.Call ff_thread_report_progress() after some part of the current picture has decoded.A good place to put this is where draw_horiz_band() is called-add this if it isn't called anywhere
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...
enum AVPictureType pict_type
Picture type of the frame.
the definition of that something depends on the semantic of the filter The callback must examine the status of the filter s links and proceed accordingly The status of output links is stored in the status_in and status_out fields and tested by the then the processing requires a frame on this link and the filter is expected to make efforts in that direction The status of input links is stored by the fifo and status_out fields
int width
picture width / height.
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)
Parse a vlc code.
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
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.
static int hqx_decode_444a(HQXContext *ctx, int slice_no, int x, int y)
static int decode_slice_thread(AVCodecContext *avctx, void *arg, int slice_no, int threadnr)
int discard_damaged_percentage
The percentage of damaged samples to discard a frame.
Libavcodec external API header.
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_RB24
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
main external API structure.
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2]...the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so...,+,-,+,-,+,+,-,+,-,+,...hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32-hcoeff[1]-hcoeff[2]-...a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2}an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||.........intra?||||:Block01:yes no||||:Block02:.................||||:Block03::y DC::ref index:||||:Block04::cb DC::motion x:||||.........:cr DC::motion y:||||.................|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------------------------------|||Y subbands||Cb subbands||Cr subbands||||------||------||------|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||------||------||------||||------||------||------|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||------||------||------||||------||------||------|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||------||------||------||||------||------||------|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------------------------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction------------|\Dequantization-------------------\||Reference frames|\IDWT|--------------|Motion\|||Frame 0||Frame 1||Compensation.OBMC v-------|--------------|--------------.\------> Frame n output Frame Frame<----------------------------------/|...|-------------------Range Coder:============Binary Range Coder:-------------------The implemented range coder is an adapted version based upon"Range encoding: an algorithm for removing redundancy from a digitised message."by G.N.N.Martin.The symbols encoded by the Snow range coder are bits(0|1).The associated probabilities are not fix but change depending on the symbol mix seen so far.bit seen|new state---------+-----------------------------------------------0|256-state_transition_table[256-old_state];1|state_transition_table[old_state];state_transition_table={0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:-------------------------FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1.the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled top and top right vectors is used as motion vector prediction the used motion vector is the sum of the predictor and(mvx_diff, mvy_diff)*mv_scale Intra DC Prediction block[y][x] dc[1]
static unsigned int get_bits1(GetBitContext *s)
static const int shuffle_16[16]
static void skip_bits(GetBitContext *s, int n)
const uint8_t ff_zigzag_direct[64]
static av_const int sign_extend(int val, unsigned bits)
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
common internal api header.
static void put_blocks(HQXContext *ctx, int plane, int x, int y, int ilace, int16_t *block0, int16_t *block1, const uint8_t *quant)
av_cold void ff_hqxdsp_init(HQXDSPContext *c)
VLC_TYPE(* table)[2]
code, bits
static LevelCodes lev[4+3+3]
int key_frame
1 -> keyframe, 0-> not
void(* idct_put)(uint16_t *dst, ptrdiff_t stride, int16_t *block, const uint8_t *quant)
static int16_t block1[64]
static int hqx_decode_444(HQXContext *ctx, int slice_no, int x, int y)
#define MKTAG(a, b, c, d)
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
static double val(void *priv, double ch)
This structure stores compressed data.
void ff_free_vlc(VLC *vlc)
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
#define AV_PIX_FMT_YUV422P16