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/thread.h"
33 
34 #include "mpegvideo.h"
35 #include "mpeg12codecs.h"
36 #include "mpeg12data.h"
37 #include "mpeg12dec.h"
38 #include "mpegutils.h"
39 #include "rl.h"
40 
41 static const uint8_t table_mb_ptype[7][2] = {
42  { 3, 5 }, // 0x01 MB_INTRA
43  { 1, 2 }, // 0x02 MB_PAT
44  { 1, 3 }, // 0x08 MB_FOR
45  { 1, 1 }, // 0x0A MB_FOR|MB_PAT
46  { 1, 6 }, // 0x11 MB_QUANT|MB_INTRA
47  { 1, 5 }, // 0x12 MB_QUANT|MB_PAT
48  { 2, 5 }, // 0x1A MB_QUANT|MB_FOR|MB_PAT
49 };
50 
51 static const uint8_t table_mb_btype[11][2] = {
52  { 3, 5 }, // 0x01 MB_INTRA
53  { 2, 3 }, // 0x04 MB_BACK
54  { 3, 3 }, // 0x06 MB_BACK|MB_PAT
55  { 2, 4 }, // 0x08 MB_FOR
56  { 3, 4 }, // 0x0A MB_FOR|MB_PAT
57  { 2, 2 }, // 0x0C MB_FOR|MB_BACK
58  { 3, 2 }, // 0x0E MB_FOR|MB_BACK|MB_PAT
59  { 1, 6 }, // 0x11 MB_QUANT|MB_INTRA
60  { 2, 6 }, // 0x16 MB_QUANT|MB_BACK|MB_PAT
61  { 3, 6 }, // 0x1A MB_QUANT|MB_FOR|MB_PAT
62  { 2, 5 }, // 0x1E MB_QUANT|MB_FOR|MB_BACK|MB_PAT
63 };
64 
65 static const int16_t ptype2mb_type[7] = {
73 };
74 
75 static const int16_t btype2mb_type[11] = {
87 };
88 
89 av_cold void ff_init_2d_vlc_rl(const uint16_t table_vlc[][2], RL_VLC_ELEM rl_vlc[],
90  const int8_t table_run[], const uint8_t table_level[],
91  int n, unsigned static_size, int flags)
92 {
93  int i;
94  VLCElem table[680] = { 0 };
95  VLC vlc = { .table = table, .table_allocated = static_size };
96  av_assert0(static_size <= FF_ARRAY_ELEMS(table));
97  vlc_init(&vlc, TEX_VLC_BITS, n + 2, &table_vlc[0][1], 4, 2, &table_vlc[0][0], 4, 2, VLC_INIT_USE_STATIC | flags);
98 
99  for (i = 0; i < vlc.table_size; i++) {
100  int code = vlc.table[i].sym;
101  int len = vlc.table[i].len;
102  int level, run;
103 
104  if (len == 0) { // illegal code
105  run = 65;
106  level = MAX_LEVEL;
107  } else if (len<0) { //more bits needed
108  run = 0;
109  level = code;
110  } else {
111  if (code == n) { //esc
112  run = 65;
113  level = 0;
114  } else if (code == n + 1) { //eob
115  run = 0;
116  level = 127;
117  } else {
118  run = table_run [code] + 1;
119  level = table_level[code];
120  }
121  }
122  rl_vlc[i].len = len;
123  rl_vlc[i].level = level;
124  rl_vlc[i].run = run;
125  }
126 }
127 
129 {
130  s->last_dc[0] = 1 << (7 + s->intra_dc_precision);
131  s->last_dc[1] = s->last_dc[0];
132  s->last_dc[2] = s->last_dc[0];
133  memset(s->last_mv, 0, sizeof(s->last_mv));
134 }
135 
136 
137 /******************************************/
138 /* decoding */
139 
141 
144 
149 
152 
153 static av_cold void mpeg12_init_vlcs(void)
154 {
157  ff_mpeg12_vlc_dc_lum_code, 2, 2, 0);
162  &ff_mpeg12_mbMotionVectorTable[0][1], 2, 1,
163  &ff_mpeg12_mbMotionVectorTable[0][0], 2, 1, 0);
165  &ff_mpeg12_mbAddrIncrTable[0][1], 2, 1,
166  &ff_mpeg12_mbAddrIncrTable[0][0], 2, 1, 0);
168  &ff_mpeg12_mbPatTable[0][1], 2, 1,
169  &ff_mpeg12_mbPatTable[0][0], 2, 1, 0);
170 
172  &table_mb_ptype[0][1], 2, 1,
173  &table_mb_ptype[0][0], 2, 1,
174  ptype2mb_type, 2, 2, 0);
176  &table_mb_btype[0][1], 2, 1,
177  &table_mb_btype[0][0], 2, 1,
178  btype2mb_type, 2, 2, 0);
179 
186 }
187 
189 {
190  static AVOnce init_static_once = AV_ONCE_INIT;
191  ff_thread_once(&init_static_once, mpeg12_init_vlcs);
192 }
193 
194 #define MAX_INDEX (64 - 1)
195 
197  const uint16_t *quant_matrix,
198  const uint8_t *scantable, int last_dc[3],
199  int16_t *block, int index, int qscale)
200 {
201  int dc, diff, i = 0, component;
202 
203  /* DC coefficient */
204  component = index <= 3 ? 0 : index - 4 + 1;
205 
206  diff = decode_dc(gb, component);
207 
208  dc = last_dc[component];
209  dc += diff;
210  last_dc[component] = dc;
211 
212  block[0] = dc * quant_matrix[0];
213 
214  {
215  OPEN_READER(re, gb);
216  UPDATE_CACHE(re, gb);
217  if (((int32_t)GET_CACHE(re, gb)) <= (int32_t)0xBFFFFFFF)
218  goto end;
219 
220  /* now quantify & encode AC coefficients */
221  while (1) {
222  int level, run, j;
223 
225  TEX_VLC_BITS, 2, 0);
226 
227  if (level != 0) {
228  i += run;
229  if (i > MAX_INDEX)
230  break;
231 
232  j = scantable[i];
233  level = (level * qscale * quant_matrix[j]) >> 4;
234  level = (level - 1) | 1;
235  level = (level ^ SHOW_SBITS(re, gb, 1)) -
236  SHOW_SBITS(re, gb, 1);
237  SKIP_BITS(re, gb, 1);
238  } else {
239  /* escape */
240  run = SHOW_UBITS(re, gb, 6) + 1;
241  LAST_SKIP_BITS(re, gb, 6);
242  UPDATE_CACHE(re, gb);
243  level = SHOW_SBITS(re, gb, 8);
244  SKIP_BITS(re, gb, 8);
245 
246  if (level == -128) {
247  level = SHOW_UBITS(re, gb, 8) - 256;
248  SKIP_BITS(re, gb, 8);
249  } else if (level == 0) {
250  level = SHOW_UBITS(re, gb, 8);
251  SKIP_BITS(re, gb, 8);
252  }
253 
254  i += run;
255  if (i > MAX_INDEX)
256  break;
257 
258  j = scantable[i];
259  if (level < 0) {
260  level = -level;
261  level = (level * qscale * quant_matrix[j]) >> 4;
262  level = (level - 1) | 1;
263  level = -level;
264  } else {
265  level = (level * qscale * quant_matrix[j]) >> 4;
266  level = (level - 1) | 1;
267  }
268  }
269 
270  block[j] = level;
271  if (((int32_t)GET_CACHE(re, gb)) <= (int32_t)0xBFFFFFFF)
272  break;
273 
274  UPDATE_CACHE(re, gb);
275  }
276 end:
277  LAST_SKIP_BITS(re, gb, 2);
278  CLOSE_READER(re, gb);
279  }
280 
281  if (i > MAX_INDEX)
283 
284  return i;
285 }
ff_mb_pat_vlc
VLCElem ff_mb_pat_vlc[512]
Definition: mpeg12.c:148
level
uint8_t level
Definition: svq3.c:205
thread.h
MPEG12_RL_NB_ELEMS
#define MPEG12_RL_NB_ELEMS
Definition: mpeg12vlc.h:52
table_mb_btype
static const uint8_t table_mb_btype[11][2]
Definition: mpeg12.c:51
table
static const uint16_t table[]
Definition: prosumer.c:203
MB_TYPE_16x16
#define MB_TYPE_16x16
Definition: mpegutils.h:42
VLCElem::len
VLCBaseType len
Definition: vlc.h:33
mpegvideo.h
UPDATE_CACHE
#define UPDATE_CACHE(name, gb)
Definition: get_bits.h:225
mpegutils.h
MAX_INDEX
#define MAX_INDEX
Definition: mpeg12.c:194
ff_mpeg12_vlc_dc_chroma_bits
const unsigned char ff_mpeg12_vlc_dc_chroma_bits[12]
Definition: mpeg12data.c:63
ff_mpeg12_vlc_dc_lum_bits
const unsigned char ff_mpeg12_vlc_dc_lum_bits[12]
Definition: mpeg12data.c:56
GET_CACHE
#define GET_CACHE(name, gb)
Definition: get_bits.h:263
ff_mpeg2_rl_vlc
RL_VLC_ELEM ff_mpeg2_rl_vlc[674]
Definition: mpeg12.c:151
ff_mpeg12_mbAddrIncrTable
const uint8_t ff_mpeg12_mbAddrIncrTable[36][2]
Definition: mpeg12data.c:167
ff_mbincr_vlc
VLCElem ff_mbincr_vlc[538]
Definition: mpeg12.c:145
GetBitContext
Definition: get_bits.h:108
ff_mpeg12_mbMotionVectorTable
const uint8_t ff_mpeg12_mbMotionVectorTable[17][2]
Definition: mpeg12data.c:273
MB_TYPE_CBP
#define MB_TYPE_CBP
Definition: mpegutils.h:48
VLCElem::sym
VLCBaseType sym
Definition: vlc.h:33
ptype2mb_type
static const int16_t ptype2mb_type[7]
Definition: mpeg12.c:65
avassert.h
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
mpeg12_init_vlcs
static av_cold void mpeg12_init_vlcs(void)
Definition: mpeg12.c:153
CLOSE_READER
#define CLOSE_READER(name, gb)
Definition: get_bits.h:188
s
#define s(width, name)
Definition: cbs_vp9.c:198
ff_mv_vlc
VLCElem ff_mv_vlc[266]
Definition: mpeg12.c:140
ff_dc_lum_vlc
VLCElem ff_dc_lum_vlc[512]
Definition: mpeg12.c:142
MB_TYPE_ZERO_MV
#define MB_TYPE_ZERO_MV
Definition: mpeg12dec.h:28
btype2mb_type
static const int16_t btype2mb_type[11]
Definition: mpeg12.c:75
SHOW_SBITS
#define SHOW_SBITS(name, gb, num)
Definition: get_bits.h:260
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
vlc_init
#define vlc_init(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size, codes, codes_wrap, codes_size, flags)
Definition: vlc.h:62
SKIP_BITS
#define SKIP_BITS(name, gb, num)
Definition: get_bits.h:241
rl_vlc
static const VLCElem * rl_vlc[2]
Definition: mobiclip.c:278
MB_PTYPE_VLC_BITS
#define MB_PTYPE_VLC_BITS
Definition: mpeg12vlc.h:39
AV_ONCE_INIT
#define AV_ONCE_INIT
Definition: thread.h:203
run
uint8_t run
Definition: svq3.c:204
LAST_SKIP_BITS
#define LAST_SKIP_BITS(name, gb, num)
Definition: get_bits.h:247
MB_TYPE_QUANT
#define MB_TYPE_QUANT
Definition: mpegutils.h:49
MB_TYPE_BIDIR_MV
#define MB_TYPE_BIDIR_MV
Definition: mpegutils.h:52
ff_mpeg1_rl_vlc
RL_VLC_ELEM ff_mpeg1_rl_vlc[680]
Definition: mpeg12.c:150
MB_BTYPE_VLC_BITS
#define MB_BTYPE_VLC_BITS
Definition: mpeg12vlc.h:40
mpeg12codecs.h
AVOnce
#define AVOnce
Definition: thread.h:202
index
int index
Definition: gxfenc.c:90
ff_mpeg12_run
const int8_t ff_mpeg12_run[MPEG12_RL_NB_ELEMS]
Definition: mpeg12data.c:150
ff_init_2d_vlc_rl
av_cold void ff_init_2d_vlc_rl(const uint16_t table_vlc[][2], RL_VLC_ELEM rl_vlc[], const int8_t table_run[], const uint8_t table_level[], int n, unsigned static_size, int flags)
Definition: mpeg12.c:89
MAX_LEVEL
#define MAX_LEVEL
Definition: rl.h:36
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
RL_VLC_ELEM
Definition: vlc.h:56
ff_mpeg12_level
const int8_t ff_mpeg12_level[MPEG12_RL_NB_ELEMS]
Definition: mpeg12data.c:133
ff_mpeg1_clean_buffers
void ff_mpeg1_clean_buffers(MpegEncContext *s)
Definition: mpeg12.c:128
VLCElem
Definition: vlc.h:32
diff
static av_always_inline int diff(const struct color_info *a, const struct color_info *b, const int trans_thresh)
Definition: vf_paletteuse.c:164
OPEN_READER
#define OPEN_READER(name, gb)
Definition: get_bits.h:177
attributes.h
ff_mpeg1_decode_block_intra
int ff_mpeg1_decode_block_intra(GetBitContext *gb, const uint16_t *quant_matrix, const uint8_t *scantable, int last_dc[3], int16_t *block, int index, int qscale)
Definition: mpeg12.c:196
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
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
MB_TYPE_BACKWARD_MV
#define MB_TYPE_BACKWARD_MV
Definition: mpegutils.h:51
ff_mpeg12_init_vlcs
av_cold void ff_mpeg12_init_vlcs(void)
Definition: mpeg12.c:188
MB_PAT_VLC_BITS
#define MB_PAT_VLC_BITS
Definition: mpeg12vlc.h:38
len
int len
Definition: vorbis_enc_data.h:426
VLC_INIT_STATIC_SPARSE_TABLE
#define VLC_INIT_STATIC_SPARSE_TABLE(vlc_table, nb_bits, nb_codes, bits, bits_wrap, bits_size, codes, codes_wrap, codes_size, symbols, symbols_wrap, symbols_size, flags)
Definition: vlc.h:258
table_mb_ptype
static const uint8_t table_mb_ptype[7][2]
Definition: mpeg12.c:41
ff_mpeg12_mbPatTable
const uint8_t ff_mpeg12_mbPatTable[64][2]
Definition: mpeg12data.c:206
GET_RL_VLC
#define GET_RL_VLC(level, run, name, gb, table, bits, max_depth, need_update)
Definition: get_bits.h:606
ff_mpeg12_vlc_dc_chroma_code
const uint16_t ff_mpeg12_vlc_dc_chroma_code[12]
Definition: mpeg12data.c:60
TEX_VLC_BITS
#define TEX_VLC_BITS
Definition: dvdec.c:147
ff_mpeg1_vlc_table
const uint16_t ff_mpeg1_vlc_table[MPEG12_RL_NB_ELEMS+2][2]
Definition: mpeg12data.c:67
mpeg12data.h
SHOW_UBITS
#define SHOW_UBITS(name, gb, num)
Definition: get_bits.h:259
mpeg12dec.h
VLC_INIT_STATIC_TABLE
#define VLC_INIT_STATIC_TABLE(vlc_table, nb_bits, nb_codes, bits, bits_wrap, bits_size, codes, codes_wrap, codes_size, flags)
Definition: vlc.h:270
VLC
Definition: vlc.h:36
ff_mpeg2_vlc_table
const uint16_t ff_mpeg2_vlc_table[MPEG12_RL_NB_ELEMS+2][2]
Definition: mpeg12data.c:100
VLC::table
VLCElem * table
Definition: vlc.h:38
ff_mb_ptype_vlc
VLCElem ff_mb_ptype_vlc[64]
Definition: mpeg12.c:146
VLC::table_size
int table_size
Definition: vlc.h:39
ff_dc_chroma_vlc
VLCElem ff_dc_chroma_vlc[514]
Definition: mpeg12.c:143
rl.h
int32_t
int32_t
Definition: audioconvert.c:56
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:482
ff_mpeg12_vlc_dc_lum_code
const uint16_t ff_mpeg12_vlc_dc_lum_code[12]
Definition: mpeg12data.c:53
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
VLC_INIT_USE_STATIC
#define VLC_INIT_USE_STATIC
Definition: vlc.h:182
ff_mb_btype_vlc
VLCElem ff_mb_btype_vlc[64]
Definition: mpeg12.c:147
DC_VLC_BITS
#define DC_VLC_BITS
Definition: intrax8.c:41
MV_VLC_BITS
#define MV_VLC_BITS
Definition: mpeg12vlc.h:34
MpegEncContext
MpegEncContext.
Definition: mpegvideo.h:73
MB_TYPE_FORWARD_MV
#define MB_TYPE_FORWARD_MV
Definition: mpegutils.h:50
decode_dc
static int decode_dc(GetBitContext *gb, int component)
Definition: mpeg12dec.h:30
MB_TYPE_INTRA
#define MB_TYPE_INTRA
Definition: mpegutils.h:65
MBINCR_VLC_BITS
#define MBINCR_VLC_BITS
Definition: mpeg12vlc.h:37