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 #include "libavutil/thread.h"
34 
35 #include "internal.h"
36 #include "avcodec.h"
37 #include "mpegvideo.h"
38 #include "error_resilience.h"
39 #include "mpeg12.h"
40 #include "mpeg12data.h"
41 #include "mpegvideodata.h"
42 #include "bytestream.h"
43 #include "thread.h"
44 
45 static const uint8_t table_mb_ptype[7][2] = {
46  { 3, 5 }, // 0x01 MB_INTRA
47  { 1, 2 }, // 0x02 MB_PAT
48  { 1, 3 }, // 0x08 MB_FOR
49  { 1, 1 }, // 0x0A MB_FOR|MB_PAT
50  { 1, 6 }, // 0x11 MB_QUANT|MB_INTRA
51  { 1, 5 }, // 0x12 MB_QUANT|MB_PAT
52  { 2, 5 }, // 0x1A MB_QUANT|MB_FOR|MB_PAT
53 };
54 
55 static const uint8_t table_mb_btype[11][2] = {
56  { 3, 5 }, // 0x01 MB_INTRA
57  { 2, 3 }, // 0x04 MB_BACK
58  { 3, 3 }, // 0x06 MB_BACK|MB_PAT
59  { 2, 4 }, // 0x08 MB_FOR
60  { 3, 4 }, // 0x0A MB_FOR|MB_PAT
61  { 2, 2 }, // 0x0C MB_FOR|MB_BACK
62  { 3, 2 }, // 0x0E MB_FOR|MB_BACK|MB_PAT
63  { 1, 6 }, // 0x11 MB_QUANT|MB_INTRA
64  { 2, 6 }, // 0x16 MB_QUANT|MB_BACK|MB_PAT
65  { 3, 6 }, // 0x1A MB_QUANT|MB_FOR|MB_PAT
66  { 2, 5 }, // 0x1E MB_QUANT|MB_FOR|MB_BACK|MB_PAT
67 };
68 
69 av_cold void ff_init_2d_vlc_rl(RLTable *rl, unsigned static_size, int flags)
70 {
71  int i;
72  VLC_TYPE table[680][2] = {{0}};
73  VLC vlc = { .table = table, .table_allocated = static_size };
74  av_assert0(static_size <= FF_ARRAY_ELEMS(table));
75  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);
76 
77  for (i = 0; i < vlc.table_size; i++) {
78  int code = vlc.table[i][0];
79  int len = vlc.table[i][1];
80  int level, run;
81 
82  if (len == 0) { // illegal code
83  run = 65;
84  level = MAX_LEVEL;
85  } else if (len<0) { //more bits needed
86  run = 0;
87  level = code;
88  } else {
89  if (code == rl->n) { //esc
90  run = 65;
91  level = 0;
92  } else if (code == rl->n+1) { //eob
93  run = 0;
94  level = 127;
95  } else {
96  run = rl->table_run [code] + 1;
97  level = rl->table_level[code];
98  }
99  }
100  rl->rl_vlc[0][i].len = len;
101  rl->rl_vlc[0][i].level = level;
102  rl->rl_vlc[0][i].run = run;
103  }
104 }
105 
107 {
108 
109  s->y_dc_scale_table =
111 
112 }
113 
115 {
116  s->last_dc[0] = 1 << (7 + s->intra_dc_precision);
117  s->last_dc[1] = s->last_dc[0];
118  s->last_dc[2] = s->last_dc[0];
119  memset(s->last_mv, 0, sizeof(s->last_mv));
120 }
121 
122 
123 /******************************************/
124 /* decoding */
125 
127 
130 
135 
136 static av_cold void mpeg12_init_vlcs(void)
137 {
138  INIT_VLC_STATIC(&ff_dc_lum_vlc, DC_VLC_BITS, 12,
140  ff_mpeg12_vlc_dc_lum_code, 2, 2, 512);
141  INIT_VLC_STATIC(&ff_dc_chroma_vlc, DC_VLC_BITS, 12,
143  ff_mpeg12_vlc_dc_chroma_code, 2, 2, 514);
144  INIT_VLC_STATIC(&ff_mv_vlc, MV_VLC_BITS, 17,
145  &ff_mpeg12_mbMotionVectorTable[0][1], 2, 1,
146  &ff_mpeg12_mbMotionVectorTable[0][0], 2, 1, 266);
147  INIT_VLC_STATIC(&ff_mbincr_vlc, MBINCR_VLC_BITS, 36,
148  &ff_mpeg12_mbAddrIncrTable[0][1], 2, 1,
149  &ff_mpeg12_mbAddrIncrTable[0][0], 2, 1, 538);
150  INIT_VLC_STATIC(&ff_mb_pat_vlc, MB_PAT_VLC_BITS, 64,
151  &ff_mpeg12_mbPatTable[0][1], 2, 1,
152  &ff_mpeg12_mbPatTable[0][0], 2, 1, 512);
153 
154  INIT_VLC_STATIC(&ff_mb_ptype_vlc, MB_PTYPE_VLC_BITS, 7,
155  &table_mb_ptype[0][1], 2, 1,
156  &table_mb_ptype[0][0], 2, 1, 64);
157  INIT_VLC_STATIC(&ff_mb_btype_vlc, MB_BTYPE_VLC_BITS, 11,
158  &table_mb_btype[0][1], 2, 1,
159  &table_mb_btype[0][0], 2, 1, 64);
160 
161  INIT_2D_VLC_RL(ff_rl_mpeg1, 680, 0);
162  INIT_2D_VLC_RL(ff_rl_mpeg2, 674, 0);
163 }
164 
166 {
167  static AVOnce init_static_once = AV_ONCE_INIT;
168  ff_thread_once(&init_static_once, mpeg12_init_vlcs);
169 }
170 
171 /**
172  * Find the end of the current frame in the bitstream.
173  * @return the position of the first byte of the next frame, or -1
174  */
176 {
177  int i;
178  uint32_t state = pc->state;
179 
180  /* EOF considered as end of frame */
181  if (buf_size == 0)
182  return 0;
183 
184 /*
185  0 frame start -> 1/4
186  1 first_SEQEXT -> 0/2
187  2 first field start -> 3/0
188  3 second_SEQEXT -> 2/0
189  4 searching end
190 */
191 
192  for (i = 0; i < buf_size; i++) {
193  av_assert1(pc->frame_start_found >= 0 && pc->frame_start_found <= 4);
194  if (pc->frame_start_found & 1) {
195  if (state == EXT_START_CODE && (buf[i] & 0xF0) != 0x80)
196  pc->frame_start_found--;
197  else if (state == EXT_START_CODE + 2) {
198  if ((buf[i] & 3) == 3)
199  pc->frame_start_found = 0;
200  else
201  pc->frame_start_found = (pc->frame_start_found + 1) & 3;
202  }
203  state++;
204  } else {
205  i = avpriv_find_start_code(buf + i, buf + buf_size, &state) - buf - 1;
206  if (pc->frame_start_found == 0 && state >= SLICE_MIN_START_CODE && state <= SLICE_MAX_START_CODE) {
207  i++;
208  pc->frame_start_found = 4;
209  }
210  if (state == SEQ_END_CODE) {
211  pc->frame_start_found = 0;
212  pc->state=-1;
213  return i+1;
214  }
215  if (pc->frame_start_found == 2 && state == SEQ_START_CODE)
216  pc->frame_start_found = 0;
217  if (pc->frame_start_found < 4 && state == EXT_START_CODE)
218  pc->frame_start_found++;
219  if (pc->frame_start_found == 4 && (state & 0xFFFFFF00) == 0x100) {
220  if (state < SLICE_MIN_START_CODE || state > SLICE_MAX_START_CODE) {
221  pc->frame_start_found = 0;
222  pc->state = -1;
223  return i - 3;
224  }
225  }
226  if (pc->frame_start_found == 0 && s && state == PICTURE_START_CODE) {
227  ff_fetch_timestamp(s, i - 3, 1, i > 3);
228  }
229  }
230  }
231  pc->state = state;
232  return END_NOT_FOUND;
233 }
234 
235 #define MAX_INDEX (64 - 1)
236 
238  const uint16_t *quant_matrix,
239  uint8_t *const scantable, int last_dc[3],
240  int16_t *block, int index, int qscale)
241 {
242  int dc, diff, i = 0, component;
243  RLTable *rl = &ff_rl_mpeg1;
244 
245  /* DC coefficient */
246  component = index <= 3 ? 0 : index - 4 + 1;
247 
248  diff = decode_dc(gb, component);
249  if (diff >= 0xffff)
250  return AVERROR_INVALIDDATA;
251 
252  dc = last_dc[component];
253  dc += diff;
254  last_dc[component] = dc;
255 
256  block[0] = dc * quant_matrix[0];
257 
258  {
259  OPEN_READER(re, gb);
260  UPDATE_CACHE(re, gb);
261  if (((int32_t)GET_CACHE(re, gb)) <= (int32_t)0xBFFFFFFF)
262  goto end;
263 
264  /* now quantify & encode AC coefficients */
265  while (1) {
266  int level, run, j;
267 
268  GET_RL_VLC(level, run, re, gb, rl->rl_vlc[0],
269  TEX_VLC_BITS, 2, 0);
270 
271  if (level != 0) {
272  i += run;
273  if (i > MAX_INDEX)
274  break;
275 
276  j = scantable[i];
277  level = (level * qscale * quant_matrix[j]) >> 4;
278  level = (level - 1) | 1;
279  level = (level ^ SHOW_SBITS(re, gb, 1)) -
280  SHOW_SBITS(re, gb, 1);
281  SKIP_BITS(re, gb, 1);
282  } else {
283  /* escape */
284  run = SHOW_UBITS(re, gb, 6) + 1;
285  LAST_SKIP_BITS(re, gb, 6);
286  UPDATE_CACHE(re, gb);
287  level = SHOW_SBITS(re, gb, 8);
288  SKIP_BITS(re, gb, 8);
289 
290  if (level == -128) {
291  level = SHOW_UBITS(re, gb, 8) - 256;
292  SKIP_BITS(re, gb, 8);
293  } else if (level == 0) {
294  level = SHOW_UBITS(re, gb, 8);
295  SKIP_BITS(re, gb, 8);
296  }
297 
298  i += run;
299  if (i > MAX_INDEX)
300  break;
301 
302  j = scantable[i];
303  if (level < 0) {
304  level = -level;
305  level = (level * qscale * quant_matrix[j]) >> 4;
306  level = (level - 1) | 1;
307  level = -level;
308  } else {
309  level = (level * qscale * quant_matrix[j]) >> 4;
310  level = (level - 1) | 1;
311  }
312  }
313 
314  block[j] = level;
315  if (((int32_t)GET_CACHE(re, gb)) <= (int32_t)0xBFFFFFFF)
316  break;
317 
318  UPDATE_CACHE(re, gb);
319  }
320 end:
321  LAST_SKIP_BITS(re, gb, 2);
322  CLOSE_READER(re, gb);
323  }
324 
325  if (i > MAX_INDEX)
327 
328  return i;
329 }
int table_size
Definition: vlc.h:29
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
#define SLICE_MAX_START_CODE
Definition: cavs.h:34
VLC ff_dc_lum_vlc
Definition: mpeg12.c:128
const uint8_t * y_dc_scale_table
qscale -> y_dc_scale table
Definition: mpegvideo.h:188
int last_mv[2][2][2]
last MV, used for MV prediction in MPEG-1 & B-frame MPEG-4
Definition: mpegvideo.h:278
float re
Definition: fft.c:82
av_cold void ff_mpeg12_init_vlcs(void)
Definition: mpeg12.c:165
#define INIT_VLC_STATIC(vlc, bits, a, b, c, d, e, f, g, static_size)
Definition: vlc.h:120
const unsigned char ff_mpeg12_vlc_dc_lum_bits[12]
Definition: mpeg12data.c:55
void ff_mpeg1_clean_buffers(MpegEncContext *s)
Definition: mpeg12.c:114
mpegvideo header.
#define FF_ARRAY_ELEMS(a)
const uint16_t ff_mpeg12_vlc_dc_lum_code[12]
Definition: mpeg12data.c:52
const int8_t * table_level
Definition: rl.h:44
uint8_t run
Definition: svq3.c:205
#define SLICE_MIN_START_CODE
Definition: mpegvideo.h:71
int frame_start_found
Definition: parser.h:34
RLTable.
Definition: rl.h:39
Macro definitions for various function/variable attributes.
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
#define MBINCR_VLC_BITS
Definition: mpeg12vlc.h:37
The exact code depends on how similar the blocks are and how related they are to the block
uint8_t
#define av_cold
Definition: attributes.h:88
#define INIT_2D_VLC_RL(rl, static_size, flags)
Definition: mpeg12.h:30
RLTable ff_rl_mpeg2
Definition: mpeg12data.c:174
Multithreading support functions.
int intra_dc_precision
Definition: mpegvideo.h:469
static const uint8_t table_mb_ptype[7][2]
Definition: mpeg12.c:45
static struct @321 state
#define AVOnce
Definition: thread.h:172
VLC ff_mv_vlc
Definition: mpeg12.c:126
#define MAX_LEVEL
Definition: rl.h:36
const uint8_t * avpriv_find_start_code(const uint8_t *p, const uint8_t *end, uint32_t *state)
static const uint16_t table[]
Definition: prosumer.c:206
#define MAX_INDEX
Definition: mpeg12.c:235
#define UPDATE_CACHE(name, gb)
Definition: get_bits.h:178
int last_dc[3]
last DC values for MPEG-1
Definition: mpegvideo.h:185
#define init_vlc(vlc, nb_bits, nb_codes,bits, bits_wrap, bits_size,codes, codes_wrap, codes_size,flags)
Definition: vlc.h:38
const uint16_t ff_mpeg12_vlc_dc_chroma_code[12]
Definition: mpeg12data.c:59
simple assert() macros that are a bit more flexible than ISO C assert().
#define SEQ_END_CODE
Definition: mpegvideo.h:67
#define CLOSE_READER(name, gb)
Definition: get_bits.h:149
VLC ff_mb_pat_vlc
Definition: mpeg12.c:134
static int decode_dc(GetBitContext *gb, int component)
Definition: mpeg12.h:40
int8_t len
Definition: vlc.h:34
#define GET_RL_VLC(level, run, name, gb, table, bits,max_depth, need_update)
Definition: get_bits.h:738
Definition: vlc.h:26
#define SKIP_BITS(name, gb, num)
Definition: get_bits.h:193
av_cold void ff_init_2d_vlc_rl(RLTable *rl, unsigned static_size, int flags)
Definition: mpeg12.c:69
static const uint8_t table_mb_btype[11][2]
Definition: mpeg12.c:55
const uint8_t *const ff_mpeg2_dc_scale_table[4]
Definition: mpegvideodata.c:77
int n
number of entries of table_vlc minus 1
Definition: rl.h:40
#define MB_PAT_VLC_BITS
Definition: mpeg12vlc.h:38
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
const uint16_t(* table_vlc)[2]
Definition: rl.h:42
const unsigned char ff_mpeg12_vlc_dc_chroma_bits[12]
Definition: mpeg12data.c:62
RLTable ff_rl_mpeg1
Definition: mpeg12data.c:166
#define MB_BTYPE_VLC_BITS
Definition: mpeg12vlc.h:40
int32_t
const int8_t * table_run
Definition: rl.h:43
#define s(width, name)
Definition: cbs_vp9.c:257
#define LAST_SKIP_BITS(name, gb, num)
Definition: get_bits.h:199
#define EXT_START_CODE
Definition: cavs.h:35
static av_cold void mpeg12_init_vlcs(void)
Definition: mpeg12.c:136
RL_VLC_ELEM * rl_vlc[32]
decoding only
Definition: rl.h:48
#define SHOW_UBITS(name, gb, num)
Definition: get_bits.h:211
#define AV_ONCE_INIT
Definition: thread.h:173
VLC ff_dc_chroma_vlc
Definition: mpeg12.c:129
Libavcodec external API header.
Timecode helpers header.
#define MB_PTYPE_VLC_BITS
Definition: mpeg12vlc.h:39
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
MPEG-1/2 tables.
#define OPEN_READER(name, gb)
Definition: get_bits.h:138
uint32_t state
contains the last few bytes in MSB order
Definition: parser.h:33
int index
Definition: gxfenc.c:89
VLC ff_mb_ptype_vlc
Definition: mpeg12.c:132
#define GET_CACHE(name, gb)
Definition: get_bits.h:215
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:175
#define END_NOT_FOUND
Definition: parser.h:40
av_cold void ff_mpeg12_common_init(MpegEncContext *s)
Definition: mpeg12.c:106
#define flags(name, subs,...)
Definition: cbs_av1.c:561
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
const uint8_t * c_dc_scale_table
qscale -> c_dc_scale table
Definition: mpegvideo.h:189
uint8_t level
Definition: svq3.c:206
#define DC_VLC_BITS
Definition: intrax8.c:40
MpegEncContext.
Definition: mpegvideo.h:81
uint8_t run
Definition: vlc.h:35
#define SHOW_SBITS(name, gb, num)
Definition: get_bits.h:212
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:237
common internal api header.
#define TEX_VLC_BITS
Definition: dv.h:99
#define INIT_VLC_USE_NEW_STATIC
Definition: vlc.h:95
VLC ff_mbincr_vlc
Definition: mpeg12.c:131
const uint8_t ff_mpeg12_mbPatTable[64][2]
Definition: mpeg12data.c:221
static av_always_inline int diff(const uint32_t a, const uint32_t b)
int len
#define SEQ_START_CODE
Definition: mpegvideo.h:68
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:175
const uint8_t ff_mpeg12_mbAddrIncrTable[36][2]
Definition: mpeg12data.c:182
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
int16_t level
Definition: vlc.h:33
const uint8_t ff_mpeg12_mbMotionVectorTable[17][2]
Definition: mpeg12data.c:288
#define PICTURE_START_CODE
Definition: mpegvideo.h:70
#define VLC_TYPE
Definition: vlc.h:24
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
#define MV_VLC_BITS
Definition: mpeg12vlc.h:34
int i
Definition: input.c:407
VLC ff_mb_btype_vlc
Definition: mpeg12.c:133