FFmpeg
hq_hqa.c
Go to the documentation of this file.
1 /*
2  * Canopus HQ/HQA decoder
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 #include <stdint.h>
22 
23 #include "libavutil/attributes.h"
24 
25 #include "avcodec.h"
26 #include "bytestream.h"
27 #include "canopus.h"
28 #include "codec_internal.h"
29 #include "decode.h"
30 #include "get_bits.h"
31 
32 #include "hq_hqa.h"
33 #include "hq_hqadsp.h"
34 
35 /* HQ/HQA slices are a set of macroblocks belonging to a frame, and
36  * they usually form a pseudorandom pattern (probably because it is
37  * nicer to display on partial decode).
38  *
39  * For HQA it just happens that each slice is on every 8th macroblock,
40  * but they can be on any frame width like
41  * X.......X.
42  * ......X...
43  * ....X.....
44  * ..X.......
45  * etc.
46  *
47  * The original decoder has special handling for edge macroblocks,
48  * while lavc simply aligns coded_width and coded_height.
49  */
50 
51 static inline void put_blocks(HQContext *c, AVFrame *pic,
52  int plane, int x, int y, int ilace,
53  int16_t *block0, int16_t *block1)
54 {
55  uint8_t *p = pic->data[plane] + x;
56 
57  c->hqhqadsp.idct_put(p + y * pic->linesize[plane],
58  pic->linesize[plane] << ilace, block0);
59  c->hqhqadsp.idct_put(p + (y + (ilace ? 1 : 8)) * pic->linesize[plane],
60  pic->linesize[plane] << ilace, block1);
61 }
62 
63 static int hq_decode_block(HQContext *c, GetBitContext *gb, int16_t block[64],
64  int qsel, int is_chroma, int is_hqa)
65 {
66  const int32_t *q;
67  int val, pos = 1;
68 
69  memset(block, 0, 64 * sizeof(*block));
70 
71  if (!is_hqa) {
72  block[0] = get_sbits(gb, 9) * 64;
73  q = ff_hq_quants[qsel][is_chroma][get_bits(gb, 2)];
74  } else {
75  q = ff_hq_quants[qsel][is_chroma][get_bits(gb, 2)];
76  block[0] = get_sbits(gb, 9) * 64;
77  }
78 
79  for (;;) {
80  val = get_vlc2(gb, c->hq_ac_vlc.table, 9, 2);
81  if (val < 0)
82  return AVERROR_INVALIDDATA;
83 
85  if (pos >= 64)
86  break;
87  block[ff_zigzag_direct[pos]] = (int)(ff_hq_ac_syms[val] * (unsigned)q[pos]) >> 12;
88  pos++;
89  }
90 
91  return 0;
92 }
93 
94 static int hq_decode_mb(HQContext *c, AVFrame *pic,
95  GetBitContext *gb, int x, int y)
96 {
97  int qgroup, flag;
98  int i, ret;
99 
100  qgroup = get_bits(gb, 4);
101  flag = get_bits1(gb);
102 
103  for (i = 0; i < 8; i++) {
104  ret = hq_decode_block(c, gb, c->block[i], qgroup, i >= 4, 0);
105  if (ret < 0)
106  return ret;
107  }
108 
109  put_blocks(c, pic, 0, x, y, flag, c->block[0], c->block[2]);
110  put_blocks(c, pic, 0, x + 8, y, flag, c->block[1], c->block[3]);
111  put_blocks(c, pic, 2, x >> 1, y, flag, c->block[4], c->block[5]);
112  put_blocks(c, pic, 1, x >> 1, y, flag, c->block[6], c->block[7]);
113 
114  return 0;
115 }
116 
118  int prof_num, size_t data_size)
119 {
120  const HQProfile *profile;
121  GetBitContext gb;
122  const uint8_t *perm, *src = gbc->buffer;
123  uint32_t slice_off[21];
124  int slice, start_off, next_off, i, ret;
125 
126  if ((unsigned)prof_num >= NUM_HQ_PROFILES) {
127  profile = &ff_hq_profile[0];
128  avpriv_request_sample(ctx->avctx, "HQ Profile %d", prof_num);
129  } else {
130  profile = &ff_hq_profile[prof_num];
131  av_log(ctx->avctx, AV_LOG_VERBOSE, "HQ Profile %d\n", prof_num);
132  }
133 
134  ctx->avctx->coded_width = FFALIGN(profile->width, 16);
135  ctx->avctx->coded_height = FFALIGN(profile->height, 16);
136  ctx->avctx->width = profile->width;
137  ctx->avctx->height = profile->height;
138  ctx->avctx->bits_per_raw_sample = 8;
139  ctx->avctx->pix_fmt = AV_PIX_FMT_YUV422P;
140 
141  ret = ff_get_buffer(ctx->avctx, pic, 0);
142  if (ret < 0)
143  return ret;
144 
145  /* Offsets are stored from CUV position, so adjust them accordingly. */
146  for (i = 0; i < profile->num_slices + 1; i++)
147  slice_off[i] = bytestream2_get_be24(gbc) - 4;
148 
149  next_off = 0;
150  for (slice = 0; slice < profile->num_slices; slice++) {
151  start_off = next_off;
152  next_off = profile->tab_h * (slice + 1) / profile->num_slices;
153  perm = profile->perm_tab + start_off * profile->tab_w * 2;
154 
155  if (slice_off[slice] < (profile->num_slices + 1) * 3 ||
156  slice_off[slice] >= slice_off[slice + 1] ||
157  slice_off[slice + 1] > data_size) {
158  av_log(ctx->avctx, AV_LOG_ERROR,
159  "Invalid slice size %"SIZE_SPECIFIER".\n", data_size);
160  break;
161  }
162  init_get_bits(&gb, src + slice_off[slice],
163  (slice_off[slice + 1] - slice_off[slice]) * 8);
164 
165  for (i = 0; i < (next_off - start_off) * profile->tab_w; i++) {
166  ret = hq_decode_mb(ctx, pic, &gb, perm[0] * 16, perm[1] * 16);
167  if (ret < 0) {
168  av_log(ctx->avctx, AV_LOG_ERROR,
169  "Error decoding macroblock %d at slice %d.\n", i, slice);
170  return ret;
171  }
172  perm += 2;
173  }
174  }
175 
176  return 0;
177 }
178 
179 static int hqa_decode_mb(HQContext *c, AVFrame *pic, int qgroup,
180  GetBitContext *gb, int x, int y)
181 {
182  int flag = 0;
183  int i, ret, cbp;
184 
185  if (get_bits_left(gb) < 1)
186  return AVERROR_INVALIDDATA;
187 
188  cbp = get_vlc2(gb, c->hqa_cbp_vlc.table, 5, 1);
189 
190  for (i = 0; i < 12; i++)
191  memset(c->block[i], 0, sizeof(*c->block));
192  for (i = 0; i < 12; i++)
193  c->block[i][0] = -128 * (1 << 6);
194 
195  if (cbp) {
196  flag = get_bits1(gb);
197 
198  cbp |= cbp << 4;
199  if (cbp & 0x3)
200  cbp |= 0x500;
201  if (cbp & 0xC)
202  cbp |= 0xA00;
203  for (i = 0; i < 12; i++) {
204  if (!(cbp & (1 << i)))
205  continue;
206  ret = hq_decode_block(c, gb, c->block[i], qgroup, i >= 8, 1);
207  if (ret < 0)
208  return ret;
209  }
210  }
211 
212  put_blocks(c, pic, 3, x, y, flag, c->block[ 0], c->block[ 2]);
213  put_blocks(c, pic, 3, x + 8, y, flag, c->block[ 1], c->block[ 3]);
214  put_blocks(c, pic, 0, x, y, flag, c->block[ 4], c->block[ 6]);
215  put_blocks(c, pic, 0, x + 8, y, flag, c->block[ 5], c->block[ 7]);
216  put_blocks(c, pic, 2, x >> 1, y, flag, c->block[ 8], c->block[ 9]);
217  put_blocks(c, pic, 1, x >> 1, y, flag, c->block[10], c->block[11]);
218 
219  return 0;
220 }
221 
223  int quant, int slice_no, int w, int h)
224 {
225  int i, j, off;
226  int ret;
227 
228  for (i = 0; i < h; i += 16) {
229  off = (slice_no * 16 + i * 3) & 0x70;
230  for (j = off; j < w; j += 128) {
231  ret = hqa_decode_mb(ctx, pic, quant, gb, j, i);
232  if (ret < 0) {
233  av_log(ctx->avctx, AV_LOG_ERROR,
234  "Error decoding macroblock at %dx%d.\n", i, j);
235  return ret;
236  }
237  }
238  }
239 
240  return 0;
241 }
242 
243 static int hqa_decode_frame(HQContext *ctx, AVFrame *pic, GetByteContext *gbc, size_t data_size)
244 {
245  GetBitContext gb;
246  const int num_slices = 8;
247  uint32_t slice_off[9];
248  int i, slice, ret;
249  int width, height, quant;
250  const uint8_t *src = gbc->buffer;
251 
252  if (bytestream2_get_bytes_left(gbc) < 8 + 4*(num_slices + 1))
253  return AVERROR_INVALIDDATA;
254 
255  width = bytestream2_get_be16(gbc);
256  height = bytestream2_get_be16(gbc);
257 
258  ret = ff_set_dimensions(ctx->avctx, width, height);
259  if (ret < 0)
260  return ret;
261 
262  ctx->avctx->coded_width = FFALIGN(width, 16);
263  ctx->avctx->coded_height = FFALIGN(height, 16);
264  ctx->avctx->bits_per_raw_sample = 8;
265  ctx->avctx->pix_fmt = AV_PIX_FMT_YUVA422P;
266 
267  av_log(ctx->avctx, AV_LOG_VERBOSE, "HQA Profile\n");
268 
269  quant = bytestream2_get_byte(gbc);
270  bytestream2_skip(gbc, 3);
271  if (quant >= NUM_HQ_QUANTS) {
272  av_log(ctx->avctx, AV_LOG_ERROR,
273  "Invalid quantization matrix %d.\n", quant);
274  return AVERROR_INVALIDDATA;
275  }
276 
277  ret = ff_get_buffer(ctx->avctx, pic, 0);
278  if (ret < 0)
279  return ret;
280 
281  /* Offsets are stored from HQA1 position, so adjust them accordingly. */
282  for (i = 0; i < num_slices + 1; i++)
283  slice_off[i] = bytestream2_get_be32(gbc) - 4;
284 
285  for (slice = 0; slice < num_slices; slice++) {
286  if (slice_off[slice] < (num_slices + 1) * 3 ||
287  slice_off[slice] >= slice_off[slice + 1] ||
288  slice_off[slice + 1] > data_size) {
289  av_log(ctx->avctx, AV_LOG_ERROR,
290  "Invalid slice size %"SIZE_SPECIFIER".\n", data_size);
291  break;
292  }
293  init_get_bits(&gb, src + slice_off[slice],
294  (slice_off[slice + 1] - slice_off[slice]) * 8);
295 
296  ret = hqa_decode_slice(ctx, pic, &gb, quant, slice, width, height);
297  if (ret < 0)
298  return ret;
299  }
300 
301  return 0;
302 }
303 
305  int *got_frame, AVPacket *avpkt)
306 {
307  HQContext *ctx = avctx->priv_data;
308  GetByteContext gbc0, *const gbc = &gbc0;
309  uint32_t info_tag;
310  unsigned int data_size;
311  int ret;
312  unsigned tag;
313 
314  bytestream2_init(gbc, avpkt->data, avpkt->size);
315  if (bytestream2_get_bytes_left(gbc) < 4 + 4) {
316  av_log(avctx, AV_LOG_ERROR, "Frame is too small (%d).\n", avpkt->size);
317  return AVERROR_INVALIDDATA;
318  }
319 
320  info_tag = bytestream2_peek_le32(gbc);
321  if (info_tag == MKTAG('I', 'N', 'F', 'O')) {
322  int info_size;
323  bytestream2_skip(gbc, 4);
324  info_size = bytestream2_get_le32(gbc);
325  if (info_size < 0 || bytestream2_get_bytes_left(gbc) < info_size) {
326  av_log(avctx, AV_LOG_ERROR, "Invalid INFO size (%d).\n", info_size);
327  return AVERROR_INVALIDDATA;
328  }
329  ff_canopus_parse_info_tag(avctx, gbc->buffer, info_size);
330 
331  bytestream2_skip(gbc, info_size);
332  }
333 
334  data_size = bytestream2_get_bytes_left(gbc);
335  if (data_size < 4) {
336  av_log(avctx, AV_LOG_ERROR, "Frame is too small (%d).\n", data_size);
337  return AVERROR_INVALIDDATA;
338  }
339 
340  /* HQ defines dimensions and number of slices, and thus slice traversal
341  * order. HQA has no size constraint and a fixed number of slices, so it
342  * needs a separate scheme for it. */
343  tag = bytestream2_get_le32(gbc);
344  if ((tag & 0x00FFFFFF) == (MKTAG('U', 'V', 'C', ' ') & 0x00FFFFFF)) {
345  ret = hq_decode_frame(ctx, pic, gbc, tag >> 24, data_size);
346  } else if (tag == MKTAG('H', 'Q', 'A', '1')) {
347  ret = hqa_decode_frame(ctx, pic, gbc, data_size);
348  } else {
349  av_log(avctx, AV_LOG_ERROR, "Not a HQ/HQA frame.\n");
350  return AVERROR_INVALIDDATA;
351  }
352  if (ret < 0) {
353  av_log(avctx, AV_LOG_ERROR, "Error decoding frame.\n");
354  return ret;
355  }
356 
357  pic->key_frame = 1;
359 
360  *got_frame = 1;
361 
362  return avpkt->size;
363 }
364 
366 {
367  HQContext *ctx = avctx->priv_data;
368  ctx->avctx = avctx;
369 
370  ff_hqdsp_init(&ctx->hqhqadsp);
371 
372  return ff_hq_init_vlcs(ctx);
373 }
374 
376 {
377  HQContext *ctx = avctx->priv_data;
378 
379  ff_free_vlc(&ctx->hq_ac_vlc);
380  ff_free_vlc(&ctx->hqa_cbp_vlc);
381 
382  return 0;
383 }
384 
386  .p.name = "hq_hqa",
387  CODEC_LONG_NAME("Canopus HQ/HQA"),
388  .p.type = AVMEDIA_TYPE_VIDEO,
389  .p.id = AV_CODEC_ID_HQ_HQA,
390  .priv_data_size = sizeof(HQContext),
393  .close = hq_hqa_decode_close,
394  .p.capabilities = AV_CODEC_CAP_DR1,
395  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
396 };
hq_decode_block
static int hq_decode_block(HQContext *c, GetBitContext *gb, int16_t block[64], int qsel, int is_chroma, int is_hqa)
Definition: hq_hqa.c:63
hq_hqa_decode_close
static av_cold int hq_hqa_decode_close(AVCodecContext *avctx)
Definition: hq_hqa.c:375
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: codec_internal.h:42
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:839
GetByteContext
Definition: bytestream.h:33
hq_decode_mb
static int hq_decode_mb(HQContext *c, AVFrame *pic, GetBitContext *gb, int x, int y)
Definition: hq_hqa.c:94
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:325
w
uint8_t w
Definition: llviddspenc.c:38
AVPacket::data
uint8_t * data
Definition: packet.h:374
FFCodec
Definition: codec_internal.h:119
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
ff_set_dimensions
int ff_set_dimensions(AVCodecContext *s, int width, int height)
Check that the provided frame dimensions are valid and set them on the codec context.
Definition: utils.c:91
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:649
ff_hq_quants
const int32_t *const ff_hq_quants[16][2][4]
Definition: hq_hqadata.c:1126
hq_hqa_decode_frame
static int hq_hqa_decode_frame(AVCodecContext *avctx, AVFrame *pic, int *got_frame, AVPacket *avpkt)
Definition: hq_hqa.c:304
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:346
bytestream2_skip
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:168
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:123
ff_canopus_parse_info_tag
int ff_canopus_parse_info_tag(AVCodecContext *avctx, const uint8_t *src, size_t size)
Definition: canopus.c:30
GetBitContext
Definition: get_bits.h:61
AVFrame::key_frame
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:417
perm
perm
Definition: f_perms.c:74
val
static double val(void *priv, double ch)
Definition: aeval.c:77
hq_decode_frame
static int hq_decode_frame(HQContext *ctx, AVFrame *pic, GetByteContext *gbc, int prof_num, size_t data_size)
Definition: hq_hqa.c:117
quant
static int quant(float coef, const float Q, const float rounding)
Quantize one coefficient.
Definition: aacenc_utils.h:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_cold
#define av_cold
Definition: attributes.h:90
ff_hq_profile
const HQProfile ff_hq_profile[NUM_HQ_PROFILES]
Definition: hq_hqadata.c:8343
width
#define width
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:298
HQProfile
Definition: hq_hqa.h:45
hqa_decode_slice
static int hqa_decode_slice(HQContext *ctx, AVFrame *pic, GetBitContext *gb, int quant, int slice_no, int w, int h)
Definition: hq_hqa.c:222
GetByteContext::buffer
const uint8_t * buffer
Definition: bytestream.h:34
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts_bsf.c:363
get_sbits
static int get_sbits(GetBitContext *s, int n)
Definition: get_bits.h:359
ctx
AVFormatContext * ctx
Definition: movenc.c:48
decode.h
get_bits.h
ff_hq_init_vlcs
int ff_hq_init_vlcs(HQContext *c)
Definition: hq_hqadata.c:8368
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:264
if
if(ret)
Definition: filter_design.txt:179
hqa_decode_mb
static int hqa_decode_mb(HQContext *c, AVFrame *pic, int qgroup, GetBitContext *gb, int x, int y)
Definition: hq_hqa.c:179
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
hqa_decode_frame
static int hqa_decode_frame(HQContext *ctx, AVFrame *pic, GetByteContext *gbc, size_t data_size)
Definition: hq_hqa.c:243
NUM_HQ_PROFILES
#define NUM_HQ_PROFILES
Definition: hq_hqa.h:33
get_vlc2
static av_always_inline int get_vlc2(GetBitContext *s, const VLCElem *table, int bits, int max_depth)
Parse a vlc code.
Definition: get_bits.h:787
canopus.h
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
bytestream2_get_bytes_left
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:158
ff_hq_ac_syms
const int16_t ff_hq_ac_syms[NUM_HQ_AC_ENTRIES]
Definition: hq_hqadata.c:1342
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:422
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1450
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
AVPacket::size
int size
Definition: packet.h:375
codec_internal.h
HQContext
Definition: hq_hqa.h:36
height
#define height
attributes.h
hq_hqadsp.h
ff_hqdsp_init
av_cold void ff_hqdsp_init(HQDSPContext *c)
Definition: hq_hqadsp.c:127
AV_CODEC_ID_HQ_HQA
@ AV_CODEC_ID_HQ_HQA
Definition: codec_id.h:240
flag
#define flag(name)
Definition: cbs_av1.c:553
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
put_blocks
static void put_blocks(HQContext *c, AVFrame *pic, int plane, int x, int y, int ilace, int16_t *block0, int16_t *block1)
Definition: hq_hqa.c:51
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:211
profile
int profile
Definition: mxfenc.c:2006
ff_free_vlc
void ff_free_vlc(VLC *vlc)
Definition: vlc.c:375
avcodec.h
ff_zigzag_direct
const uint8_t ff_zigzag_direct[64]
Definition: mathtables.c:98
tag
uint32_t tag
Definition: movenc.c:1647
ret
ret
Definition: filter_design.txt:187
pos
unsigned int pos
Definition: spdifenc.c:412
SIZE_SPECIFIER
#define SIZE_SPECIFIER
Definition: internal.h:150
AVCodecContext
main external API structure.
Definition: avcodec.h:398
hq_hqa.h
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AV_PIX_FMT_YUV422P
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:36
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:425
AVPacket
This structure stores compressed data.
Definition: packet.h:351
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
NUM_HQ_QUANTS
#define NUM_HQ_QUANTS
Definition: hq_hqa.h:34
int32_t
int32_t
Definition: audioconvert.c:56
bytestream.h
bytestream2_init
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:137
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
Definition: frame.h:370
block
The exact code depends on how similar the blocks are and how related they are to the block
Definition: filter_design.txt:207
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
ff_hq_ac_skips
const uint8_t ff_hq_ac_skips[NUM_HQ_AC_ENTRIES]
Definition: hq_hqadata.c:1292
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
MKTAG
#define MKTAG(a, b, c, d)
Definition: macros.h:55
h
h
Definition: vp9dsp_template.c:2038
int
int
Definition: ffmpeg_filter.c:156
block1
static int16_t block1[64]
Definition: dct.c:118
ff_hq_hqa_decoder
const FFCodec ff_hq_hqa_decoder
Definition: hq_hqa.c:385
AV_PIX_FMT_YUVA422P
@ AV_PIX_FMT_YUVA422P
planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
Definition: pixfmt.h:166
hq_hqa_decode_init
static av_cold int hq_hqa_decode_init(AVCodecContext *avctx)
Definition: hq_hqa.c:365