FFmpeg
mpeg12.c
Go to the documentation of this file.
1 /*
2  * MPEG-1/2 decoder
3  * Copyright (c) 2000, 2001 Fabrice Bellard
4  * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
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 /**
24  * @file
25  * MPEG-1/2 decoder
26  */
27 
28 #define UNCHECKED_BITSTREAM_READER 1
29 
30 #include "libavutil/attributes.h"
31 #include "libavutil/avassert.h"
32 #include "libavutil/timecode.h"
33 
34 #include "internal.h"
35 #include "avcodec.h"
36 #include "mpegvideo.h"
37 #include "error_resilience.h"
38 #include "mpeg12.h"
39 #include "mpeg12data.h"
40 #include "mpegvideodata.h"
41 #include "bytestream.h"
42 #include "thread.h"
43 
45 
46 static const uint8_t table_mb_ptype[7][2] = {
47  { 3, 5 }, // 0x01 MB_INTRA
48  { 1, 2 }, // 0x02 MB_PAT
49  { 1, 3 }, // 0x08 MB_FOR
50  { 1, 1 }, // 0x0A MB_FOR|MB_PAT
51  { 1, 6 }, // 0x11 MB_QUANT|MB_INTRA
52  { 1, 5 }, // 0x12 MB_QUANT|MB_PAT
53  { 2, 5 }, // 0x1A MB_QUANT|MB_FOR|MB_PAT
54 };
55 
56 static const uint8_t table_mb_btype[11][2] = {
57  { 3, 5 }, // 0x01 MB_INTRA
58  { 2, 3 }, // 0x04 MB_BACK
59  { 3, 3 }, // 0x06 MB_BACK|MB_PAT
60  { 2, 4 }, // 0x08 MB_FOR
61  { 3, 4 }, // 0x0A MB_FOR|MB_PAT
62  { 2, 2 }, // 0x0C MB_FOR|MB_BACK
63  { 3, 2 }, // 0x0E MB_FOR|MB_BACK|MB_PAT
64  { 1, 6 }, // 0x11 MB_QUANT|MB_INTRA
65  { 2, 6 }, // 0x16 MB_QUANT|MB_BACK|MB_PAT
66  { 3, 6 }, // 0x1A MB_QUANT|MB_FOR|MB_PAT
67  { 2, 5 }, // 0x1E MB_QUANT|MB_FOR|MB_BACK|MB_PAT
68 };
69 
70 av_cold void ff_init_2d_vlc_rl(RLTable *rl, unsigned static_size, int flags)
71 {
72  int i;
73  VLC_TYPE table[680][2] = {{0}};
74  VLC vlc = { .table = table, .table_allocated = static_size };
75  av_assert0(static_size <= FF_ARRAY_ELEMS(table));
76  init_vlc(&vlc, TEX_VLC_BITS, rl->n + 2, &rl->table_vlc[0][1], 4, 2, &rl->table_vlc[0][0], 4, 2, INIT_VLC_USE_NEW_STATIC | flags);
77 
78  for (i = 0; i < vlc.table_size; i++) {
79  int code = vlc.table[i][0];
80  int len = vlc.table[i][1];
81  int level, run;
82 
83  if (len == 0) { // illegal code
84  run = 65;
85  level = MAX_LEVEL;
86  } else if (len<0) { //more bits needed
87  run = 0;
88  level = code;
89  } else {
90  if (code == rl->n) { //esc
91  run = 65;
92  level = 0;
93  } else if (code == rl->n+1) { //eob
94  run = 0;
95  level = 127;
96  } else {
97  run = rl->table_run [code] + 1;
98  level = rl->table_level[code];
99  }
100  }
101  rl->rl_vlc[0][i].len = len;
102  rl->rl_vlc[0][i].level = level;
103  rl->rl_vlc[0][i].run = run;
104  }
105 }
106 
108 {
109 
110  s->y_dc_scale_table =
111  s->c_dc_scale_table = ff_mpeg2_dc_scale_table[s->intra_dc_precision];
112 
113 }
114 
116 {
117  s->last_dc[0] = 1 << (7 + s->intra_dc_precision);
118  s->last_dc[1] = s->last_dc[0];
119  s->last_dc[2] = s->last_dc[0];
120  memset(s->last_mv, 0, sizeof(s->last_mv));
121 }
122 
123 
124 /******************************************/
125 /* decoding */
126 
128 
131 
136 
138 {
139  static int done = 0;
140 
141  if (!done) {
142  done = 1;
143 
146  ff_mpeg12_vlc_dc_lum_code, 2, 2, 512);
149  ff_mpeg12_vlc_dc_chroma_code, 2, 2, 514);
151  &ff_mpeg12_mbMotionVectorTable[0][1], 2, 1,
152  &ff_mpeg12_mbMotionVectorTable[0][0], 2, 1, 518);
154  &ff_mpeg12_mbAddrIncrTable[0][1], 2, 1,
155  &ff_mpeg12_mbAddrIncrTable[0][0], 2, 1, 538);
157  &ff_mpeg12_mbPatTable[0][1], 2, 1,
158  &ff_mpeg12_mbPatTable[0][0], 2, 1, 512);
159 
161  &table_mb_ptype[0][1], 2, 1,
162  &table_mb_ptype[0][0], 2, 1, 64);
164  &table_mb_btype[0][1], 2, 1,
165  &table_mb_btype[0][0], 2, 1, 64);
168 
169  INIT_2D_VLC_RL(ff_rl_mpeg1, 680, 0);
170  INIT_2D_VLC_RL(ff_rl_mpeg2, 674, 0);
171  }
172 }
173 
174 /**
175  * Find the end of the current frame in the bitstream.
176  * @return the position of the first byte of the next frame, or -1
177  */
179 {
180  int i;
181  uint32_t state = pc->state;
182 
183  /* EOF considered as end of frame */
184  if (buf_size == 0)
185  return 0;
186 
187 /*
188  0 frame start -> 1/4
189  1 first_SEQEXT -> 0/2
190  2 first field start -> 3/0
191  3 second_SEQEXT -> 2/0
192  4 searching end
193 */
194 
195  for (i = 0; i < buf_size; i++) {
196  av_assert1(pc->frame_start_found >= 0 && pc->frame_start_found <= 4);
197  if (pc->frame_start_found & 1) {
198  if (state == EXT_START_CODE && (buf[i] & 0xF0) != 0x80)
199  pc->frame_start_found--;
200  else if (state == EXT_START_CODE + 2) {
201  if ((buf[i] & 3) == 3)
202  pc->frame_start_found = 0;
203  else
204  pc->frame_start_found = (pc->frame_start_found + 1) & 3;
205  }
206  state++;
207  } else {
208  i = avpriv_find_start_code(buf + i, buf + buf_size, &state) - buf - 1;
210  i++;
211  pc->frame_start_found = 4;
212  }
213  if (state == SEQ_END_CODE) {
214  pc->frame_start_found = 0;
215  pc->state=-1;
216  return i+1;
217  }
218  if (pc->frame_start_found == 2 && state == SEQ_START_CODE)
219  pc->frame_start_found = 0;
220  if (pc->frame_start_found < 4 && state == EXT_START_CODE)
221  pc->frame_start_found++;
222  if (pc->frame_start_found == 4 && (state & 0xFFFFFF00) == 0x100) {
223  if (state < SLICE_MIN_START_CODE || state > SLICE_MAX_START_CODE) {
224  pc->frame_start_found = 0;
225  pc->state = -1;
226  return i - 3;
227  }
228  }
229  if (pc->frame_start_found == 0 && s && state == PICTURE_START_CODE) {
230  ff_fetch_timestamp(s, i - 3, 1, i > 3);
231  }
232  }
233  }
234  pc->state = state;
235  return END_NOT_FOUND;
236 }
237 
238 #define MAX_INDEX (64 - 1)
239 
241  const uint16_t *quant_matrix,
242  uint8_t *const scantable, int last_dc[3],
243  int16_t *block, int index, int qscale)
244 {
245  int dc, diff, i = 0, component;
246  RLTable *rl = &ff_rl_mpeg1;
247 
248  /* DC coefficient */
249  component = index <= 3 ? 0 : index - 4 + 1;
250 
251  diff = decode_dc(gb, component);
252  if (diff >= 0xffff)
253  return AVERROR_INVALIDDATA;
254 
255  dc = last_dc[component];
256  dc += diff;
257  last_dc[component] = dc;
258 
259  block[0] = dc * quant_matrix[0];
260 
261  {
262  OPEN_READER(re, gb);
263  UPDATE_CACHE(re, gb);
264  if (((int32_t)GET_CACHE(re, gb)) <= (int32_t)0xBFFFFFFF)
265  goto end;
266 
267  /* now quantify & encode AC coefficients */
268  while (1) {
269  int level, run, j;
270 
271  GET_RL_VLC(level, run, re, gb, rl->rl_vlc[0],
272  TEX_VLC_BITS, 2, 0);
273 
274  if (level != 0) {
275  i += run;
276  if (i > MAX_INDEX)
277  break;
278 
279  j = scantable[i];
280  level = (level * qscale * quant_matrix[j]) >> 4;
281  level = (level - 1) | 1;
282  level = (level ^ SHOW_SBITS(re, gb, 1)) -
283  SHOW_SBITS(re, gb, 1);
284  SKIP_BITS(re, gb, 1);
285  } else {
286  /* escape */
287  run = SHOW_UBITS(re, gb, 6) + 1;
288  LAST_SKIP_BITS(re, gb, 6);
289  UPDATE_CACHE(re, gb);
290  level = SHOW_SBITS(re, gb, 8);
291  SKIP_BITS(re, gb, 8);
292 
293  if (level == -128) {
294  level = SHOW_UBITS(re, gb, 8) - 256;
295  SKIP_BITS(re, gb, 8);
296  } else if (level == 0) {
297  level = SHOW_UBITS(re, gb, 8);
298  SKIP_BITS(re, gb, 8);
299  }
300 
301  i += run;
302  if (i > MAX_INDEX)
303  break;
304 
305  j = scantable[i];
306  if (level < 0) {
307  level = -level;
308  level = (level * qscale * quant_matrix[j]) >> 4;
309  level = (level - 1) | 1;
310  level = -level;
311  } else {
312  level = (level * qscale * quant_matrix[j]) >> 4;
313  level = (level - 1) | 1;
314  }
315  }
316 
317  block[j] = level;
318  if (((int32_t)GET_CACHE(re, gb)) <= (int32_t)0xBFFFFFFF)
319  break;
320 
321  UPDATE_CACHE(re, gb);
322  }
323 end:
324  LAST_SKIP_BITS(re, gb, 2);
325  CLOSE_READER(re, gb);
326  }
327 
328  if (i > MAX_INDEX)
330 
331  return i;
332 }
ff_rl_mpeg2
RLTable ff_rl_mpeg2
Definition: mpeg12data.c:174
level
uint8_t level
Definition: svq3.c:207
EXT_START_CODE
#define EXT_START_CODE
Definition: cavs.h:33
ff_mbincr_vlc
VLC ff_mbincr_vlc
Definition: mpeg12.c:132
ff_dc_chroma_vlc
VLC ff_dc_chroma_vlc
Definition: mpeg12.c:130
INIT_VLC_STATIC
#define INIT_VLC_STATIC(vlc, bits, a, b, c, d, e, f, g, static_size)
Definition: vlc.h:75
MAX_RUN
#define MAX_RUN
Definition: rl.h:35
SEQ_START_CODE
#define SEQ_START_CODE
Definition: mpegvideo.h:68
end
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
ff_mpeg12_common_init
av_cold void ff_mpeg12_common_init(MpegEncContext *s)
Definition: mpeg12.c:107
internal.h
table_mb_btype
static const uint8_t table_mb_btype[11][2]
Definition: mpeg12.c:56
init_vlc
#define init_vlc(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size, codes, codes_wrap, codes_size, flags)
Definition: vlc.h:38
table
static const uint16_t table[]
Definition: prosumer.c:206
RL_VLC_ELEM::run
uint8_t run
Definition: vlc.h:35
mpegvideo.h
avpriv_find_start_code
const uint8_t * avpriv_find_start_code(const uint8_t *p, const uint8_t *end, uint32_t *state)
UPDATE_CACHE
#define UPDATE_CACHE(name, gb)
Definition: get_bits.h:178
ff_mpeg12_static_rl_table_store
uint8_t ff_mpeg12_static_rl_table_store[2][2][2 *MAX_RUN+MAX_LEVEL+3]
Definition: mpeg12.c:44
MAX_INDEX
#define MAX_INDEX
Definition: mpeg12.c:238
ParseContext::state
uint32_t state
contains the last few bytes in MSB order
Definition: parser.h:33
ff_mpeg12_vlc_dc_chroma_bits
const unsigned char ff_mpeg12_vlc_dc_chroma_bits[12]
Definition: mpeg12data.c:62
thread.h
ff_mb_pat_vlc
VLC ff_mb_pat_vlc
Definition: mpeg12.c:135
SLICE_MAX_START_CODE
#define SLICE_MAX_START_CODE
Definition: avs2_parser.c:24
ff_mpeg12_vlc_dc_lum_bits
const unsigned char ff_mpeg12_vlc_dc_lum_bits[12]
Definition: mpeg12data.c:55
ff_fetch_timestamp
void ff_fetch_timestamp(AVCodecParserContext *s, int off, int remove, int fuzzy)
Fetch timestamps for a specific byte within the current access unit.
Definition: parser.c:89
GET_CACHE
#define GET_CACHE(name, gb)
Definition: get_bits.h:215
ff_mpeg12_mbAddrIncrTable
const uint8_t ff_mpeg12_mbAddrIncrTable[36][2]
Definition: mpeg12data.c:182
ParseContext
Definition: parser.h:28
VLC_TYPE
#define VLC_TYPE
Definition: vlc.h:24
ff_mpeg1_decode_block_intra
int ff_mpeg1_decode_block_intra(GetBitContext *gb, const uint16_t *quant_matrix, uint8_t *const scantable, int last_dc[3], int16_t *block, int index, int qscale)
Definition: mpeg12.c:240
timecode.h
PICTURE_START_CODE
#define PICTURE_START_CODE
Definition: mpegvideo.h:70
RLTable
RLTable.
Definition: rl.h:39
GetBitContext
Definition: get_bits.h:61
ff_mpeg12_mbMotionVectorTable
const uint8_t ff_mpeg12_mbMotionVectorTable[17][2]
Definition: mpeg12data.c:288
avassert.h
RLTable::n
int n
number of entries of table_vlc minus 1
Definition: rl.h:40
mpeg12.h
state
static struct @313 state
buf
void * buf
Definition: avisynth_c.h:766
av_cold
#define av_cold
Definition: attributes.h:84
ff_rl_mpeg1
RLTable ff_rl_mpeg1
Definition: mpeg12data.c:166
CLOSE_READER
#define CLOSE_READER(name, gb)
Definition: get_bits.h:149
s
#define s(width, name)
Definition: cbs_vp9.c:257
ff_mpeg2_dc_scale_table
const uint8_t *const ff_mpeg2_dc_scale_table[4]
Definition: mpegvideodata.c:82
SHOW_SBITS
#define SHOW_SBITS(name, gb, num)
Definition: get_bits.h:212
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
SKIP_BITS
#define SKIP_BITS(name, gb, num)
Definition: get_bits.h:193
int32_t
int32_t
Definition: audio_convert.c:194
MB_PTYPE_VLC_BITS
#define MB_PTYPE_VLC_BITS
Definition: mpeg12vlc.h:39
run
uint8_t run
Definition: svq3.c:206
RLTable::table_vlc
const uint16_t(* table_vlc)[2]
Definition: rl.h:42
SEQ_END_CODE
#define SEQ_END_CODE
Definition: mpegvideo.h:67
ParseContext::frame_start_found
int frame_start_found
Definition: parser.h:34
INIT_VLC_USE_NEW_STATIC
#define INIT_VLC_USE_NEW_STATIC
Definition: vlc.h:55
LAST_SKIP_BITS
#define LAST_SKIP_BITS(name, gb, num)
Definition: get_bits.h:199
MB_BTYPE_VLC_BITS
#define MB_BTYPE_VLC_BITS
Definition: mpeg12vlc.h:40
index
int index
Definition: gxfenc.c:89
RL_VLC_ELEM::len
int8_t len
Definition: vlc.h:34
ff_mb_ptype_vlc
VLC ff_mb_ptype_vlc
Definition: mpeg12.c:133
MAX_LEVEL
#define MAX_LEVEL
Definition: rl.h:36
ff_mpeg1_find_frame_end
int ff_mpeg1_find_frame_end(ParseContext *pc, const uint8_t *buf, int buf_size, AVCodecParserContext *s)
Find the end of the current frame in the bitstream.
Definition: mpeg12.c:178
RLTable::table_level
const int8_t * table_level
Definition: rl.h:44
MV_VLC_BITS
#define MV_VLC_BITS
Definition: ituh263dec.c:54
dc
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]
Definition: snow.txt:400
SLICE_MIN_START_CODE
#define SLICE_MIN_START_CODE
Definition: mpegvideo.h:71
ff_mpeg1_clean_buffers
void ff_mpeg1_clean_buffers(MpegEncContext *s)
Definition: mpeg12.c:115
OPEN_READER
#define OPEN_READER(name, gb)
Definition: get_bits.h:138
mpegvideodata.h
attributes.h
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
code
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
Definition: filter_design.txt:178
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
ff_mpeg12_init_vlcs
av_cold void ff_mpeg12_init_vlcs(void)
Definition: mpeg12.c:137
TEX_VLC_BITS
#define TEX_VLC_BITS
Definition: dv.h:96
MB_PAT_VLC_BITS
#define MB_PAT_VLC_BITS
Definition: mpeg12vlc.h:38
uint8_t
uint8_t
Definition: audio_convert.c:194
len
int len
Definition: vorbis_enc_data.h:452
ff_init_2d_vlc_rl
av_cold void ff_init_2d_vlc_rl(RLTable *rl, unsigned static_size, int flags)
Definition: mpeg12.c:70
table_mb_ptype
static const uint8_t table_mb_ptype[7][2]
Definition: mpeg12.c:46
ff_mpeg12_mbPatTable
const uint8_t ff_mpeg12_mbPatTable[64][2]
Definition: mpeg12data.c:221
avcodec.h
AVCodecParserContext
Definition: avcodec.h:5108
GET_RL_VLC
#define GET_RL_VLC(level, run, name, gb, table, bits, max_depth, need_update)
Definition: get_bits.h:738
ff_mpeg12_vlc_dc_chroma_code
const uint16_t ff_mpeg12_vlc_dc_chroma_code[12]
Definition: mpeg12data.c:59
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen_template.c:38
ff_dc_lum_vlc
VLC ff_dc_lum_vlc
Definition: mpeg12.c:129
mpeg12data.h
decode_dc
static int decode_dc(GetBitContext *gb, int component)
Definition: mpeg12.h:41
SHOW_UBITS
#define SHOW_UBITS(name, gb, num)
Definition: get_bits.h:211
error_resilience.h
VLC
Definition: vlc.h:26
ff_rl_init
av_cold int ff_rl_init(RLTable *rl, uint8_t static_store[2][2 *MAX_RUN+MAX_LEVEL+3])
Definition: rl.c:39
ff_mb_btype_vlc
VLC ff_mb_btype_vlc
Definition: mpeg12.c:134
VLC::table_size
int table_size
Definition: vlc.h:29
diff
static av_always_inline int diff(const uint32_t a, const uint32_t b)
Definition: vf_palettegen.c:136
ff_mv_vlc
VLC ff_mv_vlc
Definition: mpeg12.c:127
END_NOT_FOUND
#define END_NOT_FOUND
Definition: parser.h:40
INIT_2D_VLC_RL
#define INIT_2D_VLC_RL(rl, static_size, flags)
Definition: mpeg12.h:32
bytestream.h
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:565
ff_mpeg12_vlc_dc_lum_code
const uint16_t ff_mpeg12_vlc_dc_lum_code[12]
Definition: mpeg12data.c:52
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:59
DC_VLC_BITS
#define DC_VLC_BITS
Definition: intrax8.c:37
MpegEncContext
MpegEncContext.
Definition: mpegvideo.h:81
VLC::table
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
RLTable::table_run
const int8_t * table_run
Definition: rl.h:43
RLTable::rl_vlc
RL_VLC_ELEM * rl_vlc[32]
decoding only
Definition: rl.h:48
RL_VLC_ELEM::level
int16_t level
Definition: vlc.h:33
MBINCR_VLC_BITS
#define MBINCR_VLC_BITS
Definition: mpeg12vlc.h:37
re
float re
Definition: fft.c:82