FFmpeg
leaddec.c
Go to the documentation of this file.
1 /*
2  * LEAD MCMP decoder
3  *
4  * Copyright (c) 2023 Peter Ross
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 #include "avcodec.h"
24 #include "blockdsp.h"
25 #include "codec_internal.h"
26 #include "copy_block.h"
27 #include "decode.h"
28 #include "get_bits.h"
29 #include "idctdsp.h"
30 #include "jpegquanttables.h"
31 #include "jpegtables.h"
32 #include "leaddata.h"
33 #include "libavutil/mem_internal.h"
34 #include "libavutil/thread.h"
35 
36 #define LUMA_DC_BITS 9
37 #define CHROMA_DC_BITS 11
38 #define LUMA_AC_BITS 10
39 #define CHROMA_AC_BITS 10
40 
43 static VLCElem luma_ac_vlc[1160];
44 static VLCElem chroma_ac_vlc[1160];
45 
46 static av_cold void lead_init_static_data(void)
47 {
49  luma_dc_len, 1,
50  NULL, 0, 0,
51  0, 0);
53  chroma_dc_len, 1,
54  NULL, 0, 0,
55  0, 0);
57  luma_ac_len, 1,
59  0, 0);
61  chroma_ac_len, 1,
63  0, 0);
64 }
65 
66 typedef struct LeadContext {
67  uint8_t *bitstream_buf;
68  unsigned int bitstream_buf_size;
71  uint8_t permutated_scantable[64];
72 } LeadContext;
73 
75 {
76  static AVOnce init_static_once = AV_ONCE_INIT;
77  LeadContext *s = avctx->priv_data;
78 
79  if (avctx->extradata_size < 20)
80  return AVERROR_INVALIDDATA;
81 
82  ff_blockdsp_init(&s->bdsp);
83  ff_idctdsp_init(&s->idsp, avctx);
84  ff_permute_scantable(s->permutated_scantable, ff_zigzag_direct, s->idsp.idct_permutation);
85 
86  ff_thread_once(&init_static_once, lead_init_static_data);
87 
88  return 0;
89 }
90 
91 static void calc_dequant(uint16_t * dequant, const uint8_t * quant_tbl, int q)
92 {
93  for (int i = 0; i < 64; i++)
94  dequant[i] = av_clip(q * quant_tbl[ff_zigzag_direct[i]] / 50, 2, 32767);
95 }
96 
98  const VLCElem * dc_table, int dc_bits, const VLCElem * ac_table, int ac_bits,
99  int16_t * dc_pred, const uint16_t * dequant,
100  uint8_t * dst, int stride)
101 {
102  DECLARE_ALIGNED(32, int16_t, block)[64];
103  int size;
104 
105  s->bdsp.clear_block(block);
106 
107  if (get_bits_left(gb) <= 0)
108  return AVERROR_INVALIDDATA;
109 
110  size = get_vlc2(gb, dc_table, dc_bits, 1);
111  if (size < 0)
112  return AVERROR_INVALIDDATA;
113 
114  if (size)
115  *dc_pred += get_xbits(gb, size);
116 
117  block[0] = (1 << 10) + *dc_pred * dequant[0];
118 
119  for (int i = 1; i < 64; i++) {
120  int symbol = get_vlc2(gb, ac_table, ac_bits, 2);
121  if (symbol < 0)
122  return AVERROR_INVALIDDATA;
123 
124  if (!symbol)
125  break;
126 
127  i += symbol >> 4;
128  if (i >= 64)
129  return AVERROR_INVALIDDATA;
130 
131  size = symbol & 0xF;
132  if (size)
133  block[s->permutated_scantable[i]] = get_xbits(gb, size) * dequant[i];
134  }
135 
136  s->idsp.idct_put(dst, stride, block);
137  return 0;
138 }
139 
141  int * got_frame, AVPacket * avpkt)
142 {
143  LeadContext *s = avctx->priv_data;
144  const uint8_t * buf = avpkt->data;
145  int ret, format, zero = 0, yuv20p_half = 0, fields = 1, q, size;
146  GetBitContext gb;
147  int16_t dc_pred[3] = {0, 0, 0};
148  uint16_t dequant[2][64];
149 
150  if (avpkt->size < 8)
151  return AVERROR_INVALIDDATA;
152 
153  format = AV_RL16(buf + 4);
154  switch(format) {
155  case 0x0:
156  zero = 1;
157  avctx->pix_fmt = AV_PIX_FMT_YUV420P;
158  break;
159  case 0x8000:
160  yuv20p_half = 1;
161  // fall-through
162  case 0x1000:
163  avctx->pix_fmt = AV_PIX_FMT_YUV420P;
164  break;
165  case 0x2000:
166  avctx->pix_fmt = AV_PIX_FMT_YUV444P;
167  break;
168  case 0x2006:
169  avctx->pix_fmt = AV_PIX_FMT_YUV444P;
170  fields = 2;
171  break;
172  default:
173  avpriv_request_sample(avctx, "unsupported format 0x%x", format);
174  return AVERROR_PATCHWELCOME;
175  }
176 
177  q = AV_RL16(buf + 6);
180 
181  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
182  return ret;
183 
186 
187  av_fast_padded_malloc(&s->bitstream_buf, &s->bitstream_buf_size, avpkt->size - 8);
188  if (!s->bitstream_buf)
189  return AVERROR(ENOMEM);
190 
191  size = 0;
192  for (int i = 8; i < avpkt->size; i++) {
193  int src = buf[i] ^ 0x80;
194  s->bitstream_buf[size++] = src;
195  if (src == 0xFF && i + 1 < avpkt->size && (buf[i + 1] ^ 0x80) == 0x00)
196  i++;
197  }
198 
199  init_get_bits8(&gb, s->bitstream_buf, size);
200 
201  if (avctx->pix_fmt == AV_PIX_FMT_YUV420P && zero) {
202  for (int mb_y = 0; mb_y < avctx->height / 8; mb_y++)
203  for (int mb_x = 0; mb_x < avctx->width / 16; mb_x++)
204  for (int b = 0; b < 4; b++) {
205  int luma_block = 2;
206  const VLCElem * dc_vlc = b < luma_block ? luma_dc_vlc : chroma_dc_vlc;
207  int dc_bits = b < luma_block ? LUMA_DC_BITS : CHROMA_DC_BITS;
208  const VLCElem * ac_vlc = b < luma_block ? luma_ac_vlc : chroma_ac_vlc;
209  int ac_bits = b < luma_block ? LUMA_AC_BITS : CHROMA_AC_BITS;
210  int plane = b < luma_block ? 0 : b - 1;
211  int x, y, yclip;
212 
213  if (b < luma_block) {
214  y = 8*mb_y + 8*(b >> 1);
215  x = 16*mb_x + 8*(b & 1);
216  yclip = 0;
217  } else {
218  y = 4*mb_y;
219  x = 8*mb_x;
220  yclip = y + 8 >= avctx->height / 2;
221  }
222 
223  if (yclip) {
224  uint8_t tmp[64];
225  ret = decode_block(s, &gb, dc_vlc, dc_bits, ac_vlc, ac_bits,
226  dc_pred + plane, dequant[!(b < 4)], tmp, 8);
227  for (int yy = 0; yy < 8 && y + yy < avctx->height / 2; yy++)
228  memcpy(frame->data[plane] + (y+yy)*frame->linesize[plane] + x, tmp + yy, 8);
229  } else {
230  ret = decode_block(s, &gb, dc_vlc, dc_bits, ac_vlc, ac_bits,
231  dc_pred + plane, dequant[!(b < 4)],
232  frame->data[plane] + y*frame->linesize[plane] + x,
233  frame->linesize[plane]);
234  }
235  if (ret < 0)
236  return ret;
237  }
238  } else if (avctx->pix_fmt == AV_PIX_FMT_YUV420P) {
239  for (int mb_y = 0; mb_y < (avctx->height + 15) / 16; mb_y++)
240  for (int mb_x = 0; mb_x < (avctx->width + 15) / 16; mb_x++)
241  for (int b = 0; b < (yuv20p_half ? 4 : 6); b++) {
242  int luma_block = yuv20p_half ? 2 : 4;
243  const VLCElem * dc_vlc = b < luma_block ? luma_dc_vlc : chroma_dc_vlc;
244  int dc_bits = b < luma_block ? LUMA_DC_BITS : CHROMA_DC_BITS;
245  const VLCElem * ac_vlc = b < luma_block ? luma_ac_vlc : chroma_ac_vlc;
246  int ac_bits = b < luma_block ? LUMA_AC_BITS : CHROMA_AC_BITS;
247  int plane = b < luma_block ? 0 : b - (yuv20p_half ? 1 : 3);
248  int x, y;
249 
250  if (b < luma_block) {
251  y = 16*mb_y + 8*(b >> 1);
252  x = 16*mb_x + 8*(b & 1);
253  } else {
254  y = 8*mb_y;
255  x = 8*mb_x;
256  }
257 
258  ret = decode_block(s, &gb, dc_vlc, dc_bits, ac_vlc, ac_bits,
259  dc_pred + plane, dequant[!(b < 4)],
260  frame->data[plane] + y*frame->linesize[plane] + x,
261  (yuv20p_half && b < 2 ? 2 : 1) * frame->linesize[plane]);
262  if (ret < 0)
263  return ret;
264 
265  if (yuv20p_half && b < 2)
266  copy_block8(frame->data[plane] + (y + 1)*frame->linesize[plane] + x,
267  frame->data[plane] + y*frame->linesize[plane] + x,
268  2*frame->linesize[plane], 2*frame->linesize[plane], 8);
269  }
270  } else {
271  for (int f = 0; f < fields; f++)
272  for (int j = 0; j < (avctx->height + 7) / fields / 8; j++)
273  for (int i = 0; i < (avctx->width + 7) / 8; i++)
274  for (int plane = 0; plane < 3; plane++) {
275  const VLCElem * dc_vlc = !plane ? luma_dc_vlc : chroma_dc_vlc;
276  int dc_bits = !plane ? LUMA_DC_BITS : CHROMA_DC_BITS;
277  const VLCElem * ac_vlc = !plane ? luma_ac_vlc : chroma_ac_vlc;
278  int ac_bits = !plane ? LUMA_AC_BITS : CHROMA_AC_BITS;
279 
280  ret = decode_block(s, &gb, dc_vlc, dc_bits, ac_vlc, ac_bits,
281  dc_pred + plane, dequant[!!plane],
282  frame->data[plane] + (f + 8*j*fields)*frame->linesize[plane] + 8*i,
283  fields * frame->linesize[plane]);
284  if (ret < 0)
285  return ret;
286  }
287  }
288 
289  *got_frame = 1;
290 
291  return avpkt->size;
292 }
293 
295 {
296  LeadContext *s = avctx->priv_data;
297 
298  av_freep(&s->bitstream_buf);
299 
300  return 0;
301 }
302 
304  .p.name = "lead",
305  CODEC_LONG_NAME("LEAD MCMP"),
306  .p.type = AVMEDIA_TYPE_VIDEO,
307  .p.id = AV_CODEC_ID_LEAD,
308  .priv_data_size = sizeof(LeadContext),
310  .close = lead_decode_end,
312  .p.capabilities = AV_CODEC_CAP_DR1,
313  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
314 };
LeadContext::bdsp
BlockDSPContext bdsp
Definition: leaddec.c:69
jpegtables.h
av_clip
#define av_clip
Definition: common.h:98
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
blockdsp.h
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:694
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
mem_internal.h
chroma_dc_vlc
static VLCElem chroma_dc_vlc[1<< CHROMA_DC_BITS]
Definition: leaddec.c:42
thread.h
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:340
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
CHROMA_AC_BITS
#define CHROMA_AC_BITS
Definition: leaddec.c:39
AVPacket::data
uint8_t * data
Definition: packet.h:522
b
#define b
Definition: input.c:41
FFCodec
Definition: codec_internal.h:127
copy_block8
static void copy_block8(uint8_t *dst, const uint8_t *src, ptrdiff_t dstStride, ptrdiff_t srcStride, int h)
Definition: copy_block.h:47
AVFrame::flags
int flags
Frame flags, a combination of AV_FRAME_FLAGS.
Definition: frame.h:649
LeadContext::idsp
IDCTDSPContext idsp
Definition: leaddec.c:70
BlockDSPContext
Definition: blockdsp.h:32
ff_idctdsp_init
av_cold void ff_idctdsp_init(IDCTDSPContext *c, AVCodecContext *avctx)
Definition: idctdsp.c:228
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:361
ff_permute_scantable
av_cold void ff_permute_scantable(uint8_t dst[64], const uint8_t src[64], const uint8_t permutation[64])
Definition: idctdsp.c:30
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
GetBitContext
Definition: get_bits.h:108
dequant
static int dequant(AVSContext *h, int16_t *level_buf, uint8_t *run_buf, int16_t *dst, int mul, int shift, int coeff_num)
Definition: cavsdec.c:520
lead_decode_end
static av_cold int lead_decode_end(AVCodecContext *avctx)
Definition: leaddec.c:294
ff_thread_once
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:205
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
chroma_dc_len
static const uint8_t chroma_dc_len[]
Definition: leaddata.h:30
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:545
AV_FRAME_FLAG_KEY
#define AV_FRAME_FLAG_KEY
A flag to mark frames that are keyframes.
Definition: frame.h:628
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:547
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:306
ff_blockdsp_init
av_cold void ff_blockdsp_init(BlockDSPContext *c)
Definition: blockdsp.c:58
s
#define s(width, name)
Definition: cbs_vp9.c:198
luma_ac_len
static const uint8_t luma_ac_len[]
Definition: leaddata.h:34
format
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample format(the sample packing is implied by the sample format) and sample rate. The lists are not just lists
LeadContext::bitstream_buf_size
unsigned int bitstream_buf_size
Definition: leaddec.c:68
decode.h
get_bits.h
AV_RL16
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_RL16
Definition: bytestream.h:94
LeadContext::bitstream_buf
uint8_t * bitstream_buf
Definition: leaddec.c:67
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:73
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:272
frame
static AVFrame * frame
Definition: demux_decode.c:54
fields
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
Definition: filter_design.txt:155
dc_vlc
static VLCElem dc_vlc[1104]
Definition: clearvideo.c:78
AV_CODEC_ID_LEAD
@ AV_CODEC_ID_LEAD
Definition: codec_id.h:327
AV_ONCE_INIT
#define AV_ONCE_INIT
Definition: thread.h:203
NULL
#define NULL
Definition: coverity.c:32
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:279
ff_mjpeg_val_ac_chrominance
const uint8_t ff_mjpeg_val_ac_chrominance[]
Definition: jpegtabs.h:69
leaddata.h
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:652
jpegquanttables.h
lead_decode_init
static av_cold int lead_decode_init(AVCodecContext *avctx)
Definition: leaddec.c:74
AVOnce
#define AVOnce
Definition: thread.h:202
CHROMA_DC_BITS
#define CHROMA_DC_BITS
Definition: leaddec.c:37
LUMA_DC_BITS
#define LUMA_DC_BITS
Definition: leaddec.c:36
f
f
Definition: af_crystalizer.c:121
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:442
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1618
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:365
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
ff_mjpeg_val_ac_luminance
const uint8_t ff_mjpeg_val_ac_luminance[]
Definition: jpegtabs.h:42
AVPacket::size
int size
Definition: packet.h:523
codec_internal.h
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem_internal.h:111
luma_dc_len
static const uint8_t luma_dc_len[]
Definition: leaddata.h:26
LeadContext::permutated_scantable
uint8_t permutated_scantable[64]
Definition: leaddec.c:71
size
int size
Definition: twinvq_data.h:10344
VLCElem
Definition: vlc.h:32
decode_block
static int decode_block(LeadContext *s, GetBitContext *gb, const VLCElem *dc_table, int dc_bits, const VLCElem *ac_table, int ac_bits, int16_t *dc_pred, const uint16_t *dequant, uint8_t *dst, int stride)
Definition: leaddec.c:97
get_xbits
static int get_xbits(GetBitContext *s, int n)
Read MPEG-1 dc-style VLC (sign bit + mantissa with no MSB).
Definition: get_bits.h:292
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:255
ff_lead_decoder
const FFCodec ff_lead_decoder
Definition: leaddec.c:303
copy_block.h
luma_ac_vlc
static VLCElem luma_ac_vlc[1160]
Definition: leaddec.c:43
av_fast_padded_malloc
void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size)
Same behaviour av_fast_malloc but the buffer has additional AV_INPUT_BUFFER_PADDING_SIZE at the end w...
Definition: utils.c:52
ff_mjpeg_std_chrominance_quant_tbl
const uint8_t ff_mjpeg_std_chrominance_quant_tbl[64]
Definition: jpegquanttables.c:45
lead_decode_frame
static int lead_decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame, AVPacket *avpkt)
Definition: leaddec.c:140
lead_init_static_data
static av_cold void lead_init_static_data(void)
Definition: leaddec.c:46
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
AVCodecContext::height
int height
Definition: avcodec.h:625
luma_dc_vlc
static VLCElem luma_dc_vlc[1<< LUMA_DC_BITS]
Definition: leaddec.c:41
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:662
calc_dequant
static void calc_dequant(uint16_t *dequant, const uint8_t *quant_tbl, int q)
Definition: leaddec.c:91
idctdsp.h
avcodec.h
stride
#define stride
Definition: h264pred_template.c:537
ff_zigzag_direct
const uint8_t ff_zigzag_direct[64]
Definition: mathtables.c:98
ret
ret
Definition: filter_design.txt:187
IDCTDSPContext
Definition: idctdsp.h:45
ff_mjpeg_std_luminance_quant_tbl
const uint8_t ff_mjpeg_std_luminance_quant_tbl[64]
Definition: jpegquanttables.c:35
AVCodecContext
main external API structure.
Definition: avcodec.h:445
chroma_ac_vlc
static VLCElem chroma_ac_vlc[1160]
Definition: leaddec.c:44
ac_vlc
static VLCElem ac_vlc[554]
Definition: clearvideo.c:78
chroma_ac_len
static const uint8_t chroma_ac_len[]
Definition: leaddata.h:48
AV_PIX_FMT_YUV444P
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:78
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
zero
#define zero
Definition: regdef.h:64
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:36
VLC_INIT_STATIC_TABLE_FROM_LENGTHS
#define VLC_INIT_STATIC_TABLE_FROM_LENGTHS(vlc_table, nb_bits, nb_codes, lens, lens_wrap, syms, syms_wrap, syms_size, offset, flags)
Definition: vlc.h:277
AVPacket
This structure stores compressed data.
Definition: packet.h:499
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:472
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:625
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:385
block
The exact code depends on how similar the blocks are and how related they are to the block
Definition: filter_design.txt:207
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
LUMA_AC_BITS
#define LUMA_AC_BITS
Definition: leaddec.c:38
LeadContext
Definition: leaddec.c:66