FFmpeg
mpeg4videodec.c
Go to the documentation of this file.
1 /*
2  * MPEG-4 decoder
3  * Copyright (c) 2000,2001 Fabrice Bellard
4  * Copyright (c) 2002-2010 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 #define UNCHECKED_BITSTREAM_READER 1
24 
25 #include "config_components.h"
26 
27 #include "libavutil/internal.h"
28 #include "libavutil/opt.h"
29 #include "libavutil/thread.h"
30 #include "codec_internal.h"
31 #include "error_resilience.h"
32 #include "hwconfig.h"
33 #include "idctdsp.h"
34 #include "mpegutils.h"
35 #include "mpegvideo.h"
36 #include "mpegvideodata.h"
37 #include "mpegvideodec.h"
38 #include "mpeg4video.h"
39 #include "mpeg4videodata.h"
40 #include "mpeg4videodec.h"
41 #include "mpeg4videodefs.h"
42 #include "h263.h"
43 #include "h263data.h"
44 #include "h263dec.h"
45 #include "internal.h"
46 #include "profiles.h"
47 #include "qpeldsp.h"
48 #include "threadprogress.h"
49 #include "xvididct.h"
50 #include "unary.h"
51 
52 #if 0 //3IV1 is quite rare and it slows things down a tiny bit
53 #define IS_3IV1 (s->codec_tag == AV_RL32("3IV1"))
54 #else
55 #define IS_3IV1 0
56 #endif
57 
58 /* The defines below define the number of bits that are read at once for
59  * reading vlc values. Changing these may improve speed and data cache needs
60  * be aware though that decreasing them may need the number of stages that is
61  * passed to get_vlc* to be increased. */
62 #define SPRITE_TRAJ_VLC_BITS 6
63 #define DC_VLC_BITS 9
64 #define MB_TYPE_B_VLC_BITS 4
65 #define STUDIO_INTRA_BITS 9
66 
67 static VLCElem dc_lum[512], dc_chrom[512];
68 static VLCElem sprite_trajectory[128];
69 static VLCElem mb_type_b_vlc[16];
70 static const VLCElem *studio_intra_tab[12];
71 static VLCElem studio_luma_dc[528];
72 static VLCElem studio_chroma_dc[528];
73 
74 static const uint8_t mpeg4_block_count[4] = { 0, 6, 8, 12 };
75 
76 static const int16_t mb_type_b_map[4] = {
77  MB_TYPE_DIRECT2 | MB_TYPE_BIDIR_MV,
78  MB_TYPE_BIDIR_MV | MB_TYPE_16x16,
79  MB_TYPE_BACKWARD_MV | MB_TYPE_16x16,
80  MB_TYPE_FORWARD_MV | MB_TYPE_16x16,
81 };
82 
83 static void gmc1_motion(MpegEncContext *s, const Mpeg4DecContext *ctx,
84  uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
85  uint8_t *const *ref_picture)
86 {
87  const uint8_t *ptr;
88  int src_x, src_y, motion_x, motion_y;
89  ptrdiff_t offset, linesize, uvlinesize;
90  int emu = 0;
91 
92  motion_x = ctx->sprite_offset[0][0];
93  motion_y = ctx->sprite_offset[0][1];
94  src_x = s->mb_x * 16 + (motion_x >> (ctx->sprite_warping_accuracy + 1));
95  src_y = s->mb_y * 16 + (motion_y >> (ctx->sprite_warping_accuracy + 1));
96  motion_x *= 1 << (3 - ctx->sprite_warping_accuracy);
97  motion_y *= 1 << (3 - ctx->sprite_warping_accuracy);
98  src_x = av_clip(src_x, -16, s->width);
99  if (src_x == s->width)
100  motion_x = 0;
101  src_y = av_clip(src_y, -16, s->height);
102  if (src_y == s->height)
103  motion_y = 0;
104 
105  linesize = s->linesize;
106  uvlinesize = s->uvlinesize;
107 
108  ptr = ref_picture[0] + src_y * linesize + src_x;
109 
110  if ((unsigned)src_x >= FFMAX(s->h_edge_pos - 17, 0) ||
111  (unsigned)src_y >= FFMAX(s->v_edge_pos - 17, 0)) {
112  s->vdsp.emulated_edge_mc(s->sc.edge_emu_buffer, ptr,
113  linesize, linesize,
114  17, 17,
115  src_x, src_y,
116  s->h_edge_pos, s->v_edge_pos);
117  ptr = s->sc.edge_emu_buffer;
118  }
119 
120  if ((motion_x | motion_y) & 7) {
121  ctx->mdsp.gmc1(dest_y, ptr, linesize, 16,
122  motion_x & 15, motion_y & 15, 128 - s->no_rounding);
123  ctx->mdsp.gmc1(dest_y + 8, ptr + 8, linesize, 16,
124  motion_x & 15, motion_y & 15, 128 - s->no_rounding);
125  } else {
126  int dxy;
127 
128  dxy = ((motion_x >> 3) & 1) | ((motion_y >> 2) & 2);
129  if (s->no_rounding) {
130  s->hdsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
131  } else {
132  s->hdsp.put_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
133  }
134  }
135 
136  if (CONFIG_GRAY && s->avctx->flags & AV_CODEC_FLAG_GRAY)
137  return;
138 
139  motion_x = ctx->sprite_offset[1][0];
140  motion_y = ctx->sprite_offset[1][1];
141  src_x = s->mb_x * 8 + (motion_x >> (ctx->sprite_warping_accuracy + 1));
142  src_y = s->mb_y * 8 + (motion_y >> (ctx->sprite_warping_accuracy + 1));
143  motion_x *= 1 << (3 - ctx->sprite_warping_accuracy);
144  motion_y *= 1 << (3 - ctx->sprite_warping_accuracy);
145  src_x = av_clip(src_x, -8, s->width >> 1);
146  if (src_x == s->width >> 1)
147  motion_x = 0;
148  src_y = av_clip(src_y, -8, s->height >> 1);
149  if (src_y == s->height >> 1)
150  motion_y = 0;
151 
152  offset = (src_y * uvlinesize) + src_x;
153  ptr = ref_picture[1] + offset;
154  if ((unsigned)src_x >= FFMAX((s->h_edge_pos >> 1) - 9, 0) ||
155  (unsigned)src_y >= FFMAX((s->v_edge_pos >> 1) - 9, 0)) {
156  s->vdsp.emulated_edge_mc(s->sc.edge_emu_buffer, ptr,
157  uvlinesize, uvlinesize,
158  9, 9,
159  src_x, src_y,
160  s->h_edge_pos >> 1, s->v_edge_pos >> 1);
161  ptr = s->sc.edge_emu_buffer;
162  emu = 1;
163  }
164  ctx->mdsp.gmc1(dest_cb, ptr, uvlinesize, 8,
165  motion_x & 15, motion_y & 15, 128 - s->no_rounding);
166 
167  ptr = ref_picture[2] + offset;
168  if (emu) {
169  s->vdsp.emulated_edge_mc(s->sc.edge_emu_buffer, ptr,
170  uvlinesize, uvlinesize,
171  9, 9,
172  src_x, src_y,
173  s->h_edge_pos >> 1, s->v_edge_pos >> 1);
174  ptr = s->sc.edge_emu_buffer;
175  }
176  ctx->mdsp.gmc1(dest_cr, ptr, uvlinesize, 8,
177  motion_x & 15, motion_y & 15, 128 - s->no_rounding);
178 }
179 
180 static void gmc_motion(MpegEncContext *s, const Mpeg4DecContext *ctx,
181  uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
182  uint8_t *const *ref_picture)
183 {
184  const uint8_t *ptr;
185  int linesize, uvlinesize;
186  const int a = ctx->sprite_warping_accuracy;
187  int ox, oy;
188 
189  linesize = s->linesize;
190  uvlinesize = s->uvlinesize;
191 
192  ptr = ref_picture[0];
193 
194  ox = ctx->sprite_offset[0][0] + ctx->sprite_delta[0][0] * s->mb_x * 16 +
195  ctx->sprite_delta[0][1] * s->mb_y * 16;
196  oy = ctx->sprite_offset[0][1] + ctx->sprite_delta[1][0] * s->mb_x * 16 +
197  ctx->sprite_delta[1][1] * s->mb_y * 16;
198 
199  ctx->mdsp.gmc(dest_y, ptr, linesize, 16,
200  ox, oy,
201  ctx->sprite_delta[0][0], ctx->sprite_delta[0][1],
202  ctx->sprite_delta[1][0], ctx->sprite_delta[1][1],
203  a + 1, (1 << (2 * a + 1)) - s->no_rounding,
204  s->h_edge_pos, s->v_edge_pos);
205  ctx->mdsp.gmc(dest_y + 8, ptr, linesize, 16,
206  ox + ctx->sprite_delta[0][0] * 8,
207  oy + ctx->sprite_delta[1][0] * 8,
208  ctx->sprite_delta[0][0], ctx->sprite_delta[0][1],
209  ctx->sprite_delta[1][0], ctx->sprite_delta[1][1],
210  a + 1, (1 << (2 * a + 1)) - s->no_rounding,
211  s->h_edge_pos, s->v_edge_pos);
212 
213  if (CONFIG_GRAY && s->avctx->flags & AV_CODEC_FLAG_GRAY)
214  return;
215 
216  ox = ctx->sprite_offset[1][0] + ctx->sprite_delta[0][0] * s->mb_x * 8 +
217  ctx->sprite_delta[0][1] * s->mb_y * 8;
218  oy = ctx->sprite_offset[1][1] + ctx->sprite_delta[1][0] * s->mb_x * 8 +
219  ctx->sprite_delta[1][1] * s->mb_y * 8;
220 
221  ptr = ref_picture[1];
222  ctx->mdsp.gmc(dest_cb, ptr, uvlinesize, 8,
223  ox, oy,
224  ctx->sprite_delta[0][0], ctx->sprite_delta[0][1],
225  ctx->sprite_delta[1][0], ctx->sprite_delta[1][1],
226  a + 1, (1 << (2 * a + 1)) - s->no_rounding,
227  (s->h_edge_pos + 1) >> 1, (s->v_edge_pos + 1) >> 1);
228 
229  ptr = ref_picture[2];
230  ctx->mdsp.gmc(dest_cr, ptr, uvlinesize, 8,
231  ox, oy,
232  ctx->sprite_delta[0][0], ctx->sprite_delta[0][1],
233  ctx->sprite_delta[1][0], ctx->sprite_delta[1][1],
234  a + 1, (1 << (2 * a + 1)) - s->no_rounding,
235  (s->h_edge_pos + 1) >> 1, (s->v_edge_pos + 1) >> 1);
236 }
237 
238 void ff_mpeg4_mcsel_motion(MpegEncContext *s,
239  uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
240  uint8_t *const *ref_picture)
241 {
242  const Mpeg4DecContext *const ctx = (Mpeg4DecContext*)s;
243 
244  if (ctx->real_sprite_warping_points == 1) {
245  gmc1_motion(s, ctx, dest_y, dest_cb, dest_cr,
246  ref_picture);
247  } else {
248  gmc_motion(s, ctx, dest_y, dest_cb, dest_cr,
249  ref_picture);
250  }
251 }
252 
253 void ff_mpeg4_decode_studio(MpegEncContext *s, uint8_t *dest_y, uint8_t *dest_cb,
254  uint8_t *dest_cr, int block_size, int uvlinesize,
255  int dct_linesize, int dct_offset)
256 {
257  Mpeg4DecContext *const ctx = (Mpeg4DecContext*)s;
258  const int act_block_size = block_size * 2;
259 
260  if (ctx->dpcm_direction == 0) {
261  s->idsp.idct_put(dest_y, dct_linesize, (int16_t*)ctx->block32[0]);
262  s->idsp.idct_put(dest_y + act_block_size, dct_linesize, (int16_t*)ctx->block32[1]);
263  s->idsp.idct_put(dest_y + dct_offset, dct_linesize, (int16_t*)ctx->block32[2]);
264  s->idsp.idct_put(dest_y + dct_offset + act_block_size, dct_linesize, (int16_t*)ctx->block32[3]);
265 
266  dct_linesize = uvlinesize << s->interlaced_dct;
267  dct_offset = s->interlaced_dct ? uvlinesize : uvlinesize*block_size;
268 
269  s->idsp.idct_put(dest_cb, dct_linesize, (int16_t*)ctx->block32[4]);
270  s->idsp.idct_put(dest_cr, dct_linesize, (int16_t*)ctx->block32[5]);
271  s->idsp.idct_put(dest_cb + dct_offset, dct_linesize, (int16_t*)ctx->block32[6]);
272  s->idsp.idct_put(dest_cr + dct_offset, dct_linesize, (int16_t*)ctx->block32[7]);
273  if (!s->chroma_x_shift){ //Chroma444
274  s->idsp.idct_put(dest_cb + act_block_size, dct_linesize, (int16_t*)ctx->block32[8]);
275  s->idsp.idct_put(dest_cr + act_block_size, dct_linesize, (int16_t*)ctx->block32[9]);
276  s->idsp.idct_put(dest_cb + act_block_size + dct_offset, dct_linesize, (int16_t*)ctx->block32[10]);
277  s->idsp.idct_put(dest_cr + act_block_size + dct_offset, dct_linesize, (int16_t*)ctx->block32[11]);
278  }
279  } else if (ctx->dpcm_direction == 1) {
280  uint16_t *dest_pcm[3] = {(uint16_t*)dest_y, (uint16_t*)dest_cb, (uint16_t*)dest_cr};
281  int linesize[3] = {dct_linesize, uvlinesize, uvlinesize};
282  for (int i = 0; i < 3; i++) {
283  const uint16_t *src = ctx->dpcm_macroblock[i];
284  int vsub = i ? s->chroma_y_shift : 0;
285  int hsub = i ? s->chroma_x_shift : 0;
286  int lowres = s->avctx->lowres;
287  int step = 1 << lowres;
288  for (int h = 0; h < (16 >> (vsub + lowres)); h++){
289  for (int w = 0, idx = 0; w < (16 >> (hsub + lowres)); w++, idx += step)
290  dest_pcm[i][w] = src[idx];
291  dest_pcm[i] += linesize[i] / 2;
292  src += (16 >> hsub) * step;
293  }
294  }
295  } else {
296  uint16_t *dest_pcm[3] = {(uint16_t*)dest_y, (uint16_t*)dest_cb, (uint16_t*)dest_cr};
297  int linesize[3] = {dct_linesize, uvlinesize, uvlinesize};
298  av_assert2(ctx->dpcm_direction == -1);
299  for (int i = 0; i < 3; i++) {
300  const uint16_t *src = ctx->dpcm_macroblock[i];
301  int vsub = i ? s->chroma_y_shift : 0;
302  int hsub = i ? s->chroma_x_shift : 0;
303  int lowres = s->avctx->lowres;
304  int step = 1 << lowres;
305  dest_pcm[i] += (linesize[i] / 2) * ((16 >> vsub + lowres) - 1);
306  for (int h = (16 >> (vsub + lowres)) - 1; h >= 0; h--){
307  for (int w = (16 >> (hsub + lowres)) - 1, idx = 0; w >= 0; w--, idx += step)
308  dest_pcm[i][w] = src[idx];
309  src += step * (16 >> hsub);
310  dest_pcm[i] -= linesize[i] / 2;
311  }
312  }
313  }
314 }
315 
316 /**
317  * Predict the ac.
318  * @param n block index (0-3 are luma, 4-5 are chroma)
319  * @param dir the ac prediction direction
320  */
321 void ff_mpeg4_pred_ac(MpegEncContext *s, int16_t *block, int n, int dir)
322 {
323  int i;
324  int16_t *ac_val, *ac_val1;
325  int8_t *const qscale_table = s->cur_pic.qscale_table;
326 
327  /* find prediction */
328  ac_val = &s->ac_val[0][0][0] + s->block_index[n] * 16;
329  ac_val1 = ac_val;
330  if (s->ac_pred) {
331  if (dir == 0) {
332  const int xy = s->mb_x - 1 + s->mb_y * s->mb_stride;
333  /* left prediction */
334  ac_val -= 16;
335 
336  if (s->mb_x == 0 || s->qscale == qscale_table[xy] ||
337  n == 1 || n == 3) {
338  /* same qscale */
339  for (i = 1; i < 8; i++)
340  block[s->idsp.idct_permutation[i << 3]] += ac_val[i];
341  } else {
342  /* different qscale, we must rescale */
343  for (i = 1; i < 8; i++)
344  block[s->idsp.idct_permutation[i << 3]] += ROUNDED_DIV(ac_val[i] * qscale_table[xy], s->qscale);
345  }
346  } else {
347  const int xy = s->mb_x + s->mb_y * s->mb_stride - s->mb_stride;
348  /* top prediction */
349  ac_val -= 16 * s->block_wrap[n];
350 
351  if (s->mb_y == 0 || s->qscale == qscale_table[xy] ||
352  n == 2 || n == 3) {
353  /* same qscale */
354  for (i = 1; i < 8; i++)
355  block[s->idsp.idct_permutation[i]] += ac_val[i + 8];
356  } else {
357  /* different qscale, we must rescale */
358  for (i = 1; i < 8; i++)
359  block[s->idsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8] * qscale_table[xy], s->qscale);
360  }
361  }
362  }
363  /* left copy */
364  for (i = 1; i < 8; i++)
365  ac_val1[i] = block[s->idsp.idct_permutation[i << 3]];
366 
367  /* top copy */
368  for (i = 1; i < 8; i++)
369  ac_val1[8 + i] = block[s->idsp.idct_permutation[i]];
370 }
371 
372 /**
373  * check if the next stuff is a resync marker or the end.
374  * @return 0 if not
375  */
376 static inline int mpeg4_is_resync(Mpeg4DecContext *ctx)
377 {
378  MpegEncContext *s = &ctx->m;
379  int bits_count = get_bits_count(&s->gb);
380  int v = show_bits(&s->gb, 16);
381 
382  if (s->workaround_bugs & FF_BUG_NO_PADDING && !ctx->resync_marker)
383  return 0;
384 
385  while (v <= 0xFF) {
386  if (s->pict_type == AV_PICTURE_TYPE_B ||
387  (v >> (8 - s->pict_type) != 1) || s->partitioned_frame)
388  break;
389  skip_bits(&s->gb, 8 + s->pict_type);
390  bits_count += 8 + s->pict_type;
391  v = show_bits(&s->gb, 16);
392  }
393 
394  if (bits_count + 8 >= s->gb.size_in_bits) {
395  v >>= 8;
396  v |= 0x7F >> (7 - (bits_count & 7));
397 
398  if (v == 0x7F)
399  return s->mb_num;
400  } else {
401  static const uint16_t mpeg4_resync_prefix[8] = {
402  0x7F00, 0x7E00, 0x7C00, 0x7800, 0x7000, 0x6000, 0x4000, 0x0000
403  };
404 
405  if (v == mpeg4_resync_prefix[bits_count & 7]) {
406  int len, mb_num;
407  int mb_num_bits = av_log2(s->mb_num - 1) + 1;
408  GetBitContext gb = s->gb;
409 
410  skip_bits(&s->gb, 1);
411  align_get_bits(&s->gb);
412 
413  for (len = 0; len < 32; len++)
414  if (get_bits1(&s->gb))
415  break;
416 
417  mb_num = get_bits(&s->gb, mb_num_bits);
418  if (!mb_num || mb_num > s->mb_num || get_bits_count(&s->gb)+6 > s->gb.size_in_bits)
419  mb_num= -1;
420 
421  s->gb = gb;
422 
423  if (len >= ff_mpeg4_get_video_packet_prefix_length(s))
424  return mb_num;
425  }
426  }
427  return 0;
428 }
429 
430 static int mpeg4_decode_sprite_trajectory(Mpeg4DecContext *ctx, GetBitContext *gb)
431 {
432  MpegEncContext *s = &ctx->m;
433  int a = 2 << ctx->sprite_warping_accuracy;
434  int rho = 3 - ctx->sprite_warping_accuracy;
435  int r = 16 / a;
436  int alpha = 1;
437  int beta = 0;
438  int w = s->width;
439  int h = s->height;
440  int min_ab, i, w2, h2, w3, h3;
441  int sprite_ref[4][2];
442  int virtual_ref[2][2];
443  int64_t sprite_offset[2][2];
444  int64_t sprite_delta[2][2];
445 
446  // only true for rectangle shapes
447  const int vop_ref[4][2] = { { 0, 0 }, { s->width, 0 },
448  { 0, s->height }, { s->width, s->height } };
449  int d[4][2] = { { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 } };
450 
451  if (w <= 0 || h <= 0)
452  return AVERROR_INVALIDDATA;
453 
454  for (i = 0; i < ctx->num_sprite_warping_points; i++) {
455  int length;
456  int x = 0, y = 0;
457 
458  length = get_vlc2(gb, sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 2);
459  if (length > 0)
460  x = get_xbits(gb, length);
461 
462  if (!(ctx->divx_version == 500 && ctx->divx_build == 413))
463  check_marker(s->avctx, gb, "before sprite_trajectory");
464 
465  length = get_vlc2(gb, sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 2);
466  if (length > 0)
467  y = get_xbits(gb, length);
468 
469  check_marker(s->avctx, gb, "after sprite_trajectory");
470  ctx->sprite_traj[i][0] = d[i][0] = x;
471  ctx->sprite_traj[i][1] = d[i][1] = y;
472  }
473  for (; i < 4; i++)
474  ctx->sprite_traj[i][0] = ctx->sprite_traj[i][1] = 0;
475 
476  while ((1 << alpha) < w)
477  alpha++;
478  while ((1 << beta) < h)
479  beta++; /* typo in the MPEG-4 std for the definition of w' and h' */
480  w2 = 1 << alpha;
481  h2 = 1 << beta;
482 
483  // Note, the 4th point isn't used for GMC
484  if (ctx->divx_version == 500 && ctx->divx_build == 413) {
485  sprite_ref[0][0] = a * vop_ref[0][0] + d[0][0];
486  sprite_ref[0][1] = a * vop_ref[0][1] + d[0][1];
487  sprite_ref[1][0] = a * vop_ref[1][0] + d[0][0] + d[1][0];
488  sprite_ref[1][1] = a * vop_ref[1][1] + d[0][1] + d[1][1];
489  sprite_ref[2][0] = a * vop_ref[2][0] + d[0][0] + d[2][0];
490  sprite_ref[2][1] = a * vop_ref[2][1] + d[0][1] + d[2][1];
491  } else {
492  sprite_ref[0][0] = (a >> 1) * (2 * vop_ref[0][0] + d[0][0]);
493  sprite_ref[0][1] = (a >> 1) * (2 * vop_ref[0][1] + d[0][1]);
494  sprite_ref[1][0] = (a >> 1) * (2 * vop_ref[1][0] + d[0][0] + d[1][0]);
495  sprite_ref[1][1] = (a >> 1) * (2 * vop_ref[1][1] + d[0][1] + d[1][1]);
496  sprite_ref[2][0] = (a >> 1) * (2 * vop_ref[2][0] + d[0][0] + d[2][0]);
497  sprite_ref[2][1] = (a >> 1) * (2 * vop_ref[2][1] + d[0][1] + d[2][1]);
498  }
499  /* sprite_ref[3][0] = (a >> 1) * (2 * vop_ref[3][0] + d[0][0] + d[1][0] + d[2][0] + d[3][0]);
500  * sprite_ref[3][1] = (a >> 1) * (2 * vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */
501 
502  /* This is mostly identical to the MPEG-4 std (and is totally unreadable
503  * because of that...). Perhaps it should be reordered to be more readable.
504  * The idea behind this virtual_ref mess is to be able to use shifts later
505  * per pixel instead of divides so the distance between points is converted
506  * from w&h based to w2&h2 based which are of the 2^x form. */
507  virtual_ref[0][0] = 16 * (vop_ref[0][0] + w2) +
508  ROUNDED_DIV(((w - w2) *
509  (r * sprite_ref[0][0] - 16LL * vop_ref[0][0]) +
510  w2 * (r * sprite_ref[1][0] - 16LL * vop_ref[1][0])), w);
511  virtual_ref[0][1] = 16 * vop_ref[0][1] +
512  ROUNDED_DIV(((w - w2) *
513  (r * sprite_ref[0][1] - 16LL * vop_ref[0][1]) +
514  w2 * (r * sprite_ref[1][1] - 16LL * vop_ref[1][1])), w);
515  virtual_ref[1][0] = 16 * vop_ref[0][0] +
516  ROUNDED_DIV(((h - h2) * (r * sprite_ref[0][0] - 16LL * vop_ref[0][0]) +
517  h2 * (r * sprite_ref[2][0] - 16LL * vop_ref[2][0])), h);
518  virtual_ref[1][1] = 16 * (vop_ref[0][1] + h2) +
519  ROUNDED_DIV(((h - h2) * (r * sprite_ref[0][1] - 16LL * vop_ref[0][1]) +
520  h2 * (r * sprite_ref[2][1] - 16LL * vop_ref[2][1])), h);
521 
522  switch (ctx->num_sprite_warping_points) {
523  case 0:
524  sprite_offset[0][0] =
525  sprite_offset[0][1] =
526  sprite_offset[1][0] =
527  sprite_offset[1][1] = 0;
528  sprite_delta[0][0] = a;
529  sprite_delta[0][1] =
530  sprite_delta[1][0] = 0;
531  sprite_delta[1][1] = a;
532  ctx->sprite_shift[0] =
533  ctx->sprite_shift[1] = 0;
534  break;
535  case 1: // GMC only
536  sprite_offset[0][0] = sprite_ref[0][0] - a * vop_ref[0][0];
537  sprite_offset[0][1] = sprite_ref[0][1] - a * vop_ref[0][1];
538  sprite_offset[1][0] = ((sprite_ref[0][0] >> 1) | (sprite_ref[0][0] & 1)) -
539  a * (vop_ref[0][0] / 2);
540  sprite_offset[1][1] = ((sprite_ref[0][1] >> 1) | (sprite_ref[0][1] & 1)) -
541  a * (vop_ref[0][1] / 2);
542  sprite_delta[0][0] = a;
543  sprite_delta[0][1] =
544  sprite_delta[1][0] = 0;
545  sprite_delta[1][1] = a;
546  ctx->sprite_shift[0] =
547  ctx->sprite_shift[1] = 0;
548  break;
549  case 2:
550  sprite_offset[0][0] = ((int64_t) sprite_ref[0][0] * (1 << alpha + rho)) +
551  ((int64_t) -r * sprite_ref[0][0] + virtual_ref[0][0]) *
552  ((int64_t) -vop_ref[0][0]) +
553  ((int64_t) r * sprite_ref[0][1] - virtual_ref[0][1]) *
554  ((int64_t) -vop_ref[0][1]) + (1 << (alpha + rho - 1));
555  sprite_offset[0][1] = ((int64_t) sprite_ref[0][1] * (1 << alpha + rho)) +
556  ((int64_t) -r * sprite_ref[0][1] + virtual_ref[0][1]) *
557  ((int64_t) -vop_ref[0][0]) +
558  ((int64_t) -r * sprite_ref[0][0] + virtual_ref[0][0]) *
559  ((int64_t) -vop_ref[0][1]) + (1 << (alpha + rho - 1));
560  sprite_offset[1][0] = (((int64_t)-r * sprite_ref[0][0] + virtual_ref[0][0]) *
561  ((int64_t)-2 * vop_ref[0][0] + 1) +
562  ((int64_t) r * sprite_ref[0][1] - virtual_ref[0][1]) *
563  ((int64_t)-2 * vop_ref[0][1] + 1) + 2 * w2 * r *
564  (int64_t) sprite_ref[0][0] - 16 * w2 + (1 << (alpha + rho + 1)));
565  sprite_offset[1][1] = (((int64_t)-r * sprite_ref[0][1] + virtual_ref[0][1]) *
566  ((int64_t)-2 * vop_ref[0][0] + 1) +
567  ((int64_t)-r * sprite_ref[0][0] + virtual_ref[0][0]) *
568  ((int64_t)-2 * vop_ref[0][1] + 1) + 2 * w2 * r *
569  (int64_t) sprite_ref[0][1] - 16 * w2 + (1 << (alpha + rho + 1)));
570  sprite_delta[0][0] = (-r * sprite_ref[0][0] + virtual_ref[0][0]);
571  sprite_delta[0][1] = (+r * sprite_ref[0][1] - virtual_ref[0][1]);
572  sprite_delta[1][0] = (-r * sprite_ref[0][1] + virtual_ref[0][1]);
573  sprite_delta[1][1] = (-r * sprite_ref[0][0] + virtual_ref[0][0]);
574 
575  ctx->sprite_shift[0] = alpha + rho;
576  ctx->sprite_shift[1] = alpha + rho + 2;
577  break;
578  case 3:
579  min_ab = FFMIN(alpha, beta);
580  w3 = w2 >> min_ab;
581  h3 = h2 >> min_ab;
582  sprite_offset[0][0] = ((int64_t)sprite_ref[0][0] * (1 << (alpha + beta + rho - min_ab))) +
583  ((int64_t)-r * sprite_ref[0][0] + virtual_ref[0][0]) * h3 * (-vop_ref[0][0]) +
584  ((int64_t)-r * sprite_ref[0][0] + virtual_ref[1][0]) * w3 * (-vop_ref[0][1]) +
585  ((int64_t)1 << (alpha + beta + rho - min_ab - 1));
586  sprite_offset[0][1] = ((int64_t)sprite_ref[0][1] * (1 << (alpha + beta + rho - min_ab))) +
587  ((int64_t)-r * sprite_ref[0][1] + virtual_ref[0][1]) * h3 * (-vop_ref[0][0]) +
588  ((int64_t)-r * sprite_ref[0][1] + virtual_ref[1][1]) * w3 * (-vop_ref[0][1]) +
589  ((int64_t)1 << (alpha + beta + rho - min_ab - 1));
590  sprite_offset[1][0] = ((int64_t)-r * sprite_ref[0][0] + virtual_ref[0][0]) * h3 * (-2 * vop_ref[0][0] + 1) +
591  ((int64_t)-r * sprite_ref[0][0] + virtual_ref[1][0]) * w3 * (-2 * vop_ref[0][1] + 1) +
592  (int64_t)2 * w2 * h3 * r * sprite_ref[0][0] - 16 * w2 * h3 +
593  ((int64_t)1 << (alpha + beta + rho - min_ab + 1));
594  sprite_offset[1][1] = ((int64_t)-r * sprite_ref[0][1] + virtual_ref[0][1]) * h3 * (-2 * vop_ref[0][0] + 1) +
595  ((int64_t)-r * sprite_ref[0][1] + virtual_ref[1][1]) * w3 * (-2 * vop_ref[0][1] + 1) +
596  (int64_t)2 * w2 * h3 * r * sprite_ref[0][1] - 16 * w2 * h3 +
597  ((int64_t)1 << (alpha + beta + rho - min_ab + 1));
598  sprite_delta[0][0] = (-r * (int64_t)sprite_ref[0][0] + virtual_ref[0][0]) * h3;
599  sprite_delta[0][1] = (-r * (int64_t)sprite_ref[0][0] + virtual_ref[1][0]) * w3;
600  sprite_delta[1][0] = (-r * (int64_t)sprite_ref[0][1] + virtual_ref[0][1]) * h3;
601  sprite_delta[1][1] = (-r * (int64_t)sprite_ref[0][1] + virtual_ref[1][1]) * w3;
602 
603  ctx->sprite_shift[0] = alpha + beta + rho - min_ab;
604  ctx->sprite_shift[1] = alpha + beta + rho - min_ab + 2;
605  break;
606  default:
607  av_assert0(0);
608  }
609  /* try to simplify the situation */
610  if (sprite_delta[0][0] == a << ctx->sprite_shift[0] &&
611  sprite_delta[0][1] == 0 &&
612  sprite_delta[1][0] == 0 &&
613  sprite_delta[1][1] == a << ctx->sprite_shift[0]) {
614  sprite_offset[0][0] >>= ctx->sprite_shift[0];
615  sprite_offset[0][1] >>= ctx->sprite_shift[0];
616  sprite_offset[1][0] >>= ctx->sprite_shift[1];
617  sprite_offset[1][1] >>= ctx->sprite_shift[1];
618  sprite_delta[0][0] = a;
619  sprite_delta[0][1] = 0;
620  sprite_delta[1][0] = 0;
621  sprite_delta[1][1] = a;
622  ctx->sprite_shift[0] = 0;
623  ctx->sprite_shift[1] = 0;
624  ctx->real_sprite_warping_points = 1;
625  } else {
626  int shift_y = 16 - ctx->sprite_shift[0];
627  int shift_c = 16 - ctx->sprite_shift[1];
628 
629  for (i = 0; i < 2; i++) {
630  if (shift_c < 0 || shift_y < 0 ||
631  FFABS( sprite_offset[0][i]) >= INT_MAX >> shift_y ||
632  FFABS( sprite_offset[1][i]) >= INT_MAX >> shift_c ||
633  FFABS( sprite_delta[0][i]) >= INT_MAX >> shift_y ||
634  FFABS( sprite_delta[1][i]) >= INT_MAX >> shift_y
635  ) {
636  avpriv_request_sample(s->avctx, "Too large sprite shift, delta or offset");
637  goto overflow;
638  }
639  }
640 
641  for (i = 0; i < 2; i++) {
642  sprite_offset[0][i] *= 1 << shift_y;
643  sprite_offset[1][i] *= 1 << shift_c;
644  sprite_delta[0][i] *= 1 << shift_y;
645  sprite_delta[1][i] *= 1 << shift_y;
646  ctx->sprite_shift[i] = 16;
647 
648  }
649  for (i = 0; i < 2; i++) {
650  int64_t sd[2] = {
651  sprite_delta[i][0] - a * (1LL<<16),
652  sprite_delta[i][1] - a * (1LL<<16)
653  };
654 
655  if (llabs(sprite_offset[0][i] + sprite_delta[i][0] * (w+16LL)) >= INT_MAX ||
656  llabs(sprite_offset[0][i] + sprite_delta[i][1] * (h+16LL)) >= INT_MAX ||
657  llabs(sprite_offset[0][i] + sprite_delta[i][0] * (w+16LL) + sprite_delta[i][1] * (h+16LL)) >= INT_MAX ||
658  llabs(sprite_delta[i][0] * (w+16LL)) >= INT_MAX ||
659  llabs(sprite_delta[i][1] * (h+16LL)) >= INT_MAX ||
660  llabs(sd[0]) >= INT_MAX ||
661  llabs(sd[1]) >= INT_MAX ||
662  llabs(sprite_offset[0][i] + sd[0] * (w+16LL)) >= INT_MAX ||
663  llabs(sprite_offset[0][i] + sd[1] * (h+16LL)) >= INT_MAX ||
664  llabs(sprite_offset[0][i] + sd[0] * (w+16LL) + sd[1] * (h+16LL)) >= INT_MAX
665  ) {
666  avpriv_request_sample(s->avctx, "Overflow on sprite points");
667  goto overflow;
668  }
669  }
670  ctx->real_sprite_warping_points = ctx->num_sprite_warping_points;
671  }
672 
673  for (i = 0; i < 4; i++) {
674  ctx->sprite_offset[i&1][i>>1] = sprite_offset[i&1][i>>1];
675  ctx->sprite_delta [i&1][i>>1] = sprite_delta [i&1][i>>1];
676  }
677 
678  return 0;
679 overflow:
680  memset(ctx->sprite_offset, 0, sizeof(ctx->sprite_offset));
681  memset(ctx->sprite_delta, 0, sizeof(ctx->sprite_delta));
682  return AVERROR_PATCHWELCOME;
683 }
684 
685 static int decode_new_pred(Mpeg4DecContext *ctx, GetBitContext *gb) {
686  MpegEncContext *s = &ctx->m;
687  int len = FFMIN(ctx->time_increment_bits + 3, 15);
688 
689  get_bits(gb, len);
690  if (get_bits1(gb))
691  get_bits(gb, len);
692  check_marker(s->avctx, gb, "after new_pred");
693 
694  return 0;
695 }
696 
697 /**
698  * Decode the next video packet.
699  * @return <0 if something went wrong
700  */
701 int ff_mpeg4_decode_video_packet_header(Mpeg4DecContext *ctx)
702 {
703  MpegEncContext *s = &ctx->m;
704 
705  int mb_num_bits = av_log2(s->mb_num - 1) + 1;
706  int header_extension = 0, mb_num, len;
707 
708  /* is there enough space left for a video packet + header */
709  if (get_bits_count(&s->gb) > s->gb.size_in_bits - 20)
710  return AVERROR_INVALIDDATA;
711 
712  for (len = 0; len < 32; len++)
713  if (get_bits1(&s->gb))
714  break;
715 
716  if (len != ff_mpeg4_get_video_packet_prefix_length(s)) {
717  av_log(s->avctx, AV_LOG_ERROR, "marker does not match f_code\n");
718  return AVERROR_INVALIDDATA;
719  }
720 
721  if (ctx->shape != RECT_SHAPE) {
722  header_extension = get_bits1(&s->gb);
723  // FIXME more stuff here
724  }
725 
726  mb_num = get_bits(&s->gb, mb_num_bits);
727  if (mb_num >= s->mb_num || !mb_num) {
728  av_log(s->avctx, AV_LOG_ERROR,
729  "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num);
730  return AVERROR_INVALIDDATA;
731  }
732 
733  s->mb_x = mb_num % s->mb_width;
734  s->mb_y = mb_num / s->mb_width;
735 
736  if (ctx->shape != BIN_ONLY_SHAPE) {
737  int qscale = get_bits(&s->gb, ctx->quant_precision);
738  if (qscale)
739  s->chroma_qscale = s->qscale = qscale;
740  }
741 
742  if (ctx->shape == RECT_SHAPE)
743  header_extension = get_bits1(&s->gb);
744 
745  if (header_extension) {
746  while (get_bits1(&s->gb) != 0)
747  ;
748 
749  check_marker(s->avctx, &s->gb, "before time_increment in video packed header");
750  skip_bits(&s->gb, ctx->time_increment_bits); /* time_increment */
751  check_marker(s->avctx, &s->gb, "before vop_coding_type in video packed header");
752 
753  skip_bits(&s->gb, 2); /* vop coding type */
754  // FIXME not rect stuff here
755 
756  if (ctx->shape != BIN_ONLY_SHAPE) {
757  skip_bits(&s->gb, 3); /* intra dc vlc threshold */
758  // FIXME don't just ignore everything
759  if (s->pict_type == AV_PICTURE_TYPE_S &&
760  ctx->vol_sprite_usage == GMC_SPRITE) {
761  if (mpeg4_decode_sprite_trajectory(ctx, &s->gb) < 0)
762  return AVERROR_INVALIDDATA;
763  av_log(s->avctx, AV_LOG_ERROR, "untested\n");
764  }
765 
766  // FIXME reduced res stuff here
767 
768  if (s->pict_type != AV_PICTURE_TYPE_I) {
769  int f_code = get_bits(&s->gb, 3); /* fcode_for */
770  if (f_code == 0)
771  av_log(s->avctx, AV_LOG_ERROR,
772  "Error, video packet header damaged (f_code=0)\n");
773  }
774  if (s->pict_type == AV_PICTURE_TYPE_B) {
775  int b_code = get_bits(&s->gb, 3);
776  if (b_code == 0)
777  av_log(s->avctx, AV_LOG_ERROR,
778  "Error, video packet header damaged (b_code=0)\n");
779  }
780  }
781  }
782  if (ctx->new_pred)
783  decode_new_pred(ctx, &s->gb);
784 
785  return 0;
786 }
787 
788 static void reset_studio_dc_predictors(MpegEncContext *s)
789 {
790  /* Reset DC Predictors */
791  s->last_dc[0] =
792  s->last_dc[1] =
793  s->last_dc[2] = 1 << (s->avctx->bits_per_raw_sample + s->dct_precision + s->intra_dc_precision - 1);
794 }
795 
796 /**
797  * Decode the next video packet.
798  * @return <0 if something went wrong
799  */
800 int ff_mpeg4_decode_studio_slice_header(Mpeg4DecContext *ctx)
801 {
802  MpegEncContext *s = &ctx->m;
803  GetBitContext *gb = &s->gb;
804  unsigned vlc_len;
805  uint16_t mb_num;
806 
807  if (get_bits_left(gb) >= 32 && get_bits_long(gb, 32) == SLICE_STARTCODE) {
808  vlc_len = av_log2(s->mb_width * s->mb_height) + 1;
809  mb_num = get_bits(gb, vlc_len);
810 
811  if (mb_num >= s->mb_num)
812  return AVERROR_INVALIDDATA;
813 
814  s->mb_x = mb_num % s->mb_width;
815  s->mb_y = mb_num / s->mb_width;
816 
817  if (ctx->shape != BIN_ONLY_SHAPE)
818  s->qscale = mpeg_get_qscale(s);
819 
820  if (get_bits1(gb)) { /* slice_extension_flag */
821  skip_bits1(gb); /* intra_slice */
822  skip_bits1(gb); /* slice_VOP_id_enable */
823  skip_bits(gb, 6); /* slice_VOP_id */
824  while (get_bits1(gb)) /* extra_bit_slice */
825  skip_bits(gb, 8); /* extra_information_slice */
826  }
827 
828  reset_studio_dc_predictors(s);
829  }
830  else {
831  return AVERROR_INVALIDDATA;
832  }
833 
834  return 0;
835 }
836 
837 /**
838  * Get the average motion vector for a GMC MB.
839  * @param n either 0 for the x component or 1 for y
840  * @return the average MV for a GMC MB
841  */
842 static inline int get_amv(Mpeg4DecContext *ctx, int n)
843 {
844  MpegEncContext *s = &ctx->m;
845  int x, y, mb_v, sum, dx, dy, shift;
846  int len = 1 << (s->f_code + 4);
847  const int a = ctx->sprite_warping_accuracy;
848 
849  if (s->workaround_bugs & FF_BUG_AMV)
850  len >>= s->quarter_sample;
851 
852  if (ctx->real_sprite_warping_points == 1) {
853  if (ctx->divx_version == 500 && ctx->divx_build == 413 && a >= s->quarter_sample)
854  sum = ctx->sprite_offset[0][n] / (1 << (a - s->quarter_sample));
855  else
856  sum = RSHIFT(ctx->sprite_offset[0][n] * (1 << s->quarter_sample), a);
857  } else {
858  dx = ctx->sprite_delta[n][0];
859  dy = ctx->sprite_delta[n][1];
860  shift = ctx->sprite_shift[0];
861  if (n)
862  dy -= 1 << (shift + a + 1);
863  else
864  dx -= 1 << (shift + a + 1);
865  mb_v = ctx->sprite_offset[0][n] + dx * s->mb_x * 16U + dy * s->mb_y * 16U;
866 
867  sum = 0;
868  for (y = 0; y < 16; y++) {
869  int v;
870 
871  v = mb_v + (unsigned)dy * y;
872  // FIXME optimize
873  for (x = 0; x < 16; x++) {
874  sum += v >> shift;
875  v += dx;
876  }
877  }
878  sum = RSHIFT(sum, a + 8 - s->quarter_sample);
879  }
880 
881  if (sum < -len)
882  sum = -len;
883  else if (sum >= len)
884  sum = len - 1;
885 
886  return sum;
887 }
888 
889 static inline int mpeg4_get_level_dc(MpegEncContext *s, int n, int pred, int level)
890 {
891  int scale = n < 4 ? s->y_dc_scale : s->c_dc_scale;
892  int ret;
893 
894  if (IS_3IV1)
895  scale = 8;
896 
897  /* we assume pred is positive */
898  pred = FASTDIV((pred + (scale >> 1)), scale);
899 
900  level += pred;
901  ret = level;
902  level *= scale;
903  if (level & (~2047)) {
904  if (s->avctx->err_recognition & (AV_EF_BITSTREAM | AV_EF_AGGRESSIVE)) {
905  if (level < 0) {
906  av_log(s->avctx, AV_LOG_ERROR,
907  "dc<0 at %dx%d\n", s->mb_x, s->mb_y);
908  return AVERROR_INVALIDDATA;
909  }
910  if (level > 2048 + scale) {
911  av_log(s->avctx, AV_LOG_ERROR,
912  "dc overflow at %dx%d\n", s->mb_x, s->mb_y);
913  return AVERROR_INVALIDDATA;
914  }
915  }
916  if (level < 0)
917  level = 0;
918  else if (!(s->workaround_bugs & FF_BUG_DC_CLIP))
919  level = 2047;
920  }
921  s->dc_val[0][s->block_index[n]] = level;
922 
923  return ret;
924 }
925 
926 /**
927  * Decode the dc value.
928  * @param n block index (0-3 are luma, 4-5 are chroma)
929  * @param dir_ptr the prediction direction will be stored here
930  * @return the quantized dc
931  */
932 static inline int mpeg4_decode_dc(MpegEncContext *s, int n, int *dir_ptr)
933 {
934  int level, code, pred;
935 
936  if (n < 4)
937  code = get_vlc2(&s->gb, dc_lum, DC_VLC_BITS, 1);
938  else
939  code = get_vlc2(&s->gb, dc_chrom, DC_VLC_BITS, 1);
940 
941  if (code < 0) {
942  av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
943  return AVERROR_INVALIDDATA;
944  }
945 
946  if (code == 0) {
947  level = 0;
948  } else {
949  if (IS_3IV1) {
950  if (code == 1)
951  level = 2 * get_bits1(&s->gb) - 1;
952  else {
953  if (get_bits1(&s->gb))
954  level = get_bits(&s->gb, code - 1) + (1 << (code - 1));
955  else
956  level = -get_bits(&s->gb, code - 1) - (1 << (code - 1));
957  }
958  } else {
959  level = get_xbits(&s->gb, code);
960  }
961 
962  if (code > 8) {
963  if (get_bits1(&s->gb) == 0) { /* marker */
964  if (s->avctx->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT)) {
965  av_log(s->avctx, AV_LOG_ERROR, "dc marker bit missing\n");
966  return AVERROR_INVALIDDATA;
967  }
968  }
969  }
970  }
971 
972  pred = ff_mpeg4_pred_dc(s, n, dir_ptr);
973  return mpeg4_get_level_dc(s, n, pred, level);
974 }
975 
976 /**
977  * Decode first partition.
978  * @return number of MBs decoded or <0 if an error occurred
979  */
980 static int mpeg4_decode_partition_a(Mpeg4DecContext *ctx)
981 {
982  MpegEncContext *s = &ctx->m;
983  int mb_num = 0;
984  static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
985 
986  /* decode first partition */
987  s->first_slice_line = 1;
988  for (; s->mb_y < s->mb_height; s->mb_y++) {
989  ff_init_block_index(s);
990  for (; s->mb_x < s->mb_width; s->mb_x++) {
991  const int xy = s->mb_x + s->mb_y * s->mb_stride;
992  int cbpc;
993  int dir = 0;
994 
995  mb_num++;
996  ff_update_block_index(s, 8, s->avctx->lowres, 1);
997  if (s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y + 1)
998  s->first_slice_line = 0;
999 
1000  if (s->pict_type == AV_PICTURE_TYPE_I) {
1001  int i;
1002 
1003  do {
1004  if (show_bits(&s->gb, 19) == DC_MARKER)
1005  return mb_num - 1;
1006 
1007  cbpc = get_vlc2(&s->gb, ff_h263_intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 2);
1008  if (cbpc < 0) {
1009  av_log(s->avctx, AV_LOG_ERROR,
1010  "mcbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
1011  return AVERROR_INVALIDDATA;
1012  }
1013  } while (cbpc == 8);
1014 
1015  s->cbp_table[xy] = cbpc & 3;
1016  s->cur_pic.mb_type[xy] = MB_TYPE_INTRA;
1017  s->mb_intra = 1;
1018 
1019  if (cbpc & 4)
1020  ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
1021 
1022  s->cur_pic.qscale_table[xy] = s->qscale;
1023 
1024  s->mbintra_table[xy] = 1;
1025  for (i = 0; i < 6; i++) {
1026  int dc_pred_dir;
1027  int dc = mpeg4_decode_dc(s, i, &dc_pred_dir);
1028  if (dc < 0) {
1029  av_log(s->avctx, AV_LOG_ERROR,
1030  "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
1031  return dc;
1032  }
1033  dir <<= 1;
1034  if (dc_pred_dir)
1035  dir |= 1;
1036  }
1037  s->pred_dir_table[xy] = dir;
1038  } else { /* P/S_TYPE */
1039  int mx, my, pred_x, pred_y, bits;
1040  int16_t *const mot_val = s->cur_pic.motion_val[0][s->block_index[0]];
1041  const int stride = s->b8_stride * 2;
1042 
1043 try_again:
1044  bits = show_bits(&s->gb, 17);
1045  if (bits == MOTION_MARKER)
1046  return mb_num - 1;
1047 
1048  skip_bits1(&s->gb);
1049  if (bits & 0x10000) {
1050  /* skip mb */
1051  if (s->pict_type == AV_PICTURE_TYPE_S &&
1052  ctx->vol_sprite_usage == GMC_SPRITE) {
1053  s->cur_pic.mb_type[xy] = MB_TYPE_SKIP |
1054  MB_TYPE_16x16 |
1055  MB_TYPE_GMC |
1056  MB_TYPE_FORWARD_MV;
1057  mx = get_amv(ctx, 0);
1058  my = get_amv(ctx, 1);
1059  } else {
1060  s->cur_pic.mb_type[xy] = MB_TYPE_SKIP |
1061  MB_TYPE_16x16 |
1062  MB_TYPE_FORWARD_MV;
1063  mx = my = 0;
1064  }
1065  mot_val[0] =
1066  mot_val[2] =
1067  mot_val[0 + stride] =
1068  mot_val[2 + stride] = mx;
1069  mot_val[1] =
1070  mot_val[3] =
1071  mot_val[1 + stride] =
1072  mot_val[3 + stride] = my;
1073 
1074  if (s->mbintra_table[xy])
1075  ff_clean_intra_table_entries(s);
1076  continue;
1077  }
1078 
1079  cbpc = get_vlc2(&s->gb, ff_h263_inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 2);
1080  if (cbpc < 0) {
1081  av_log(s->avctx, AV_LOG_ERROR,
1082  "mcbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
1083  return AVERROR_INVALIDDATA;
1084  }
1085  if (cbpc == 20)
1086  goto try_again;
1087 
1088  s->cbp_table[xy] = cbpc & (8 + 3); // 8 is dquant
1089 
1090  s->mb_intra = ((cbpc & 4) != 0);
1091 
1092  if (s->mb_intra) {
1093  s->cur_pic.mb_type[xy] = MB_TYPE_INTRA;
1094  s->mbintra_table[xy] = 1;
1095  mot_val[0] =
1096  mot_val[2] =
1097  mot_val[0 + stride] =
1098  mot_val[2 + stride] = 0;
1099  mot_val[1] =
1100  mot_val[3] =
1101  mot_val[1 + stride] =
1102  mot_val[3 + stride] = 0;
1103  } else {
1104  if (s->mbintra_table[xy])
1105  ff_clean_intra_table_entries(s);
1106 
1107  if (s->pict_type == AV_PICTURE_TYPE_S &&
1108  ctx->vol_sprite_usage == GMC_SPRITE &&
1109  (cbpc & 16) == 0)
1110  s->mcsel = get_bits1(&s->gb);
1111  else
1112  s->mcsel = 0;
1113 
1114  if ((cbpc & 16) == 0) {
1115  /* 16x16 motion prediction */
1116 
1117  ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1118  if (!s->mcsel) {
1119  mx = ff_h263_decode_motion(s, pred_x, s->f_code);
1120  if (mx >= 0xffff)
1121  return AVERROR_INVALIDDATA;
1122 
1123  my = ff_h263_decode_motion(s, pred_y, s->f_code);
1124  if (my >= 0xffff)
1125  return AVERROR_INVALIDDATA;
1126  s->cur_pic.mb_type[xy] = MB_TYPE_16x16 |
1127  MB_TYPE_FORWARD_MV;
1128  } else {
1129  mx = get_amv(ctx, 0);
1130  my = get_amv(ctx, 1);
1131  s->cur_pic.mb_type[xy] = MB_TYPE_16x16 |
1132  MB_TYPE_GMC |
1133  MB_TYPE_FORWARD_MV;
1134  }
1135 
1136  mot_val[0] =
1137  mot_val[2] =
1138  mot_val[0 + stride] =
1139  mot_val[2 + stride] = mx;
1140  mot_val[1] =
1141  mot_val[3] =
1142  mot_val[1 + stride] =
1143  mot_val[3 + stride] = my;
1144  } else {
1145  int i;
1146  s->cur_pic.mb_type[xy] = MB_TYPE_8x8 |
1147  MB_TYPE_FORWARD_MV;
1148  for (i = 0; i < 4; i++) {
1149  int16_t *mot_val = ff_h263_pred_motion(s, i, 0, &pred_x, &pred_y);
1150  mx = ff_h263_decode_motion(s, pred_x, s->f_code);
1151  if (mx >= 0xffff)
1152  return AVERROR_INVALIDDATA;
1153 
1154  my = ff_h263_decode_motion(s, pred_y, s->f_code);
1155  if (my >= 0xffff)
1156  return AVERROR_INVALIDDATA;
1157  mot_val[0] = mx;
1158  mot_val[1] = my;
1159  }
1160  }
1161  }
1162  }
1163  }
1164  s->mb_x = 0;
1165  }
1166 
1167  return mb_num;
1168 }
1169 
1170 /**
1171  * decode second partition.
1172  * @return <0 if an error occurred
1173  */
1174 static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count)
1175 {
1176  int mb_num = 0;
1177  static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
1178 
1179  s->mb_x = s->resync_mb_x;
1180  s->first_slice_line = 1;
1181  for (s->mb_y = s->resync_mb_y; mb_num < mb_count; s->mb_y++) {
1182  ff_init_block_index(s);
1183  for (; mb_num < mb_count && s->mb_x < s->mb_width; s->mb_x++) {
1184  const int xy = s->mb_x + s->mb_y * s->mb_stride;
1185 
1186  mb_num++;
1187  ff_update_block_index(s, 8, s->avctx->lowres, 1);
1188  if (s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y + 1)
1189  s->first_slice_line = 0;
1190 
1191  if (s->pict_type == AV_PICTURE_TYPE_I) {
1192  int ac_pred = get_bits1(&s->gb);
1193  int cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc, CBPY_VLC_BITS, 1);
1194  if (cbpy < 0) {
1195  av_log(s->avctx, AV_LOG_ERROR,
1196  "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
1197  return AVERROR_INVALIDDATA;
1198  }
1199 
1200  s->cbp_table[xy] |= cbpy << 2;
1201  s->cur_pic.mb_type[xy] |= ac_pred * MB_TYPE_ACPRED;
1202  } else { /* P || S_TYPE */
1203  if (IS_INTRA(s->cur_pic.mb_type[xy])) {
1204  int i;
1205  int dir = 0;
1206  int ac_pred = get_bits1(&s->gb);
1207  int cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc, CBPY_VLC_BITS, 1);
1208 
1209  if (cbpy < 0) {
1210  av_log(s->avctx, AV_LOG_ERROR,
1211  "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
1212  return AVERROR_INVALIDDATA;
1213  }
1214 
1215  if (s->cbp_table[xy] & 8)
1216  ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
1217  s->cur_pic.qscale_table[xy] = s->qscale;
1218 
1219  for (i = 0; i < 6; i++) {
1220  int dc_pred_dir;
1221  int dc = mpeg4_decode_dc(s, i, &dc_pred_dir);
1222  if (dc < 0) {
1223  av_log(s->avctx, AV_LOG_ERROR,
1224  "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
1225  return dc;
1226  }
1227  dir <<= 1;
1228  if (dc_pred_dir)
1229  dir |= 1;
1230  }
1231  s->cbp_table[xy] &= 3; // remove dquant
1232  s->cbp_table[xy] |= cbpy << 2;
1233  s->cur_pic.mb_type[xy] |= ac_pred * MB_TYPE_ACPRED;
1234  s->pred_dir_table[xy] = dir;
1235  } else if (IS_SKIP(s->cur_pic.mb_type[xy])) {
1236  s->cur_pic.qscale_table[xy] = s->qscale;
1237  s->cbp_table[xy] = 0;
1238  } else {
1239  int cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc, CBPY_VLC_BITS, 1);
1240 
1241  if (cbpy < 0) {
1242  av_log(s->avctx, AV_LOG_ERROR,
1243  "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
1244  return AVERROR_INVALIDDATA;
1245  }
1246 
1247  if (s->cbp_table[xy] & 8)
1248  ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
1249  s->cur_pic.qscale_table[xy] = s->qscale;
1250 
1251  s->cbp_table[xy] &= 3; // remove dquant
1252  s->cbp_table[xy] |= (cbpy ^ 0xf) << 2;
1253  }
1254  }
1255  }
1256  if (mb_num >= mb_count)
1257  return 0;
1258  s->mb_x = 0;
1259  }
1260  return 0;
1261 }
1262 
1263 /**
1264  * Decode the first and second partition.
1265  * @return <0 if error (and sets error type in the error_status_table)
1266  */
1267 int ff_mpeg4_decode_partitions(Mpeg4DecContext *ctx)
1268 {
1269  MpegEncContext *s = &ctx->m;
1270  int mb_num;
1271  int ret;
1272  const int part_a_error = s->pict_type == AV_PICTURE_TYPE_I ? (ER_DC_ERROR | ER_MV_ERROR) : ER_MV_ERROR;
1273  const int part_a_end = s->pict_type == AV_PICTURE_TYPE_I ? (ER_DC_END | ER_MV_END) : ER_MV_END;
1274 
1275  mb_num = mpeg4_decode_partition_a(ctx);
1276  if (mb_num <= 0) {
1277  ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
1278  s->mb_x, s->mb_y, part_a_error);
1279  return mb_num ? mb_num : AVERROR_INVALIDDATA;
1280  }
1281 
1282  if (s->resync_mb_x + s->resync_mb_y * s->mb_width + mb_num > s->mb_num) {
1283  av_log(s->avctx, AV_LOG_ERROR, "slice below monitor ...\n");
1284  ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
1285  s->mb_x, s->mb_y, part_a_error);
1286  return AVERROR_INVALIDDATA;
1287  }
1288 
1289  s->mb_num_left = mb_num;
1290 
1291  if (s->pict_type == AV_PICTURE_TYPE_I) {
1292  while (show_bits(&s->gb, 9) == 1)
1293  skip_bits(&s->gb, 9);
1294  if (get_bits(&s->gb, 19) != DC_MARKER) {
1295  av_log(s->avctx, AV_LOG_ERROR,
1296  "marker missing after first I partition at %d %d\n",
1297  s->mb_x, s->mb_y);
1298  return AVERROR_INVALIDDATA;
1299  }
1300  } else {
1301  while (show_bits(&s->gb, 10) == 1)
1302  skip_bits(&s->gb, 10);
1303  if (get_bits(&s->gb, 17) != MOTION_MARKER) {
1304  av_log(s->avctx, AV_LOG_ERROR,
1305  "marker missing after first P partition at %d %d\n",
1306  s->mb_x, s->mb_y);
1307  return AVERROR_INVALIDDATA;
1308  }
1309  }
1310  ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
1311  s->mb_x - 1, s->mb_y, part_a_end);
1312 
1313  ret = mpeg4_decode_partition_b(s, mb_num);
1314  if (ret < 0) {
1315  if (s->pict_type == AV_PICTURE_TYPE_P)
1316  ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
1317  s->mb_x, s->mb_y, ER_DC_ERROR);
1318  return ret;
1319  } else {
1320  if (s->pict_type == AV_PICTURE_TYPE_P)
1321  ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
1322  s->mb_x - 1, s->mb_y, ER_DC_END);
1323  }
1324 
1325  return 0;
1326 }
1327 
1328 /**
1329  * Decode a block.
1330  * @return <0 if an error occurred
1331  */
1332 static inline int mpeg4_decode_block(Mpeg4DecContext *ctx, int16_t *block,
1333  int n, int coded, int intra,
1334  int use_intra_dc_vlc, int rvlc)
1335 {
1336  MpegEncContext *s = &ctx->m;
1337  int level, i, last, run, qmul, qadd, pred;
1338  int av_uninit(dc_pred_dir);
1339  const RLTable *rl;
1340  const RL_VLC_ELEM *rl_vlc;
1341  const uint8_t *scan_table;
1342 
1343  // Note intra & rvlc should be optimized away if this is inlined
1344 
1345  if (intra) {
1346  if (use_intra_dc_vlc) {
1347  /* DC coef */
1348  if (s->partitioned_frame) {
1349  level = s->dc_val[0][s->block_index[n]];
1350  if (n < 4)
1351  level = FASTDIV((level + (s->y_dc_scale >> 1)), s->y_dc_scale);
1352  else
1353  level = FASTDIV((level + (s->c_dc_scale >> 1)), s->c_dc_scale);
1354  dc_pred_dir = (s->pred_dir_table[s->mb_x + s->mb_y * s->mb_stride] << n) & 32;
1355  } else {
1356  level = mpeg4_decode_dc(s, n, &dc_pred_dir);
1357  if (level < 0)
1358  return level;
1359  }
1360  block[0] = level;
1361  i = 0;
1362  } else {
1363  i = -1;
1364  pred = ff_mpeg4_pred_dc(s, n, &dc_pred_dir);
1365  }
1366  if (!coded)
1367  goto not_coded;
1368 
1369  if (rvlc) {
1370  rl = &ff_rvlc_rl_intra;
1371  rl_vlc = ff_rvlc_rl_intra.rl_vlc[0];
1372  } else {
1373  rl = &ff_mpeg4_rl_intra;
1374  rl_vlc = ff_mpeg4_rl_intra.rl_vlc[0];
1375  }
1376  if (s->ac_pred) {
1377  if (dc_pred_dir == 0)
1378  scan_table = s->permutated_intra_v_scantable; /* left */
1379  else
1380  scan_table = s->permutated_intra_h_scantable; /* top */
1381  } else {
1382  scan_table = s->intra_scantable.permutated;
1383  }
1384  qmul = 1;
1385  qadd = 0;
1386  } else {
1387  i = -1;
1388  if (!coded) {
1389  s->block_last_index[n] = i;
1390  return 0;
1391  }
1392  if (rvlc)
1393  rl = &ff_rvlc_rl_inter;
1394  else
1395  rl = &ff_h263_rl_inter;
1396 
1397  scan_table = s->intra_scantable.permutated;
1398 
1399  if (s->mpeg_quant) {
1400  qmul = 1;
1401  qadd = 0;
1402  if (rvlc)
1403  rl_vlc = ff_rvlc_rl_inter.rl_vlc[0];
1404  else
1405  rl_vlc = ff_h263_rl_inter.rl_vlc[0];
1406  } else {
1407  qmul = s->qscale << 1;
1408  qadd = (s->qscale - 1) | 1;
1409  if (rvlc)
1410  rl_vlc = ff_rvlc_rl_inter.rl_vlc[s->qscale];
1411  else
1412  rl_vlc = ff_h263_rl_inter.rl_vlc[s->qscale];
1413  }
1414  }
1415  {
1416  OPEN_READER(re, &s->gb);
1417  for (;;) {
1418  UPDATE_CACHE(re, &s->gb);
1419  GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
1420  if (level == 0) {
1421  /* escape */
1422  if (rvlc) {
1423  if (SHOW_UBITS(re, &s->gb, 1) == 0) {
1424  av_log(s->avctx, AV_LOG_ERROR,
1425  "1. marker bit missing in rvlc esc\n");
1426  return AVERROR_INVALIDDATA;
1427  }
1428  SKIP_CACHE(re, &s->gb, 1);
1429 
1430  last = SHOW_UBITS(re, &s->gb, 1);
1431  SKIP_CACHE(re, &s->gb, 1);
1432  run = SHOW_UBITS(re, &s->gb, 6);
1433  SKIP_COUNTER(re, &s->gb, 1 + 1 + 6);
1434  UPDATE_CACHE(re, &s->gb);
1435 
1436  if (SHOW_UBITS(re, &s->gb, 1) == 0) {
1437  av_log(s->avctx, AV_LOG_ERROR,
1438  "2. marker bit missing in rvlc esc\n");
1439  return AVERROR_INVALIDDATA;
1440  }
1441  SKIP_CACHE(re, &s->gb, 1);
1442 
1443  level = SHOW_UBITS(re, &s->gb, 11);
1444  SKIP_CACHE(re, &s->gb, 11);
1445 
1446  if (SHOW_UBITS(re, &s->gb, 5) != 0x10) {
1447  av_log(s->avctx, AV_LOG_ERROR, "reverse esc missing\n");
1448  return AVERROR_INVALIDDATA;
1449  }
1450  SKIP_CACHE(re, &s->gb, 5);
1451 
1452  level = level * qmul + qadd;
1453  level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1454  SKIP_COUNTER(re, &s->gb, 1 + 11 + 5 + 1);
1455 
1456  i += run + 1;
1457  if (last)
1458  i += 192;
1459  } else {
1460  int cache;
1461  cache = GET_CACHE(re, &s->gb);
1462 
1463  if (IS_3IV1)
1464  cache ^= 0xC0000000;
1465 
1466  if (cache & 0x80000000) {
1467  if (cache & 0x40000000) {
1468  /* third escape */
1469  SKIP_CACHE(re, &s->gb, 2);
1470  last = SHOW_UBITS(re, &s->gb, 1);
1471  SKIP_CACHE(re, &s->gb, 1);
1472  run = SHOW_UBITS(re, &s->gb, 6);
1473  SKIP_COUNTER(re, &s->gb, 2 + 1 + 6);
1474  UPDATE_CACHE(re, &s->gb);
1475 
1476  if (IS_3IV1) {
1477  level = SHOW_SBITS(re, &s->gb, 12);
1478  LAST_SKIP_BITS(re, &s->gb, 12);
1479  } else {
1480  if (SHOW_UBITS(re, &s->gb, 1) == 0) {
1481  av_log(s->avctx, AV_LOG_ERROR,
1482  "1. marker bit missing in 3. esc\n");
1483  if (!(s->avctx->err_recognition & AV_EF_IGNORE_ERR) || get_bits_left(&s->gb) <= 0)
1484  return AVERROR_INVALIDDATA;
1485  }
1486  SKIP_CACHE(re, &s->gb, 1);
1487 
1488  level = SHOW_SBITS(re, &s->gb, 12);
1489  SKIP_CACHE(re, &s->gb, 12);
1490 
1491  if (SHOW_UBITS(re, &s->gb, 1) == 0) {
1492  av_log(s->avctx, AV_LOG_ERROR,
1493  "2. marker bit missing in 3. esc\n");
1494  if (!(s->avctx->err_recognition & AV_EF_IGNORE_ERR) || get_bits_left(&s->gb) <= 0)
1495  return AVERROR_INVALIDDATA;
1496  }
1497 
1498  SKIP_COUNTER(re, &s->gb, 1 + 12 + 1);
1499  }
1500 
1501 #if 0
1502  if (s->error_recognition >= FF_ER_COMPLIANT) {
1503  const int abs_level= FFABS(level);
1504  if (abs_level<=MAX_LEVEL && run<=MAX_RUN) {
1505  const int run1= run - rl->max_run[last][abs_level] - 1;
1506  if (abs_level <= rl->max_level[last][run]) {
1507  av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n");
1508  return AVERROR_INVALIDDATA;
1509  }
1510  if (s->error_recognition > FF_ER_COMPLIANT) {
1511  if (abs_level <= rl->max_level[last][run]*2) {
1512  av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\n");
1513  return AVERROR_INVALIDDATA;
1514  }
1515  if (run1 >= 0 && abs_level <= rl->max_level[last][run1]) {
1516  av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\n");
1517  return AVERROR_INVALIDDATA;
1518  }
1519  }
1520  }
1521  }
1522 #endif
1523  if (level > 0)
1524  level = level * qmul + qadd;
1525  else
1526  level = level * qmul - qadd;
1527 
1528  if ((unsigned)(level + 2048) > 4095) {
1529  if (s->avctx->err_recognition & (AV_EF_BITSTREAM|AV_EF_AGGRESSIVE)) {
1530  if (level > 2560 || level < -2560) {
1531  av_log(s->avctx, AV_LOG_ERROR,
1532  "|level| overflow in 3. esc, qp=%d\n",
1533  s->qscale);
1534  return AVERROR_INVALIDDATA;
1535  }
1536  }
1537  level = level < 0 ? -2048 : 2047;
1538  }
1539 
1540  i += run + 1;
1541  if (last)
1542  i += 192;
1543  } else {
1544  /* second escape */
1545  SKIP_BITS(re, &s->gb, 2);
1546  GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
1547  i += run + rl->max_run[run >> 7][level / qmul] + 1; // FIXME opt indexing
1548  level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1549  LAST_SKIP_BITS(re, &s->gb, 1);
1550  }
1551  } else {
1552  /* first escape */
1553  SKIP_BITS(re, &s->gb, 1);
1554  GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
1555  i += run;
1556  level = level + rl->max_level[run >> 7][(run - 1) & 63] * qmul; // FIXME opt indexing
1557  level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1558  LAST_SKIP_BITS(re, &s->gb, 1);
1559  }
1560  }
1561  } else {
1562  i += run;
1563  level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1564  LAST_SKIP_BITS(re, &s->gb, 1);
1565  }
1566  ff_tlog(s->avctx, "dct[%d][%d] = %- 4d end?:%d\n", scan_table[i&63]&7, scan_table[i&63] >> 3, level, i>62);
1567  if (i > 62) {
1568  i -= 192;
1569  if (i & (~63)) {
1570  av_log(s->avctx, AV_LOG_ERROR,
1571  "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1572  return AVERROR_INVALIDDATA;
1573  }
1574 
1575  block[scan_table[i]] = level;
1576  break;
1577  }
1578 
1579  block[scan_table[i]] = level;
1580  }
1581  CLOSE_READER(re, &s->gb);
1582  }
1583 
1584 not_coded:
1585  if (intra) {
1586  if (!use_intra_dc_vlc) {
1587  block[0] = mpeg4_get_level_dc(s, n, pred, block[0]);
1588 
1589  i -= i >> 31; // if (i == -1) i = 0;
1590  }
1591 
1592  ff_mpeg4_pred_ac(s, block, n, dc_pred_dir);
1593  if (s->ac_pred)
1594  i = 63; // FIXME not optimal
1595  }
1596  s->block_last_index[n] = i;
1597  return 0;
1598 }
1599 
1600 /**
1601  * decode partition C of one MB.
1602  * @return <0 if an error occurred
1603  */
1604 static int mpeg4_decode_partitioned_mb(MpegEncContext *s, int16_t block[6][64])
1605 {
1606  Mpeg4DecContext *ctx = s->avctx->priv_data;
1607  int cbp, mb_type, use_intra_dc_vlc;
1608  const int xy = s->mb_x + s->mb_y * s->mb_stride;
1609 
1610  av_assert2(s == (void*)ctx);
1611 
1612  mb_type = s->cur_pic.mb_type[xy];
1613  cbp = s->cbp_table[xy];
1614 
1615  use_intra_dc_vlc = s->qscale < ctx->intra_dc_threshold;
1616 
1617  if (s->cur_pic.qscale_table[xy] != s->qscale)
1618  ff_set_qscale(s, s->cur_pic.qscale_table[xy]);
1619 
1620  if (s->pict_type == AV_PICTURE_TYPE_P ||
1621  s->pict_type == AV_PICTURE_TYPE_S) {
1622  int i;
1623  for (i = 0; i < 4; i++) {
1624  s->mv[0][i][0] = s->cur_pic.motion_val[0][s->block_index[i]][0];
1625  s->mv[0][i][1] = s->cur_pic.motion_val[0][s->block_index[i]][1];
1626  }
1627  s->mb_intra = IS_INTRA(mb_type);
1628 
1629  if (IS_SKIP(mb_type)) {
1630  /* skip mb */
1631  for (i = 0; i < 6; i++)
1632  s->block_last_index[i] = -1;
1633  s->mv_dir = MV_DIR_FORWARD;
1634  s->mv_type = MV_TYPE_16X16;
1635  if (s->pict_type == AV_PICTURE_TYPE_S
1636  && ctx->vol_sprite_usage == GMC_SPRITE) {
1637  s->mcsel = 1;
1638  s->mb_skipped = 0;
1639  s->cur_pic.mbskip_table[xy] = 0;
1640  } else {
1641  s->mcsel = 0;
1642  s->mb_skipped = 1;
1643  s->cur_pic.mbskip_table[xy] = 1;
1644  }
1645  } else if (s->mb_intra) {
1646  s->ac_pred = IS_ACPRED(s->cur_pic.mb_type[xy]);
1647  } else if (!s->mb_intra) {
1648  // s->mcsel = 0; // FIXME do we need to init that?
1649 
1650  s->mv_dir = MV_DIR_FORWARD;
1651  if (IS_8X8(mb_type)) {
1652  s->mv_type = MV_TYPE_8X8;
1653  } else {
1654  s->mv_type = MV_TYPE_16X16;
1655  }
1656  }
1657  } else { /* I-Frame */
1658  s->mb_intra = 1;
1659  s->ac_pred = IS_ACPRED(s->cur_pic.mb_type[xy]);
1660  }
1661 
1662  if (!IS_SKIP(mb_type)) {
1663  int i;
1664  s->bdsp.clear_blocks(s->block[0]);
1665  /* decode each block */
1666  for (i = 0; i < 6; i++) {
1667  if (mpeg4_decode_block(ctx, block[i], i, cbp & 32, s->mb_intra,
1668  use_intra_dc_vlc, ctx->rvlc) < 0) {
1669  av_log(s->avctx, AV_LOG_ERROR,
1670  "texture corrupted at %d %d %d\n",
1671  s->mb_x, s->mb_y, s->mb_intra);
1672  return AVERROR_INVALIDDATA;
1673  }
1674  cbp += cbp;
1675  }
1676  }
1677 
1678  /* per-MB end of slice check */
1679  if (--s->mb_num_left <= 0) {
1680  if (mpeg4_is_resync(ctx))
1681  return SLICE_END;
1682  else
1683  return SLICE_NOEND;
1684  } else {
1685  if (mpeg4_is_resync(ctx)) {
1686  const int delta = s->mb_x + 1 == s->mb_width ? 2 : 1;
1687  if (s->cbp_table[xy + delta])
1688  return SLICE_END;
1689  }
1690  return SLICE_OK;
1691  }
1692 }
1693 
1694 static int mpeg4_decode_mb(MpegEncContext *s, int16_t block[6][64])
1695 {
1696  Mpeg4DecContext *ctx = s->avctx->priv_data;
1697  int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
1698  static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
1699  const int xy = s->mb_x + s->mb_y * s->mb_stride;
1700  int next;
1701 
1702  av_assert2(s == (void*)ctx);
1703  av_assert2(s->h263_pred);
1704 
1705  if (s->pict_type == AV_PICTURE_TYPE_P ||
1706  s->pict_type == AV_PICTURE_TYPE_S) {
1707  do {
1708  if (get_bits1(&s->gb)) {
1709  /* skip mb */
1710  s->mb_intra = 0;
1711  for (i = 0; i < 6; i++)
1712  s->block_last_index[i] = -1;
1713  s->mv_dir = MV_DIR_FORWARD;
1714  s->mv_type = MV_TYPE_16X16;
1715  if (s->pict_type == AV_PICTURE_TYPE_S &&
1716  ctx->vol_sprite_usage == GMC_SPRITE) {
1717  s->cur_pic.mb_type[xy] = MB_TYPE_SKIP |
1718  MB_TYPE_GMC |
1719  MB_TYPE_16x16 |
1720  MB_TYPE_FORWARD_MV;
1721  s->mcsel = 1;
1722  s->mv[0][0][0] = get_amv(ctx, 0);
1723  s->mv[0][0][1] = get_amv(ctx, 1);
1724  s->cur_pic.mbskip_table[xy] = 0;
1725  s->mb_skipped = 0;
1726  } else {
1727  s->cur_pic.mb_type[xy] = MB_TYPE_SKIP | MB_TYPE_16x16 |
1728  MB_TYPE_FORWARD_MV;
1729  s->mcsel = 0;
1730  s->mv[0][0][0] = 0;
1731  s->mv[0][0][1] = 0;
1732  s->cur_pic.mbskip_table[xy] = 1;
1733  s->mb_skipped = 1;
1734  }
1735  goto end;
1736  }
1737  cbpc = get_vlc2(&s->gb, ff_h263_inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 2);
1738  if (cbpc < 0) {
1739  av_log(s->avctx, AV_LOG_ERROR,
1740  "mcbpc damaged at %d %d\n", s->mb_x, s->mb_y);
1741  return AVERROR_INVALIDDATA;
1742  }
1743  } while (cbpc == 20);
1744 
1745  s->bdsp.clear_blocks(s->block[0]);
1746  dquant = cbpc & 8;
1747  s->mb_intra = ((cbpc & 4) != 0);
1748  if (s->mb_intra)
1749  goto intra;
1750 
1751  if (s->pict_type == AV_PICTURE_TYPE_S &&
1752  ctx->vol_sprite_usage == GMC_SPRITE && (cbpc & 16) == 0)
1753  s->mcsel = get_bits1(&s->gb);
1754  else
1755  s->mcsel = 0;
1756  cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc, CBPY_VLC_BITS, 1) ^ 0x0F;
1757  if (cbpy < 0) {
1758  av_log(s->avctx, AV_LOG_ERROR,
1759  "P cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
1760  return AVERROR_INVALIDDATA;
1761  }
1762 
1763  cbp = (cbpc & 3) | (cbpy << 2);
1764  if (dquant)
1765  ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
1766  if ((!s->progressive_sequence) &&
1767  (cbp || (s->workaround_bugs & FF_BUG_XVID_ILACE)))
1768  s->interlaced_dct = get_bits1(&s->gb);
1769 
1770  s->mv_dir = MV_DIR_FORWARD;
1771  if ((cbpc & 16) == 0) {
1772  if (s->mcsel) {
1773  s->cur_pic.mb_type[xy] = MB_TYPE_GMC | MB_TYPE_16x16 |
1774  MB_TYPE_FORWARD_MV;
1775  /* 16x16 global motion prediction */
1776  s->mv_type = MV_TYPE_16X16;
1777  mx = get_amv(ctx, 0);
1778  my = get_amv(ctx, 1);
1779  s->mv[0][0][0] = mx;
1780  s->mv[0][0][1] = my;
1781  } else if ((!s->progressive_sequence) && get_bits1(&s->gb)) {
1782  s->cur_pic.mb_type[xy] = MB_TYPE_16x8 | MB_TYPE_FORWARD_MV |
1783  MB_TYPE_INTERLACED;
1784  /* 16x8 field motion prediction */
1785  s->mv_type = MV_TYPE_FIELD;
1786 
1787  s->field_select[0][0] = get_bits1(&s->gb);
1788  s->field_select[0][1] = get_bits1(&s->gb);
1789 
1790  ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1791 
1792  for (i = 0; i < 2; i++) {
1793  mx = ff_h263_decode_motion(s, pred_x, s->f_code);
1794  if (mx >= 0xffff)
1795  return AVERROR_INVALIDDATA;
1796 
1797  my = ff_h263_decode_motion(s, pred_y / 2, s->f_code);
1798  if (my >= 0xffff)
1799  return AVERROR_INVALIDDATA;
1800 
1801  s->mv[0][i][0] = mx;
1802  s->mv[0][i][1] = my;
1803  }
1804  } else {
1805  s->cur_pic.mb_type[xy] = MB_TYPE_16x16 | MB_TYPE_FORWARD_MV;
1806  /* 16x16 motion prediction */
1807  s->mv_type = MV_TYPE_16X16;
1808  ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1809  mx = ff_h263_decode_motion(s, pred_x, s->f_code);
1810 
1811  if (mx >= 0xffff)
1812  return AVERROR_INVALIDDATA;
1813 
1814  my = ff_h263_decode_motion(s, pred_y, s->f_code);
1815 
1816  if (my >= 0xffff)
1817  return AVERROR_INVALIDDATA;
1818  s->mv[0][0][0] = mx;
1819  s->mv[0][0][1] = my;
1820  }
1821  } else {
1822  s->cur_pic.mb_type[xy] = MB_TYPE_8x8 | MB_TYPE_FORWARD_MV;
1823  s->mv_type = MV_TYPE_8X8;
1824  for (i = 0; i < 4; i++) {
1825  int16_t *mot_val = ff_h263_pred_motion(s, i, 0, &pred_x, &pred_y);
1826  mx = ff_h263_decode_motion(s, pred_x, s->f_code);
1827  if (mx >= 0xffff)
1828  return AVERROR_INVALIDDATA;
1829 
1830  my = ff_h263_decode_motion(s, pred_y, s->f_code);
1831  if (my >= 0xffff)
1832  return AVERROR_INVALIDDATA;
1833  s->mv[0][i][0] = mx;
1834  s->mv[0][i][1] = my;
1835  mot_val[0] = mx;
1836  mot_val[1] = my;
1837  }
1838  }
1839  } else if (s->pict_type == AV_PICTURE_TYPE_B) {
1840  int modb1; // first bit of modb
1841  int modb2; // second bit of modb
1842  int mb_type;
1843 
1844  s->mb_intra = 0; // B-frames never contain intra blocks
1845  s->mcsel = 0; // ... true gmc blocks
1846 
1847  if (s->mb_x == 0) {
1848  for (i = 0; i < 2; i++) {
1849  s->last_mv[i][0][0] =
1850  s->last_mv[i][0][1] =
1851  s->last_mv[i][1][0] =
1852  s->last_mv[i][1][1] = 0;
1853  }
1854 
1855  ff_thread_progress_await(&s->next_pic.ptr->progress, s->mb_y);
1856  }
1857 
1858  /* if we skipped it in the future P-frame than skip it now too */
1859  s->mb_skipped = s->next_pic.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]; // Note, skiptab=0 if last was GMC
1860 
1861  if (s->mb_skipped) {
1862  /* skip mb */
1863  for (i = 0; i < 6; i++)
1864  s->block_last_index[i] = -1;
1865 
1866  s->mv_dir = MV_DIR_FORWARD;
1867  s->mv_type = MV_TYPE_16X16;
1868  s->mv[0][0][0] =
1869  s->mv[0][0][1] =
1870  s->mv[1][0][0] =
1871  s->mv[1][0][1] = 0;
1872  s->cur_pic.mb_type[xy] = MB_TYPE_SKIP |
1873  MB_TYPE_16x16 |
1874  MB_TYPE_FORWARD_MV;
1875  goto end;
1876  }
1877 
1878  modb1 = get_bits1(&s->gb);
1879  if (modb1) {
1880  // like MB_TYPE_B_DIRECT but no vectors coded
1881  mb_type = MB_TYPE_DIRECT2 | MB_TYPE_SKIP | MB_TYPE_BIDIR_MV;
1882  cbp = 0;
1883  } else {
1884  modb2 = get_bits1(&s->gb);
1885  mb_type = get_vlc2(&s->gb, mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 1);
1886  if (mb_type < 0) {
1887  av_log(s->avctx, AV_LOG_ERROR, "illegal MB_type\n");
1888  return AVERROR_INVALIDDATA;
1889  }
1890  if (modb2) {
1891  cbp = 0;
1892  } else {
1893  s->bdsp.clear_blocks(s->block[0]);
1894  cbp = get_bits(&s->gb, 6);
1895  }
1896 
1897  if ((!IS_DIRECT(mb_type)) && cbp) {
1898  if (get_bits1(&s->gb))
1899  ff_set_qscale(s, s->qscale + get_bits1(&s->gb) * 4 - 2);
1900  }
1901 
1902  if (!s->progressive_sequence) {
1903  if (cbp)
1904  s->interlaced_dct = get_bits1(&s->gb);
1905 
1906  if (!IS_DIRECT(mb_type) && get_bits1(&s->gb)) {
1907  mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
1908  mb_type &= ~MB_TYPE_16x16;
1909 
1910  if (HAS_FORWARD_MV(mb_type)) {
1911  s->field_select[0][0] = get_bits1(&s->gb);
1912  s->field_select[0][1] = get_bits1(&s->gb);
1913  }
1914  if (HAS_BACKWARD_MV(mb_type)) {
1915  s->field_select[1][0] = get_bits1(&s->gb);
1916  s->field_select[1][1] = get_bits1(&s->gb);
1917  }
1918  }
1919  }
1920 
1921  s->mv_dir = 0;
1922  if ((mb_type & (MB_TYPE_DIRECT2 | MB_TYPE_INTERLACED)) == 0) {
1923  s->mv_type = MV_TYPE_16X16;
1924 
1925  if (HAS_FORWARD_MV(mb_type)) {
1926  s->mv_dir = MV_DIR_FORWARD;
1927 
1928  mx = ff_h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
1929  my = ff_h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
1930  s->last_mv[0][1][0] =
1931  s->last_mv[0][0][0] =
1932  s->mv[0][0][0] = mx;
1933  s->last_mv[0][1][1] =
1934  s->last_mv[0][0][1] =
1935  s->mv[0][0][1] = my;
1936  }
1937 
1938  if (HAS_BACKWARD_MV(mb_type)) {
1939  s->mv_dir |= MV_DIR_BACKWARD;
1940 
1941  mx = ff_h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
1942  my = ff_h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
1943  s->last_mv[1][1][0] =
1944  s->last_mv[1][0][0] =
1945  s->mv[1][0][0] = mx;
1946  s->last_mv[1][1][1] =
1947  s->last_mv[1][0][1] =
1948  s->mv[1][0][1] = my;
1949  }
1950  } else if (!IS_DIRECT(mb_type)) {
1951  s->mv_type = MV_TYPE_FIELD;
1952 
1953  if (HAS_FORWARD_MV(mb_type)) {
1954  s->mv_dir = MV_DIR_FORWARD;
1955 
1956  for (i = 0; i < 2; i++) {
1957  mx = ff_h263_decode_motion(s, s->last_mv[0][i][0], s->f_code);
1958  my = ff_h263_decode_motion(s, s->last_mv[0][i][1] / 2, s->f_code);
1959  s->last_mv[0][i][0] =
1960  s->mv[0][i][0] = mx;
1961  s->last_mv[0][i][1] = (s->mv[0][i][1] = my) * 2;
1962  }
1963  }
1964 
1965  if (HAS_BACKWARD_MV(mb_type)) {
1966  s->mv_dir |= MV_DIR_BACKWARD;
1967 
1968  for (i = 0; i < 2; i++) {
1969  mx = ff_h263_decode_motion(s, s->last_mv[1][i][0], s->b_code);
1970  my = ff_h263_decode_motion(s, s->last_mv[1][i][1] / 2, s->b_code);
1971  s->last_mv[1][i][0] =
1972  s->mv[1][i][0] = mx;
1973  s->last_mv[1][i][1] = (s->mv[1][i][1] = my) * 2;
1974  }
1975  }
1976  }
1977  }
1978 
1979  if (IS_DIRECT(mb_type)) {
1980  if (IS_SKIP(mb_type)) {
1981  mx =
1982  my = 0;
1983  } else {
1984  mx = ff_h263_decode_motion(s, 0, 1);
1985  my = ff_h263_decode_motion(s, 0, 1);
1986  }
1987 
1988  s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
1989  mb_type |= ff_mpeg4_set_direct_mv(s, mx, my);
1990  }
1991  s->cur_pic.mb_type[xy] = mb_type;
1992  } else { /* I-Frame */
1993  int use_intra_dc_vlc;
1994 
1995  do {
1996  cbpc = get_vlc2(&s->gb, ff_h263_intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 2);
1997  if (cbpc < 0) {
1998  av_log(s->avctx, AV_LOG_ERROR,
1999  "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
2000  return AVERROR_INVALIDDATA;
2001  }
2002  } while (cbpc == 8);
2003 
2004  dquant = cbpc & 4;
2005  s->mb_intra = 1;
2006 
2007 intra:
2008  s->ac_pred = get_bits1(&s->gb);
2009  if (s->ac_pred)
2010  s->cur_pic.mb_type[xy] = MB_TYPE_INTRA | MB_TYPE_ACPRED;
2011  else
2012  s->cur_pic.mb_type[xy] = MB_TYPE_INTRA;
2013 
2014  cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc, CBPY_VLC_BITS, 1);
2015  if (cbpy < 0) {
2016  av_log(s->avctx, AV_LOG_ERROR,
2017  "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
2018  return AVERROR_INVALIDDATA;
2019  }
2020  cbp = (cbpc & 3) | (cbpy << 2);
2021 
2022  use_intra_dc_vlc = s->qscale < ctx->intra_dc_threshold;
2023 
2024  if (dquant)
2025  ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
2026 
2027  if (!s->progressive_sequence)
2028  s->interlaced_dct = get_bits1(&s->gb);
2029 
2030  s->bdsp.clear_blocks(s->block[0]);
2031  /* decode each block */
2032  for (i = 0; i < 6; i++) {
2033  if (mpeg4_decode_block(ctx, block[i], i, cbp & 32,
2034  1, use_intra_dc_vlc, 0) < 0)
2035  return AVERROR_INVALIDDATA;
2036  cbp += cbp;
2037  }
2038  goto end;
2039  }
2040 
2041  /* decode each block */
2042  for (i = 0; i < 6; i++) {
2043  if (mpeg4_decode_block(ctx, block[i], i, cbp & 32, 0, 0, 0) < 0)
2044  return AVERROR_INVALIDDATA;
2045  cbp += cbp;
2046  }
2047 
2048 end:
2049  /* per-MB end of slice check */
2050  next = mpeg4_is_resync(ctx);
2051  if (next) {
2052  if (s->mb_x + s->mb_y*s->mb_width + 1 > next && (s->avctx->err_recognition & AV_EF_AGGRESSIVE)) {
2053  return AVERROR_INVALIDDATA;
2054  } else if (s->mb_x + s->mb_y*s->mb_width + 1 >= next)
2055  return SLICE_END;
2056 
2057  if (s->pict_type == AV_PICTURE_TYPE_B) {
2058  const int delta = s->mb_x + 1 == s->mb_width ? 2 : 1;
2059  ff_thread_progress_await(&s->next_pic.ptr->progress,
2060  (s->mb_x + delta >= s->mb_width)
2061  ? FFMIN(s->mb_y + 1, s->mb_height - 1)
2062  : s->mb_y);
2063  if (s->next_pic.mbskip_table[xy + delta])
2064  return SLICE_OK;
2065  }
2066 
2067  return SLICE_END;
2068  }
2069 
2070  return SLICE_OK;
2071 }
2072 
2073 /* As per spec, studio start code search isn't the same as the old type of start code */
2074 static void next_start_code_studio(GetBitContext *gb)
2075 {
2076  align_get_bits(gb);
2077 
2078  while (get_bits_left(gb) >= 24 && show_bits(gb, 24) != 0x1) {
2079  get_bits(gb, 8);
2080  }
2081 }
2082 
2083 /* additional_code, vlc index */
2084 static const uint8_t ac_state_tab[22][2] =
2085 {
2086  {0, 0},
2087  {0, 1},
2088  {1, 1},
2089  {2, 1},
2090  {3, 1},
2091  {4, 1},
2092  {5, 1},
2093  {1, 2},
2094  {2, 2},
2095  {3, 2},
2096  {4, 2},
2097  {5, 2},
2098  {6, 2},
2099  {1, 3},
2100  {2, 4},
2101  {3, 5},
2102  {4, 6},
2103  {5, 7},
2104  {6, 8},
2105  {7, 9},
2106  {8, 10},
2107  {0, 11}
2108 };
2109 
2110 static int mpeg4_decode_studio_block(MpegEncContext *s, int32_t block[64], int n)
2111 {
2112  Mpeg4DecContext *ctx = s->avctx->priv_data;
2113 
2114  int cc, dct_dc_size, dct_diff, code, j, idx = 1, group = 0, run = 0,
2115  additional_code_len, sign, mismatch;
2116  const VLCElem *cur_vlc = studio_intra_tab[0];
2117  const uint8_t *const scantable = s->intra_scantable.permutated;
2118  const uint16_t *quant_matrix;
2119  uint32_t flc;
2120  const int min = -1 * (1 << (s->avctx->bits_per_raw_sample + 6));
2121  const int max = ((1 << (s->avctx->bits_per_raw_sample + 6)) - 1);
2122  int shift = 3 - s->dct_precision;
2123 
2124  mismatch = 1;
2125 
2126  memset(block, 0, 64 * sizeof(int32_t));
2127 
2128  if (n < 4) {
2129  cc = 0;
2130  dct_dc_size = get_vlc2(&s->gb, studio_luma_dc, STUDIO_INTRA_BITS, 2);
2131  quant_matrix = s->intra_matrix;
2132  } else {
2133  cc = (n & 1) + 1;
2134  if (ctx->rgb)
2135  dct_dc_size = get_vlc2(&s->gb, studio_luma_dc, STUDIO_INTRA_BITS, 2);
2136  else
2137  dct_dc_size = get_vlc2(&s->gb, studio_chroma_dc, STUDIO_INTRA_BITS, 2);
2138  quant_matrix = s->chroma_intra_matrix;
2139  }
2140 
2141  if (dct_dc_size == 0) {
2142  dct_diff = 0;
2143  } else {
2144  dct_diff = get_xbits(&s->gb, dct_dc_size);
2145 
2146  if (dct_dc_size > 8) {
2147  if(!check_marker(s->avctx, &s->gb, "dct_dc_size > 8"))
2148  return AVERROR_INVALIDDATA;
2149  }
2150 
2151  }
2152 
2153  s->last_dc[cc] += dct_diff;
2154 
2155  if (s->mpeg_quant)
2156  block[0] = s->last_dc[cc] * (8 >> s->intra_dc_precision);
2157  else
2158  block[0] = s->last_dc[cc] * (8 >> s->intra_dc_precision) * (8 >> s->dct_precision);
2159  /* TODO: support mpeg_quant for AC coefficients */
2160 
2161  block[0] = av_clip(block[0], min, max);
2162  mismatch ^= block[0];
2163 
2164  /* AC Coefficients */
2165  while (1) {
2166  group = get_vlc2(&s->gb, cur_vlc, STUDIO_INTRA_BITS, 2);
2167 
2168  if (group < 0) {
2169  av_log(s->avctx, AV_LOG_ERROR, "illegal ac coefficient group vlc\n");
2170  return AVERROR_INVALIDDATA;
2171  }
2172 
2173  additional_code_len = ac_state_tab[group][0];
2174  cur_vlc = studio_intra_tab[ac_state_tab[group][1]];
2175 
2176  if (group == 0) {
2177  /* End of Block */
2178  break;
2179  } else if (group >= 1 && group <= 6) {
2180  /* Zero run length (Table B.47) */
2181  run = 1 << additional_code_len;
2182  if (additional_code_len)
2183  run += get_bits(&s->gb, additional_code_len);
2184  idx += run;
2185  continue;
2186  } else if (group >= 7 && group <= 12) {
2187  /* Zero run length and +/-1 level (Table B.48) */
2188  code = get_bits(&s->gb, additional_code_len);
2189  sign = code & 1;
2190  code >>= 1;
2191  run = (1 << (additional_code_len - 1)) + code;
2192  idx += run;
2193  if (idx > 63)
2194  return AVERROR_INVALIDDATA;
2195  j = scantable[idx++];
2196  block[j] = sign ? 1 : -1;
2197  } else if (group >= 13 && group <= 20) {
2198  /* Level value (Table B.49) */
2199  if (idx > 63)
2200  return AVERROR_INVALIDDATA;
2201  j = scantable[idx++];
2202  block[j] = get_xbits(&s->gb, additional_code_len);
2203  } else if (group == 21) {
2204  /* Escape */
2205  if (idx > 63)
2206  return AVERROR_INVALIDDATA;
2207  j = scantable[idx++];
2208  additional_code_len = s->avctx->bits_per_raw_sample + s->dct_precision + 4;
2209  flc = get_bits(&s->gb, additional_code_len);
2210  if (flc >> (additional_code_len-1))
2211  block[j] = -1 * (( flc ^ ((1 << additional_code_len) -1)) + 1);
2212  else
2213  block[j] = flc;
2214  }
2215  block[j] = ((block[j] * quant_matrix[j] * s->qscale) * (1 << shift)) / 16;
2216  block[j] = av_clip(block[j], min, max);
2217  mismatch ^= block[j];
2218  }
2219 
2220  block[63] ^= mismatch & 1;
2221 
2222  return 0;
2223 }
2224 
2225 static int mpeg4_decode_dpcm_macroblock(MpegEncContext *s, int16_t macroblock[256], int n)
2226 {
2227  int i, j, w, h, idx = 0;
2228  int block_mean, rice_parameter, rice_prefix_code, rice_suffix_code,
2229  dpcm_residual, left, top, topleft, min_left_top, max_left_top, p, p2, output;
2230  h = 16 >> (n ? s->chroma_y_shift : 0);
2231  w = 16 >> (n ? s->chroma_x_shift : 0);
2232 
2233  block_mean = get_bits(&s->gb, s->avctx->bits_per_raw_sample);
2234  if (block_mean == 0){
2235  av_log(s->avctx, AV_LOG_ERROR, "Forbidden block_mean\n");
2236  return AVERROR_INVALIDDATA;
2237  }
2238  s->last_dc[n] = block_mean * (1 << (s->dct_precision + s->intra_dc_precision));
2239 
2240  rice_parameter = get_bits(&s->gb, 4);
2241  if (rice_parameter == 0) {
2242  av_log(s->avctx, AV_LOG_ERROR, "Forbidden rice_parameter\n");
2243  return AVERROR_INVALIDDATA;
2244  }
2245 
2246  if (rice_parameter == 15)
2247  rice_parameter = 0;
2248 
2249  if (rice_parameter > 11) {
2250  av_log(s->avctx, AV_LOG_ERROR, "Forbidden rice_parameter\n");
2251  return AVERROR_INVALIDDATA;
2252  }
2253 
2254  for (i = 0; i < h; i++) {
2255  output = 1 << (s->avctx->bits_per_raw_sample - 1);
2256  top = 1 << (s->avctx->bits_per_raw_sample - 1);
2257 
2258  for (j = 0; j < w; j++) {
2259  left = output;
2260  topleft = top;
2261 
2262  rice_prefix_code = get_unary(&s->gb, 1, 12);
2263 
2264  /* Escape */
2265  if (rice_prefix_code == 11)
2266  dpcm_residual = get_bits(&s->gb, s->avctx->bits_per_raw_sample);
2267  else {
2268  if (rice_prefix_code == 12) {
2269  av_log(s->avctx, AV_LOG_ERROR, "Forbidden rice_prefix_code\n");
2270  return AVERROR_INVALIDDATA;
2271  }
2272  rice_suffix_code = get_bitsz(&s->gb, rice_parameter);
2273  dpcm_residual = (rice_prefix_code << rice_parameter) + rice_suffix_code;
2274  }
2275 
2276  /* Map to a signed residual */
2277  if (dpcm_residual & 1)
2278  dpcm_residual = (-1 * dpcm_residual) >> 1;
2279  else
2280  dpcm_residual = (dpcm_residual >> 1);
2281 
2282  if (i != 0)
2283  top = macroblock[idx-w];
2284 
2285  p = left + top - topleft;
2286  min_left_top = FFMIN(left, top);
2287  if (p < min_left_top)
2288  p = min_left_top;
2289 
2290  max_left_top = FFMAX(left, top);
2291  if (p > max_left_top)
2292  p = max_left_top;
2293 
2294  p2 = (FFMIN(min_left_top, topleft) + FFMAX(max_left_top, topleft)) >> 1;
2295  if (p2 == p)
2296  p2 = block_mean;
2297 
2298  if (p2 > p)
2299  dpcm_residual *= -1;
2300 
2301  macroblock[idx++] = output = (dpcm_residual + p) & ((1 << s->avctx->bits_per_raw_sample) - 1);
2302  }
2303  }
2304 
2305  return 0;
2306 }
2307 
2308 static int mpeg4_decode_studio_mb(MpegEncContext *s, int16_t block_[12][64])
2309 {
2310  Mpeg4DecContext *const ctx = (Mpeg4DecContext*)s;
2311  int i;
2312 
2313  ctx->dpcm_direction = 0;
2314 
2315  /* StudioMacroblock */
2316  /* Assumes I-VOP */
2317  s->mb_intra = 1;
2318  if (get_bits1(&s->gb)) { /* compression_mode */
2319  /* DCT */
2320  /* macroblock_type, 1 or 2-bit VLC */
2321  if (!get_bits1(&s->gb)) {
2322  skip_bits1(&s->gb);
2323  s->qscale = mpeg_get_qscale(s);
2324  }
2325 
2326  for (i = 0; i < mpeg4_block_count[s->chroma_format]; i++) {
2327  if (mpeg4_decode_studio_block(s, ctx->block32[i], i) < 0)
2328  return AVERROR_INVALIDDATA;
2329  }
2330  } else {
2331  /* DPCM */
2332  check_marker(s->avctx, &s->gb, "DPCM block start");
2333  ctx->dpcm_direction = get_bits1(&s->gb) ? -1 : 1;
2334  for (i = 0; i < 3; i++) {
2335  if (mpeg4_decode_dpcm_macroblock(s, ctx->dpcm_macroblock[i], i) < 0)
2336  return AVERROR_INVALIDDATA;
2337  }
2338  }
2339 
2340  if (get_bits_left(&s->gb) >= 24 && show_bits(&s->gb, 23) == 0) {
2341  next_start_code_studio(&s->gb);
2342  return SLICE_END;
2343  }
2344 
2345  //vcon-stp9L1.bits (first frame)
2346  if (get_bits_left(&s->gb) == 0)
2347  return SLICE_END;
2348 
2349  //vcon-stp2L1.bits, vcon-stp3L1.bits, vcon-stp6L1.bits, vcon-stp7L1.bits, vcon-stp8L1.bits, vcon-stp10L1.bits (first frame)
2350  if (get_bits_left(&s->gb) < 8U && show_bits(&s->gb, get_bits_left(&s->gb)) == 0)
2351  return SLICE_END;
2352 
2353  return SLICE_OK;
2354 }
2355 
2356 static int mpeg4_decode_gop_header(MpegEncContext *s, GetBitContext *gb)
2357 {
2358  int hours, minutes, seconds;
2359 
2360  if (!show_bits(gb, 23)) {
2361  av_log(s->avctx, AV_LOG_WARNING, "GOP header invalid\n");
2362  return AVERROR_INVALIDDATA;
2363  }
2364 
2365  hours = get_bits(gb, 5);
2366  minutes = get_bits(gb, 6);
2367  check_marker(s->avctx, gb, "in gop_header");
2368  seconds = get_bits(gb, 6);
2369 
2370  s->time_base = seconds + 60*(minutes + 60*hours);
2371 
2372  skip_bits1(gb);
2373  skip_bits1(gb);
2374 
2375  return 0;
2376 }
2377 
2378 static int mpeg4_decode_profile_level(MpegEncContext *s, GetBitContext *gb, int *profile, int *level)
2379 {
2380 
2381  *profile = get_bits(gb, 4);
2382  *level = get_bits(gb, 4);
2383 
2384  // for Simple profile, level 0
2385  if (*profile == 0 && *level == 8) {
2386  *level = 0;
2387  }
2388 
2389  return 0;
2390 }
2391 
2392 static int mpeg4_decode_visual_object(MpegEncContext *s, GetBitContext *gb)
2393 {
2394  int visual_object_type;
2395  int is_visual_object_identifier = get_bits1(gb);
2396 
2397  if (is_visual_object_identifier) {
2398  skip_bits(gb, 4+3);
2399  }
2400  visual_object_type = get_bits(gb, 4);
2401 
2402  if (visual_object_type == VOT_VIDEO_ID ||
2403  visual_object_type == VOT_STILL_TEXTURE_ID) {
2404  int video_signal_type = get_bits1(gb);
2405  if (video_signal_type) {
2406  int video_range, color_description;
2407  skip_bits(gb, 3); // video_format
2408  video_range = get_bits1(gb);
2409  color_description = get_bits1(gb);
2410 
2411  s->avctx->color_range = video_range ? AVCOL_RANGE_JPEG : AVCOL_RANGE_MPEG;
2412 
2413  if (color_description) {
2414  s->avctx->color_primaries = get_bits(gb, 8);
2415  s->avctx->color_trc = get_bits(gb, 8);
2416  s->avctx->colorspace = get_bits(gb, 8);
2417  }
2418  }
2419  }
2420 
2421  return 0;
2422 }
2423 
2424 static void mpeg4_load_default_matrices(MpegEncContext *s)
2425 {
2426  int i, v;
2427 
2428  /* load default matrices */
2429  for (i = 0; i < 64; i++) {
2430  int j = s->idsp.idct_permutation[i];
2431  v = ff_mpeg4_default_intra_matrix[i];
2432  s->intra_matrix[j] = v;
2433  s->chroma_intra_matrix[j] = v;
2434 
2435  v = ff_mpeg4_default_non_intra_matrix[i];
2436  s->inter_matrix[j] = v;
2437  s->chroma_inter_matrix[j] = v;
2438  }
2439 }
2440 
2441 static int read_quant_matrix_ext(MpegEncContext *s, GetBitContext *gb)
2442 {
2443  int i, j, v;
2444 
2445  if (get_bits1(gb)) {
2446  if (get_bits_left(gb) < 64*8)
2447  return AVERROR_INVALIDDATA;
2448  /* intra_quantiser_matrix */
2449  for (i = 0; i < 64; i++) {
2450  v = get_bits(gb, 8);
2451  j = s->idsp.idct_permutation[ff_zigzag_direct[i]];
2452  s->intra_matrix[j] = v;
2453  s->chroma_intra_matrix[j] = v;
2454  }
2455  }
2456 
2457  if (get_bits1(gb)) {
2458  if (get_bits_left(gb) < 64*8)
2459  return AVERROR_INVALIDDATA;
2460  /* non_intra_quantiser_matrix */
2461  for (i = 0; i < 64; i++) {
2462  get_bits(gb, 8);
2463  }
2464  }
2465 
2466  if (get_bits1(gb)) {
2467  if (get_bits_left(gb) < 64*8)
2468  return AVERROR_INVALIDDATA;
2469  /* chroma_intra_quantiser_matrix */
2470  for (i = 0; i < 64; i++) {
2471  v = get_bits(gb, 8);
2472  j = s->idsp.idct_permutation[ff_zigzag_direct[i]];
2473  s->chroma_intra_matrix[j] = v;
2474  }
2475  }
2476 
2477  if (get_bits1(gb)) {
2478  if (get_bits_left(gb) < 64*8)
2479  return AVERROR_INVALIDDATA;
2480  /* chroma_non_intra_quantiser_matrix */
2481  for (i = 0; i < 64; i++) {
2482  get_bits(gb, 8);
2483  }
2484  }
2485 
2486  next_start_code_studio(gb);
2487  return 0;
2488 }
2489 
2490 static void extension_and_user_data(MpegEncContext *s, GetBitContext *gb, int id)
2491 {
2492  uint32_t startcode;
2493  uint8_t extension_type;
2494 
2495  startcode = show_bits_long(gb, 32);
2496  if (startcode == USER_DATA_STARTCODE || startcode == EXT_STARTCODE) {
2497 
2498  if ((id == 2 || id == 4) && startcode == EXT_STARTCODE) {
2499  skip_bits_long(gb, 32);
2500  extension_type = get_bits(gb, 4);
2501  if (extension_type == QUANT_MATRIX_EXT_ID)
2502  read_quant_matrix_ext(s, gb);
2503  }
2504  }
2505 }
2506 
2507 static int decode_studio_vol_header(Mpeg4DecContext *ctx, GetBitContext *gb)
2508 {
2509  MpegEncContext *s = &ctx->m;
2510  int width, height, aspect_ratio_info;
2511  int bits_per_raw_sample;
2512  int rgb, chroma_format;
2513 
2514  // random_accessible_vol and video_object_type_indication have already
2515  // been read by the caller decode_vol_header()
2516  skip_bits(gb, 4); /* video_object_layer_verid */
2517  ctx->shape = get_bits(gb, 2); /* video_object_layer_shape */
2518  skip_bits(gb, 4); /* video_object_layer_shape_extension */
2519  skip_bits1(gb); /* progressive_sequence */
2520  if (ctx->shape != RECT_SHAPE) {
2521  avpriv_request_sample(s->avctx, "MPEG-4 Studio profile non rectangular shape");
2522  return AVERROR_PATCHWELCOME;
2523  }
2524  if (ctx->shape != BIN_ONLY_SHAPE) {
2525  rgb = get_bits1(gb); /* rgb_components */
2526  chroma_format = get_bits(gb, 2); /* chroma_format */
2527  if (!chroma_format || chroma_format == CHROMA_420 || (rgb && chroma_format == CHROMA_422)) {
2528  av_log(s->avctx, AV_LOG_ERROR, "illegal chroma format\n");
2529  return AVERROR_INVALIDDATA;
2530  }
2531 
2532  bits_per_raw_sample = get_bits(gb, 4); /* bit_depth */
2533  if (bits_per_raw_sample == 10) {
2534  if (rgb) {
2535  s->avctx->pix_fmt = AV_PIX_FMT_GBRP10;
2536  } else {
2537  s->avctx->pix_fmt = chroma_format == CHROMA_422 ? AV_PIX_FMT_YUV422P10 : AV_PIX_FMT_YUV444P10;
2538  }
2539  } else {
2540  avpriv_request_sample(s->avctx, "MPEG-4 Studio profile bit-depth %u", bits_per_raw_sample);
2541  return AVERROR_PATCHWELCOME;
2542  }
2543  if (rgb != ctx->rgb || s->chroma_format != chroma_format)
2544  s->context_reinit = 1;
2545  s->avctx->bits_per_raw_sample = bits_per_raw_sample;
2546  ctx->rgb = rgb;
2547  s->chroma_format = chroma_format;
2548  }
2549  if (ctx->shape == RECT_SHAPE) {
2550  check_marker(s->avctx, gb, "before video_object_layer_width");
2551  width = get_bits(gb, 14); /* video_object_layer_width */
2552  check_marker(s->avctx, gb, "before video_object_layer_height");
2553  height = get_bits(gb, 14); /* video_object_layer_height */
2554  check_marker(s->avctx, gb, "after video_object_layer_height");
2555 
2556  /* Do the same check as non-studio profile */
2557  if (width && height) {
2558  if (s->width && s->height &&
2559  (s->width != width || s->height != height))
2560  s->context_reinit = 1;
2561  s->width = width;
2562  s->height = height;
2563  }
2564  }
2565  aspect_ratio_info = get_bits(gb, 4);
2566  if (aspect_ratio_info == FF_ASPECT_EXTENDED) {
2567  s->avctx->sample_aspect_ratio.num = get_bits(gb, 8); // par_width
2568  s->avctx->sample_aspect_ratio.den = get_bits(gb, 8); // par_height
2569  } else {
2570  s->avctx->sample_aspect_ratio = ff_h263_pixel_aspect[aspect_ratio_info];
2571  }
2572  skip_bits(gb, 4); /* frame_rate_code */
2573  skip_bits(gb, 15); /* first_half_bit_rate */
2574  check_marker(s->avctx, gb, "after first_half_bit_rate");
2575  skip_bits(gb, 15); /* latter_half_bit_rate */
2576  check_marker(s->avctx, gb, "after latter_half_bit_rate");
2577  skip_bits(gb, 15); /* first_half_vbv_buffer_size */
2578  check_marker(s->avctx, gb, "after first_half_vbv_buffer_size");
2579  skip_bits(gb, 3); /* latter_half_vbv_buffer_size */
2580  skip_bits(gb, 11); /* first_half_vbv_buffer_size */
2581  check_marker(s->avctx, gb, "after first_half_vbv_buffer_size");
2582  skip_bits(gb, 15); /* latter_half_vbv_occupancy */
2583  check_marker(s->avctx, gb, "after latter_half_vbv_occupancy");
2584  s->low_delay = get_bits1(gb);
2585  s->mpeg_quant = get_bits1(gb); /* mpeg2_stream */
2586 
2587  next_start_code_studio(gb);
2588  extension_and_user_data(s, gb, 2);
2589 
2590  return 0;
2591 }
2592 
2593 static int decode_vol_header(Mpeg4DecContext *ctx, GetBitContext *gb)
2594 {
2595  MpegEncContext *s = &ctx->m;
2596  int width, height, vo_ver_id, aspect_ratio_info;
2597 
2598  /* vol header */
2599  skip_bits(gb, 1); /* random access */
2600  ctx->vo_type = get_bits(gb, 8);
2601 
2602  /* If we are in studio profile (per vo_type), check if its all consistent
2603  * and if so continue pass control to decode_studio_vol_header().
2604  * elIf something is inconsistent, error out
2605  * else continue with (non studio) vol header decpoding.
2606  */
2607  if (ctx->vo_type == CORE_STUDIO_VO_TYPE ||
2608  ctx->vo_type == SIMPLE_STUDIO_VO_TYPE) {
2609  if (s->avctx->profile != AV_PROFILE_UNKNOWN && s->avctx->profile != AV_PROFILE_MPEG4_SIMPLE_STUDIO)
2610  return AVERROR_INVALIDDATA;
2611  s->studio_profile = 1;
2612  s->avctx->profile = AV_PROFILE_MPEG4_SIMPLE_STUDIO;
2613  return decode_studio_vol_header(ctx, gb);
2614  } else if (s->studio_profile) {
2615  return AVERROR_PATCHWELCOME;
2616  }
2617 
2618  if (get_bits1(gb) != 0) { /* is_ol_id */
2619  vo_ver_id = get_bits(gb, 4); /* vo_ver_id */
2620  skip_bits(gb, 3); /* vo_priority */
2621  } else {
2622  vo_ver_id = 1;
2623  }
2624  aspect_ratio_info = get_bits(gb, 4);
2625  if (aspect_ratio_info == FF_ASPECT_EXTENDED) {
2626  s->avctx->sample_aspect_ratio.num = get_bits(gb, 8); // par_width
2627  s->avctx->sample_aspect_ratio.den = get_bits(gb, 8); // par_height
2628  } else {
2629  s->avctx->sample_aspect_ratio = ff_h263_pixel_aspect[aspect_ratio_info];
2630  }
2631 
2632  if ((ctx->vol_control_parameters = get_bits1(gb))) { /* vol control parameter */
2633  int chroma_format = get_bits(gb, 2);
2634  if (chroma_format != CHROMA_420)
2635  av_log(s->avctx, AV_LOG_ERROR, "illegal chroma format\n");
2636 
2637  s->low_delay = get_bits1(gb);
2638  if (get_bits1(gb)) { /* vbv parameters */
2639  get_bits(gb, 15); /* first_half_bitrate */
2640  check_marker(s->avctx, gb, "after first_half_bitrate");
2641  get_bits(gb, 15); /* latter_half_bitrate */
2642  check_marker(s->avctx, gb, "after latter_half_bitrate");
2643  get_bits(gb, 15); /* first_half_vbv_buffer_size */
2644  check_marker(s->avctx, gb, "after first_half_vbv_buffer_size");
2645  get_bits(gb, 3); /* latter_half_vbv_buffer_size */
2646  get_bits(gb, 11); /* first_half_vbv_occupancy */
2647  check_marker(s->avctx, gb, "after first_half_vbv_occupancy");
2648  get_bits(gb, 15); /* latter_half_vbv_occupancy */
2649  check_marker(s->avctx, gb, "after latter_half_vbv_occupancy");
2650  }
2651  } else {
2652  /* is setting low delay flag only once the smartest thing to do?
2653  * low delay detection will not be overridden. */
2654  if (s->picture_number == 0) {
2655  switch (ctx->vo_type) {
2656  case SIMPLE_VO_TYPE:
2657  case ADV_SIMPLE_VO_TYPE:
2658  s->low_delay = 1;
2659  break;
2660  default:
2661  s->low_delay = 0;
2662  }
2663  }
2664  }
2665 
2666  ctx->shape = get_bits(gb, 2); /* vol shape */
2667  if (ctx->shape != RECT_SHAPE)
2668  av_log(s->avctx, AV_LOG_ERROR, "only rectangular vol supported\n");
2669  if (ctx->shape == GRAY_SHAPE && vo_ver_id != 1) {
2670  av_log(s->avctx, AV_LOG_ERROR, "Gray shape not supported\n");
2671  skip_bits(gb, 4); /* video_object_layer_shape_extension */
2672  }
2673 
2674  check_marker(s->avctx, gb, "before time_increment_resolution");
2675 
2676  s->avctx->framerate.num = get_bits(gb, 16);
2677  if (!s->avctx->framerate.num) {
2678  av_log(s->avctx, AV_LOG_ERROR, "framerate==0\n");
2679  return AVERROR_INVALIDDATA;
2680  }
2681 
2682  ctx->time_increment_bits = av_log2(s->avctx->framerate.num - 1) + 1;
2683  if (ctx->time_increment_bits < 1)
2684  ctx->time_increment_bits = 1;
2685 
2686  check_marker(s->avctx, gb, "before fixed_vop_rate");
2687 
2688  if (get_bits1(gb) != 0) /* fixed_vop_rate */
2689  s->avctx->framerate.den = get_bits(gb, ctx->time_increment_bits);
2690  else
2691  s->avctx->framerate.den = 1;
2692 
2693  ctx->t_frame = 0;
2694 
2695  if (ctx->shape != BIN_ONLY_SHAPE) {
2696  if (ctx->shape == RECT_SHAPE) {
2697  check_marker(s->avctx, gb, "before width");
2698  width = get_bits(gb, 13);
2699  check_marker(s->avctx, gb, "before height");
2700  height = get_bits(gb, 13);
2701  check_marker(s->avctx, gb, "after height");
2702  if (width && height && /* they should be non zero but who knows */
2703  !(s->width && s->codec_tag == AV_RL32("MP4S"))) {
2704  if (s->width && s->height &&
2705  (s->width != width || s->height != height))
2706  s->context_reinit = 1;
2707  s->width = width;
2708  s->height = height;
2709  }
2710  }
2711 
2712  s->progressive_sequence =
2713  s->progressive_frame = get_bits1(gb) ^ 1;
2714  s->interlaced_dct = 0;
2715  if (!get_bits1(gb) && (s->avctx->debug & FF_DEBUG_PICT_INFO))
2716  av_log(s->avctx, AV_LOG_INFO, /* OBMC Disable */
2717  "MPEG-4 OBMC not supported (very likely buggy encoder)\n");
2718  if (vo_ver_id == 1)
2719  ctx->vol_sprite_usage = get_bits1(gb); /* vol_sprite_usage */
2720  else
2721  ctx->vol_sprite_usage = get_bits(gb, 2); /* vol_sprite_usage */
2722 
2723  if (ctx->vol_sprite_usage == STATIC_SPRITE)
2724  av_log(s->avctx, AV_LOG_ERROR, "Static Sprites not supported\n");
2725  if (ctx->vol_sprite_usage == STATIC_SPRITE ||
2726  ctx->vol_sprite_usage == GMC_SPRITE) {
2727  if (ctx->vol_sprite_usage == STATIC_SPRITE) {
2728  skip_bits(gb, 13); // sprite_width
2729  check_marker(s->avctx, gb, "after sprite_width");
2730  skip_bits(gb, 13); // sprite_height
2731  check_marker(s->avctx, gb, "after sprite_height");
2732  skip_bits(gb, 13); // sprite_left
2733  check_marker(s->avctx, gb, "after sprite_left");
2734  skip_bits(gb, 13); // sprite_top
2735  check_marker(s->avctx, gb, "after sprite_top");
2736  }
2737  ctx->num_sprite_warping_points = get_bits(gb, 6);
2738  if (ctx->num_sprite_warping_points > 3) {
2739  av_log(s->avctx, AV_LOG_ERROR,
2740  "%d sprite_warping_points\n",
2741  ctx->num_sprite_warping_points);
2742  ctx->num_sprite_warping_points = 0;
2743  return AVERROR_INVALIDDATA;
2744  }
2745  ctx->sprite_warping_accuracy = get_bits(gb, 2);
2746  ctx->sprite_brightness_change = get_bits1(gb);
2747  if (ctx->vol_sprite_usage == STATIC_SPRITE)
2748  skip_bits1(gb); // low_latency_sprite
2749  }
2750  // FIXME sadct disable bit if verid!=1 && shape not rect
2751 
2752  if (get_bits1(gb) == 1) { /* not_8_bit */
2753  ctx->quant_precision = get_bits(gb, 4); /* quant_precision */
2754  if (get_bits(gb, 4) != 8) /* bits_per_pixel */
2755  av_log(s->avctx, AV_LOG_ERROR, "N-bit not supported\n");
2756  if (ctx->quant_precision != 5)
2757  av_log(s->avctx, AV_LOG_ERROR,
2758  "quant precision %d\n", ctx->quant_precision);
2759  if (ctx->quant_precision < 3 || ctx->quant_precision > 9)
2760  ctx->quant_precision = 5;
2761  } else {
2762  ctx->quant_precision = 5;
2763  }
2764 
2765  // FIXME a bunch of grayscale shape things
2766 
2767  if ((s->mpeg_quant = get_bits1(gb))) { /* vol_quant_type */
2768  int i, v;
2769 
2770  mpeg4_load_default_matrices(s);
2771 
2772  /* load custom intra matrix */
2773  if (get_bits1(gb)) {
2774  int last = 0;
2775  for (i = 0; i < 64; i++) {
2776  int j;
2777  if (get_bits_left(gb) < 8) {
2778  av_log(s->avctx, AV_LOG_ERROR, "insufficient data for custom matrix\n");
2779  return AVERROR_INVALIDDATA;
2780  }
2781  v = get_bits(gb, 8);
2782  if (v == 0)
2783  break;
2784 
2785  last = v;
2786  j = s->idsp.idct_permutation[ff_zigzag_direct[i]];
2787  s->intra_matrix[j] = last;
2788  s->chroma_intra_matrix[j] = last;
2789  }
2790 
2791  /* replicate last value */
2792  for (; i < 64; i++) {
2793  int j = s->idsp.idct_permutation[ff_zigzag_direct[i]];
2794  s->intra_matrix[j] = last;
2795  s->chroma_intra_matrix[j] = last;
2796  }
2797  }
2798 
2799  /* load custom non intra matrix */
2800  if (get_bits1(gb)) {
2801  int last = 0;
2802  for (i = 0; i < 64; i++) {
2803  int j;
2804  if (get_bits_left(gb) < 8) {
2805  av_log(s->avctx, AV_LOG_ERROR, "insufficient data for custom matrix\n");
2806  return AVERROR_INVALIDDATA;
2807  }
2808  v = get_bits(gb, 8);
2809  if (v == 0)
2810  break;
2811 
2812  last = v;
2813  j = s->idsp.idct_permutation[ff_zigzag_direct[i]];
2814  s->inter_matrix[j] = v;
2815  s->chroma_inter_matrix[j] = v;
2816  }
2817 
2818  /* replicate last value */
2819  for (; i < 64; i++) {
2820  int j = s->idsp.idct_permutation[ff_zigzag_direct[i]];
2821  s->inter_matrix[j] = last;
2822  s->chroma_inter_matrix[j] = last;
2823  }
2824  }
2825 
2826  // FIXME a bunch of grayscale shape things
2827  }
2828 
2829  if (vo_ver_id != 1)
2830  s->quarter_sample = get_bits1(gb);
2831  else
2832  s->quarter_sample = 0;
2833 
2834  if (get_bits_left(gb) < 4) {
2835  av_log(s->avctx, AV_LOG_ERROR, "VOL Header truncated\n");
2836  return AVERROR_INVALIDDATA;
2837  }
2838 
2839  if (!get_bits1(gb)) {
2840  int pos = get_bits_count(gb);
2841  int estimation_method = get_bits(gb, 2);
2842  if (estimation_method < 2) {
2843  if (!get_bits1(gb)) {
2844  ctx->cplx_estimation_trash_i += 8 * get_bits1(gb); /* opaque */
2845  ctx->cplx_estimation_trash_i += 8 * get_bits1(gb); /* transparent */
2846  ctx->cplx_estimation_trash_i += 8 * get_bits1(gb); /* intra_cae */
2847  ctx->cplx_estimation_trash_i += 8 * get_bits1(gb); /* inter_cae */
2848  ctx->cplx_estimation_trash_i += 8 * get_bits1(gb); /* no_update */
2849  ctx->cplx_estimation_trash_i += 8 * get_bits1(gb); /* upsampling */
2850  }
2851  if (!get_bits1(gb)) {
2852  ctx->cplx_estimation_trash_i += 8 * get_bits1(gb); /* intra_blocks */
2853  ctx->cplx_estimation_trash_p += 8 * get_bits1(gb); /* inter_blocks */
2854  ctx->cplx_estimation_trash_p += 8 * get_bits1(gb); /* inter4v_blocks */
2855  ctx->cplx_estimation_trash_i += 8 * get_bits1(gb); /* not coded blocks */
2856  }
2857  if (!check_marker(s->avctx, gb, "in complexity estimation part 1")) {
2858  skip_bits_long(gb, pos - get_bits_count(gb));
2859  goto no_cplx_est;
2860  }
2861  if (!get_bits1(gb)) {
2862  ctx->cplx_estimation_trash_i += 8 * get_bits1(gb); /* dct_coeffs */
2863  ctx->cplx_estimation_trash_i += 8 * get_bits1(gb); /* dct_lines */
2864  ctx->cplx_estimation_trash_i += 8 * get_bits1(gb); /* vlc_syms */
2865  ctx->cplx_estimation_trash_i += 4 * get_bits1(gb); /* vlc_bits */
2866  }
2867  if (!get_bits1(gb)) {
2868  ctx->cplx_estimation_trash_p += 8 * get_bits1(gb); /* apm */
2869  ctx->cplx_estimation_trash_p += 8 * get_bits1(gb); /* npm */
2870  ctx->cplx_estimation_trash_b += 8 * get_bits1(gb); /* interpolate_mc_q */
2871  ctx->cplx_estimation_trash_p += 8 * get_bits1(gb); /* forwback_mc_q */
2872  ctx->cplx_estimation_trash_p += 8 * get_bits1(gb); /* halfpel2 */
2873  ctx->cplx_estimation_trash_p += 8 * get_bits1(gb); /* halfpel4 */
2874  }
2875  if (!check_marker(s->avctx, gb, "in complexity estimation part 2")) {
2876  skip_bits_long(gb, pos - get_bits_count(gb));
2877  goto no_cplx_est;
2878  }
2879  if (estimation_method == 1) {
2880  ctx->cplx_estimation_trash_i += 8 * get_bits1(gb); /* sadct */
2881  ctx->cplx_estimation_trash_p += 8 * get_bits1(gb); /* qpel */
2882  }
2883  } else
2884  av_log(s->avctx, AV_LOG_ERROR,
2885  "Invalid Complexity estimation method %d\n",
2886  estimation_method);
2887  } else {
2888 
2889 no_cplx_est:
2890  ctx->cplx_estimation_trash_i =
2891  ctx->cplx_estimation_trash_p =
2892  ctx->cplx_estimation_trash_b = 0;
2893  }
2894 
2895  ctx->resync_marker = !get_bits1(gb); /* resync_marker_disabled */
2896 
2897  s->data_partitioning = get_bits1(gb);
2898  if (s->data_partitioning)
2899  ctx->rvlc = get_bits1(gb);
2900 
2901  if (vo_ver_id != 1) {
2902  ctx->new_pred = get_bits1(gb);
2903  if (ctx->new_pred) {
2904  av_log(s->avctx, AV_LOG_ERROR, "new pred not supported\n");
2905  skip_bits(gb, 2); /* requested upstream message type */
2906  skip_bits1(gb); /* newpred segment type */
2907  }
2908  if (get_bits1(gb)) // reduced_res_vop
2909  av_log(s->avctx, AV_LOG_ERROR,
2910  "reduced resolution VOP not supported\n");
2911  } else {
2912  ctx->new_pred = 0;
2913  }
2914 
2915  ctx->scalability = get_bits1(gb);
2916 
2917  if (ctx->scalability) {
2918  GetBitContext bak = *gb;
2919  int h_sampling_factor_n;
2920  int h_sampling_factor_m;
2921  int v_sampling_factor_n;
2922  int v_sampling_factor_m;
2923 
2924  skip_bits1(gb); // hierarchy_type
2925  skip_bits(gb, 4); /* ref_layer_id */
2926  skip_bits1(gb); /* ref_layer_sampling_dir */
2927  h_sampling_factor_n = get_bits(gb, 5);
2928  h_sampling_factor_m = get_bits(gb, 5);
2929  v_sampling_factor_n = get_bits(gb, 5);
2930  v_sampling_factor_m = get_bits(gb, 5);
2931  ctx->enhancement_type = get_bits1(gb);
2932 
2933  if (h_sampling_factor_n == 0 || h_sampling_factor_m == 0 ||
2934  v_sampling_factor_n == 0 || v_sampling_factor_m == 0) {
2935  /* illegal scalability header (VERY broken encoder),
2936  * trying to workaround */
2937  ctx->scalability = 0;
2938  *gb = bak;
2939  } else
2940  av_log(s->avctx, AV_LOG_ERROR, "scalability not supported\n");
2941 
2942  // bin shape stuff FIXME
2943  }
2944  }
2945 
2946  if (s->avctx->debug&FF_DEBUG_PICT_INFO) {
2947  av_log(s->avctx, AV_LOG_DEBUG, "tb %d/%d, tincrbits:%d, qp_prec:%d, ps:%d, low_delay:%d %s%s%s%s\n",
2948  s->avctx->framerate.den, s->avctx->framerate.num,
2949  ctx->time_increment_bits,
2950  ctx->quant_precision,
2951  s->progressive_sequence,
2952  s->low_delay,
2953  ctx->scalability ? "scalability " :"" , s->quarter_sample ? "qpel " : "",
2954  s->data_partitioning ? "partition " : "", ctx->rvlc ? "rvlc " : ""
2955  );
2956  }
2957 
2958  return 0;
2959 }
2960 
2961 /**
2962  * Decode the user data stuff in the header.
2963  * Also initializes divx/xvid/lavc_version/build.
2964  */
2965 static int decode_user_data(Mpeg4DecContext *ctx, GetBitContext *gb)
2966 {
2967  MpegEncContext *s = &ctx->m;
2968  char buf[256];
2969  int i;
2970  int e;
2971  int ver = 0, build = 0, ver2 = 0, ver3 = 0;
2972  char last;
2973 
2974  for (i = 0; i < 255 && get_bits_count(gb) < gb->size_in_bits; i++) {
2975  if (show_bits(gb, 23) == 0)
2976  break;
2977  buf[i] = get_bits(gb, 8);
2978  }
2979  buf[i] = 0;
2980 
2981  /* divx detection */
2982  e = sscanf(buf, "DivX%dBuild%d%c", &ver, &build, &last);
2983  if (e < 2)
2984  e = sscanf(buf, "DivX%db%d%c", &ver, &build, &last);
2985  if (e >= 2) {
2986  ctx->divx_version = ver;
2987  ctx->divx_build = build;
2988  s->divx_packed = e == 3 && last == 'p';
2989  }
2990 
2991  /* libavcodec detection */
2992  e = sscanf(buf, "FFmpe%*[^b]b%d", &build) + 3;
2993  if (e != 4)
2994  e = sscanf(buf, "FFmpeg v%d.%d.%d / libavcodec build: %d", &ver, &ver2, &ver3, &build);
2995  if (e != 4) {
2996  e = sscanf(buf, "Lavc%d.%d.%d", &ver, &ver2, &ver3) + 1;
2997  if (e > 1) {
2998  if (ver > 0xFFU || ver2 > 0xFFU || ver3 > 0xFFU) {
2999  av_log(s->avctx, AV_LOG_WARNING,
3000  "Unknown Lavc version string encountered, %d.%d.%d; "
3001  "clamping sub-version values to 8-bits.\n",
3002  ver, ver2, ver3);
3003  }
3004  build = ((ver & 0xFF) << 16) + ((ver2 & 0xFF) << 8) + (ver3 & 0xFF);
3005  }
3006  }
3007  if (e != 4) {
3008  if (strcmp(buf, "ffmpeg") == 0)
3009  ctx->lavc_build = 4600;
3010  }
3011  if (e == 4)
3012  ctx->lavc_build = build;
3013 
3014  /* Xvid detection */
3015  e = sscanf(buf, "XviD%d", &build);
3016  if (e == 1)
3017  ctx->xvid_build = build;
3018 
3019  return 0;
3020 }
3021 
3022 int ff_mpeg4_workaround_bugs(AVCodecContext *avctx)
3023 {
3024  Mpeg4DecContext *ctx = avctx->priv_data;
3025  MpegEncContext *s = &ctx->m;
3026 
3027  if (ctx->xvid_build == -1 && ctx->divx_version == -1 && ctx->lavc_build == -1) {
3028  if (s->codec_tag == AV_RL32("XVID") ||
3029  s->codec_tag == AV_RL32("XVIX") ||
3030  s->codec_tag == AV_RL32("RMP4") ||
3031  s->codec_tag == AV_RL32("ZMP4") ||
3032  s->codec_tag == AV_RL32("SIPP"))
3033  ctx->xvid_build = 0;
3034  }
3035 
3036  if (ctx->xvid_build == -1 && ctx->divx_version == -1 && ctx->lavc_build == -1)
3037  if (s->codec_tag == AV_RL32("DIVX") && ctx->vo_type == 0 &&
3038  ctx->vol_control_parameters == 0)
3039  ctx->divx_version = 400; // divx 4
3040 
3041  if (ctx->xvid_build >= 0 && ctx->divx_version >= 0) {
3042  ctx->divx_version =
3043  ctx->divx_build = -1;
3044  }
3045 
3046  if (s->workaround_bugs & FF_BUG_AUTODETECT) {
3047  if (s->codec_tag == AV_RL32("XVIX"))
3048  s->workaround_bugs |= FF_BUG_XVID_ILACE;
3049 
3050  if (s->codec_tag == AV_RL32("UMP4"))
3051  s->workaround_bugs |= FF_BUG_UMP4;
3052 
3053  if (ctx->divx_version >= 500 && ctx->divx_build < 1814)
3054  s->workaround_bugs |= FF_BUG_QPEL_CHROMA;
3055 
3056  if (ctx->divx_version > 502 && ctx->divx_build < 1814)
3057  s->workaround_bugs |= FF_BUG_QPEL_CHROMA2;
3058 
3059  if (ctx->xvid_build <= 3U)
3060  s->padding_bug_score = 256 * 256 * 256 * 64;
3061 
3062  if (ctx->xvid_build <= 1U)
3063  s->workaround_bugs |= FF_BUG_QPEL_CHROMA;
3064 
3065  if (ctx->xvid_build <= 12U)
3066  s->workaround_bugs |= FF_BUG_EDGE;
3067 
3068  if (ctx->xvid_build <= 32U)
3069  s->workaround_bugs |= FF_BUG_DC_CLIP;
3070 
3071 #define SET_QPEL_FUNC(postfix1, postfix2) \
3072  s->qdsp.put_ ## postfix1 = ff_put_ ## postfix2; \
3073  s->qdsp.put_no_rnd_ ## postfix1 = ff_put_no_rnd_ ## postfix2; \
3074  s->qdsp.avg_ ## postfix1 = ff_avg_ ## postfix2;
3075 
3076  if (ctx->lavc_build < 4653U)
3077  s->workaround_bugs |= FF_BUG_STD_QPEL;
3078 
3079  if (ctx->lavc_build < 4655U)
3080  s->workaround_bugs |= FF_BUG_DIRECT_BLOCKSIZE;
3081 
3082  if (ctx->lavc_build < 4670U)
3083  s->workaround_bugs |= FF_BUG_EDGE;
3084 
3085  if (ctx->lavc_build <= 4712U)
3086  s->workaround_bugs |= FF_BUG_DC_CLIP;
3087 
3088  if ((ctx->lavc_build&0xFF) >= 100) {
3089  if (ctx->lavc_build > 3621476 && ctx->lavc_build < 3752552 &&
3090  (ctx->lavc_build < 3752037 || ctx->lavc_build > 3752191) // 3.2.1+
3091  )
3092  s->workaround_bugs |= FF_BUG_IEDGE;
3093  }
3094 
3095  if (ctx->divx_version >= 0)
3096  s->workaround_bugs |= FF_BUG_DIRECT_BLOCKSIZE;
3097  if (ctx->divx_version == 501 && ctx->divx_build == 20020416)
3098  s->padding_bug_score = 256 * 256 * 256 * 64;
3099 
3100  if (ctx->divx_version < 500U)
3101  s->workaround_bugs |= FF_BUG_EDGE;
3102 
3103  if (ctx->divx_version >= 0)
3104  s->workaround_bugs |= FF_BUG_HPEL_CHROMA;
3105  }
3106 
3107  if (s->workaround_bugs & FF_BUG_STD_QPEL) {
3108  SET_QPEL_FUNC(qpel_pixels_tab[0][5], qpel16_mc11_old_c)
3109  SET_QPEL_FUNC(qpel_pixels_tab[0][7], qpel16_mc31_old_c)
3110  SET_QPEL_FUNC(qpel_pixels_tab[0][9], qpel16_mc12_old_c)
3111  SET_QPEL_FUNC(qpel_pixels_tab[0][11], qpel16_mc32_old_c)
3112  SET_QPEL_FUNC(qpel_pixels_tab[0][13], qpel16_mc13_old_c)
3113  SET_QPEL_FUNC(qpel_pixels_tab[0][15], qpel16_mc33_old_c)
3114 
3115  SET_QPEL_FUNC(qpel_pixels_tab[1][5], qpel8_mc11_old_c)
3116  SET_QPEL_FUNC(qpel_pixels_tab[1][7], qpel8_mc31_old_c)
3117  SET_QPEL_FUNC(qpel_pixels_tab[1][9], qpel8_mc12_old_c)
3118  SET_QPEL_FUNC(qpel_pixels_tab[1][11], qpel8_mc32_old_c)
3119  SET_QPEL_FUNC(qpel_pixels_tab[1][13], qpel8_mc13_old_c)
3120  SET_QPEL_FUNC(qpel_pixels_tab[1][15], qpel8_mc33_old_c)
3121  }
3122 
3123  if (avctx->debug & FF_DEBUG_BUGS)
3124  av_log(s->avctx, AV_LOG_DEBUG,
3125  "bugs: %X lavc_build:%d xvid_build:%d divx_version:%d divx_build:%d %s\n",
3126  s->workaround_bugs, ctx->lavc_build, ctx->xvid_build,
3127  ctx->divx_version, ctx->divx_build, s->divx_packed ? "p" : "");
3128 
3129  if (CONFIG_MPEG4_DECODER && ctx->xvid_build >= 0 &&
3130  avctx->idct_algo == FF_IDCT_AUTO) {
3131  avctx->idct_algo = FF_IDCT_XVID;
3132  ff_mpv_idct_init(s);
3133  return 1;
3134  }
3135 
3136  return 0;
3137 }
3138 
3139 static int decode_vop_header(Mpeg4DecContext *ctx, GetBitContext *gb,
3140  int parse_only)
3141 {
3142  MpegEncContext *s = &ctx->m;
3143  int time_incr, time_increment;
3144  int64_t pts;
3145 
3146  s->mcsel = 0;
3147  s->pict_type = get_bits(gb, 2) + AV_PICTURE_TYPE_I; /* pict type: I = 0 , P = 1 */
3148  if (s->pict_type == AV_PICTURE_TYPE_B && s->low_delay &&
3149  ctx->vol_control_parameters == 0 && !(s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY)) {
3150  av_log(s->avctx, AV_LOG_ERROR, "low_delay flag set incorrectly, clearing it\n");
3151  s->low_delay = 0;
3152  }
3153 
3154  s->partitioned_frame = s->data_partitioning && s->pict_type != AV_PICTURE_TYPE_B;
3155  if (s->partitioned_frame)
3156  s->decode_mb = mpeg4_decode_partitioned_mb;
3157  else
3158  s->decode_mb = mpeg4_decode_mb;
3159 
3160  time_incr = 0;
3161  while (get_bits1(gb) != 0)
3162  time_incr++;
3163 
3164  check_marker(s->avctx, gb, "before time_increment");
3165 
3166  if (ctx->time_increment_bits == 0 ||
3167  !(show_bits(gb, ctx->time_increment_bits + 1) & 1)) {
3168  av_log(s->avctx, AV_LOG_WARNING,
3169  "time_increment_bits %d is invalid in relation to the current bitstream, this is likely caused by a missing VOL header\n", ctx->time_increment_bits);
3170 
3171  for (ctx->time_increment_bits = 1;
3172  ctx->time_increment_bits < 16;
3173  ctx->time_increment_bits++) {
3174  if (s->pict_type == AV_PICTURE_TYPE_P ||
3175  (s->pict_type == AV_PICTURE_TYPE_S &&
3176  ctx->vol_sprite_usage == GMC_SPRITE)) {
3177  if ((show_bits(gb, ctx->time_increment_bits + 6) & 0x37) == 0x30)
3178  break;
3179  } else if ((show_bits(gb, ctx->time_increment_bits + 5) & 0x1F) == 0x18)
3180  break;
3181  }
3182 
3183  av_log(s->avctx, AV_LOG_WARNING,
3184  "time_increment_bits set to %d bits, based on bitstream analysis\n", ctx->time_increment_bits);
3185  }
3186 
3187  if (IS_3IV1)
3188  time_increment = get_bits1(gb); // FIXME investigate further
3189  else
3190  time_increment = get_bits(gb, ctx->time_increment_bits);
3191 
3192  if (s->pict_type != AV_PICTURE_TYPE_B) {
3193  s->last_time_base = s->time_base;
3194  s->time_base += time_incr;
3195  s->time = s->time_base * (int64_t)s->avctx->framerate.num + time_increment;
3196  if (s->workaround_bugs & FF_BUG_UMP4) {
3197  if (s->time < s->last_non_b_time) {
3198  /* header is not mpeg-4-compatible, broken encoder,
3199  * trying to workaround */
3200  s->time_base++;
3201  s->time += s->avctx->framerate.num;
3202  }
3203  }
3204  s->pp_time = s->time - s->last_non_b_time;
3205  s->last_non_b_time = s->time;
3206  } else {
3207  s->time = (s->last_time_base + time_incr) * (int64_t)s->avctx->framerate.num + time_increment;
3208  s->pb_time = s->pp_time - (s->last_non_b_time - s->time);
3209  if (s->pp_time <= s->pb_time ||
3210  s->pp_time <= s->pp_time - s->pb_time ||
3211  s->pp_time <= 0) {
3212  /* messed up order, maybe after seeking? skipping current B-frame */
3213  return FRAME_SKIPPED;
3214  }
3215  ff_mpeg4_init_direct_mv(s);
3216 
3217  if (ctx->t_frame == 0)
3218  ctx->t_frame = s->pb_time;
3219  if (ctx->t_frame == 0)
3220  ctx->t_frame = 1; // 1/0 protection
3221  s->pp_field_time = (ROUNDED_DIV(s->last_non_b_time, ctx->t_frame) -
3222  ROUNDED_DIV(s->last_non_b_time - s->pp_time, ctx->t_frame)) * 2;
3223  s->pb_field_time = (ROUNDED_DIV(s->time, ctx->t_frame) -
3224  ROUNDED_DIV(s->last_non_b_time - s->pp_time, ctx->t_frame)) * 2;
3225  if (s->pp_field_time <= s->pb_field_time || s->pb_field_time <= 1) {
3226  s->pb_field_time = 2;
3227  s->pp_field_time = 4;
3228  if (!s->progressive_sequence)
3229  return FRAME_SKIPPED;
3230  }
3231  }
3232 
3233  if (s->avctx->framerate.den)
3234  pts = ROUNDED_DIV(s->time, s->avctx->framerate.den);
3235  else
3236  pts = AV_NOPTS_VALUE;
3237  ff_dlog(s->avctx, "MPEG4 PTS: %"PRId64"\n", pts);
3238 
3239  check_marker(s->avctx, gb, "before vop_coded");
3240 
3241  /* vop coded */
3242  if (get_bits1(gb) != 1) {
3243  if (s->avctx->debug & FF_DEBUG_PICT_INFO)
3244  av_log(s->avctx, AV_LOG_ERROR, "vop not coded\n");
3245  return FRAME_SKIPPED;
3246  }
3247  if (ctx->new_pred)
3248  decode_new_pred(ctx, gb);
3249 
3250  if (ctx->shape != BIN_ONLY_SHAPE &&
3251  (s->pict_type == AV_PICTURE_TYPE_P ||
3252  (s->pict_type == AV_PICTURE_TYPE_S &&
3253  ctx->vol_sprite_usage == GMC_SPRITE))) {
3254  /* rounding type for motion estimation */
3255  s->no_rounding = get_bits1(gb);
3256  } else {
3257  s->no_rounding = 0;
3258  }
3259  // FIXME reduced res stuff
3260 
3261  if (ctx->shape != RECT_SHAPE) {
3262  if (ctx->vol_sprite_usage != 1 || s->pict_type != AV_PICTURE_TYPE_I) {
3263  skip_bits(gb, 13); /* width */
3264  check_marker(s->avctx, gb, "after width");
3265  skip_bits(gb, 13); /* height */
3266  check_marker(s->avctx, gb, "after height");
3267  skip_bits(gb, 13); /* hor_spat_ref */
3268  check_marker(s->avctx, gb, "after hor_spat_ref");
3269  skip_bits(gb, 13); /* ver_spat_ref */
3270  }
3271  skip_bits1(gb); /* change_CR_disable */
3272 
3273  if (get_bits1(gb) != 0)
3274  skip_bits(gb, 8); /* constant_alpha_value */
3275  }
3276 
3277  // FIXME complexity estimation stuff
3278 
3279  if (ctx->shape != BIN_ONLY_SHAPE) {
3280  skip_bits_long(gb, ctx->cplx_estimation_trash_i);
3281  if (s->pict_type != AV_PICTURE_TYPE_I)
3282  skip_bits_long(gb, ctx->cplx_estimation_trash_p);
3283  if (s->pict_type == AV_PICTURE_TYPE_B)
3284  skip_bits_long(gb, ctx->cplx_estimation_trash_b);
3285 
3286  if (get_bits_left(gb) < 3) {
3287  av_log(s->avctx, AV_LOG_ERROR, "Header truncated\n");
3288  return AVERROR_INVALIDDATA;
3289  }
3290  ctx->intra_dc_threshold = ff_mpeg4_dc_threshold[get_bits(gb, 3)];
3291  if (!s->progressive_sequence) {
3292  s->top_field_first = get_bits1(gb);
3293  s->alternate_scan = get_bits1(gb);
3294  } else
3295  s->alternate_scan = 0;
3296  }
3297  /* Skip at this point when only parsing since the remaining
3298  * data is not useful for a parser and requires the
3299  * sprite_trajectory VLC to be initialized. */
3300  if (parse_only)
3301  goto end;
3302 
3303  if (s->alternate_scan) {
3304  ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_alternate_vertical_scan);
3305  ff_permute_scantable(s->permutated_intra_h_scantable, ff_alternate_vertical_scan,
3306  s->idsp.idct_permutation);
3307  } else {
3308  ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_zigzag_direct);
3309  ff_permute_scantable(s->permutated_intra_h_scantable, ff_alternate_horizontal_scan,
3310  s->idsp.idct_permutation);
3311  }
3312  ff_permute_scantable(s->permutated_intra_v_scantable, ff_alternate_vertical_scan,
3313  s->idsp.idct_permutation);
3314 
3315  if (s->pict_type == AV_PICTURE_TYPE_S) {
3316  if((ctx->vol_sprite_usage == STATIC_SPRITE ||
3317  ctx->vol_sprite_usage == GMC_SPRITE)) {
3318  if (mpeg4_decode_sprite_trajectory(ctx, gb) < 0)
3319  return AVERROR_INVALIDDATA;
3320  if (ctx->sprite_brightness_change)
3321  av_log(s->avctx, AV_LOG_ERROR,
3322  "sprite_brightness_change not supported\n");
3323  if (ctx->vol_sprite_usage == STATIC_SPRITE)
3324  av_log(s->avctx, AV_LOG_ERROR, "static sprite not supported\n");
3325  } else {
3326  memset(ctx->sprite_offset, 0, sizeof(ctx->sprite_offset));
3327  memset(ctx->sprite_delta, 0, sizeof(ctx->sprite_delta));
3328  }
3329  }
3330 
3331  if (ctx->shape != BIN_ONLY_SHAPE) {
3332  s->chroma_qscale = s->qscale = get_bits(gb, ctx->quant_precision);
3333  if (s->qscale == 0) {
3334  av_log(s->avctx, AV_LOG_ERROR,
3335  "Error, header damaged or not MPEG-4 header (qscale=0)\n");
3336  return AVERROR_INVALIDDATA; // makes no sense to continue, as there is nothing left from the image then
3337  }
3338 
3339  if (s->pict_type != AV_PICTURE_TYPE_I) {
3340  s->f_code = get_bits(gb, 3); /* fcode_for */
3341  if (s->f_code == 0) {
3342  av_log(s->avctx, AV_LOG_ERROR,
3343  "Error, header damaged or not MPEG-4 header (f_code=0)\n");
3344  s->f_code = 1;
3345  return AVERROR_INVALIDDATA; // makes no sense to continue, as there is nothing left from the image then
3346  }
3347  } else
3348  s->f_code = 1;
3349 
3350  if (s->pict_type == AV_PICTURE_TYPE_B) {
3351  s->b_code = get_bits(gb, 3);
3352  if (s->b_code == 0) {
3353  av_log(s->avctx, AV_LOG_ERROR,
3354  "Error, header damaged or not MPEG4 header (b_code=0)\n");
3355  s->b_code=1;
3356  return AVERROR_INVALIDDATA; // makes no sense to continue, as the MV decoding will break very quickly
3357  }
3358  } else
3359  s->b_code = 1;
3360 
3361  if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
3362  av_log(s->avctx, AV_LOG_DEBUG,
3363  "qp:%d fc:%d,%d %c size:%d pro:%d alt:%d top:%d %cpel part:%d resync:%d w:%d a:%d rnd:%d vot:%d%s dc:%d ce:%d/%d/%d time:%"PRId64" tincr:%d\n",
3364  s->qscale, s->f_code, s->b_code,
3365  s->pict_type == AV_PICTURE_TYPE_I ? 'I' : (s->pict_type == AV_PICTURE_TYPE_P ? 'P' : (s->pict_type == AV_PICTURE_TYPE_B ? 'B' : 'S')),
3366  gb->size_in_bits,s->progressive_sequence, s->alternate_scan,
3367  s->top_field_first, s->quarter_sample ? 'q' : 'h',
3368  s->data_partitioning, ctx->resync_marker,
3369  ctx->num_sprite_warping_points, ctx->sprite_warping_accuracy,
3370  1 - s->no_rounding, ctx->vo_type,
3371  ctx->vol_control_parameters ? " VOLC" : " ", ctx->intra_dc_threshold,
3372  ctx->cplx_estimation_trash_i, ctx->cplx_estimation_trash_p,
3373  ctx->cplx_estimation_trash_b,
3374  s->time,
3375  time_increment
3376  );
3377  }
3378 
3379  if (!ctx->scalability) {
3380  if (ctx->shape != RECT_SHAPE && s->pict_type != AV_PICTURE_TYPE_I)
3381  skip_bits1(gb); // vop shape coding type
3382  } else {
3383  if (ctx->enhancement_type) {
3384  int load_backward_shape = get_bits1(gb);
3385  if (load_backward_shape)
3386  av_log(s->avctx, AV_LOG_ERROR,
3387  "load backward shape isn't supported\n");
3388  }
3389  skip_bits(gb, 2); // ref_select_code
3390  }
3391  }
3392 
3393 end:
3394  /* detect buggy encoders which don't set the low_delay flag
3395  * (divx4/xvid/opendivx). Note we cannot detect divx5 without B-frames
3396  * easily (although it's buggy too) */
3397  if (ctx->vo_type == 0 && ctx->vol_control_parameters == 0 &&
3398  ctx->divx_version == -1 && s->picture_number == 0) {
3399  av_log(s->avctx, AV_LOG_WARNING,
3400  "looks like this file was encoded with (divx4/(old)xvid/opendivx) -> forcing low_delay flag\n");
3401  s->low_delay = 1;
3402  }
3403 
3404  s->picture_number++; // better than pic number==0 always ;)
3405 
3406  // FIXME add short header support
3407  s->y_dc_scale_table = ff_mpeg4_y_dc_scale_table;
3408  s->c_dc_scale_table = ff_mpeg4_c_dc_scale_table;
3409 
3410  if (s->workaround_bugs & FF_BUG_EDGE) {
3411  s->h_edge_pos = s->width;
3412  s->v_edge_pos = s->height;
3413  }
3414  return 0;
3415 }
3416 
3417 static void decode_smpte_tc(Mpeg4DecContext *ctx, GetBitContext *gb)
3418 {
3419  MpegEncContext *s = &ctx->m;
3420 
3421  skip_bits(gb, 16); /* Time_code[63..48] */
3422  check_marker(s->avctx, gb, "after Time_code[63..48]");
3423  skip_bits(gb, 16); /* Time_code[47..32] */
3424  check_marker(s->avctx, gb, "after Time_code[47..32]");
3425  skip_bits(gb, 16); /* Time_code[31..16] */
3426  check_marker(s->avctx, gb, "after Time_code[31..16]");
3427  skip_bits(gb, 16); /* Time_code[15..0] */
3428  check_marker(s->avctx, gb, "after Time_code[15..0]");
3429  skip_bits(gb, 4); /* reserved_bits */
3430 }
3431 
3432 /**
3433  * Decode the next studio vop header.
3434  * @return <0 if something went wrong
3435  */
3436 static int decode_studio_vop_header(Mpeg4DecContext *ctx, GetBitContext *gb)
3437 {
3438  MpegEncContext *s = &ctx->m;
3439 
3440  if (get_bits_left(gb) <= 32)
3441  return 0;
3442 
3443  s->partitioned_frame = 0;
3444  s->interlaced_dct = 0;
3445  s->decode_mb = mpeg4_decode_studio_mb;
3446 
3447  decode_smpte_tc(ctx, gb);
3448 
3449  skip_bits(gb, 10); /* temporal_reference */
3450  skip_bits(gb, 2); /* vop_structure */
3451  s->pict_type = get_bits(gb, 2) + AV_PICTURE_TYPE_I; /* vop_coding_type */
3452  if (get_bits1(gb)) { /* vop_coded */
3453  skip_bits1(gb); /* top_field_first */
3454  skip_bits1(gb); /* repeat_first_field */
3455  s->progressive_frame = get_bits1(gb) ^ 1; /* progressive_frame */
3456  }
3457 
3458  if (s->pict_type == AV_PICTURE_TYPE_I) {
3459  if (get_bits1(gb))
3460  reset_studio_dc_predictors(s);
3461  }
3462 
3463  if (ctx->shape != BIN_ONLY_SHAPE) {
3464  s->alternate_scan = get_bits1(gb);
3465  s->frame_pred_frame_dct = get_bits1(gb);
3466  s->dct_precision = get_bits(gb, 2);
3467  s->intra_dc_precision = get_bits(gb, 2);
3468  s->q_scale_type = get_bits1(gb);
3469  }
3470 
3471  ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable,
3472  s->alternate_scan ? ff_alternate_vertical_scan : ff_zigzag_direct);
3473 
3474  mpeg4_load_default_matrices(s);
3475 
3476  next_start_code_studio(gb);
3477  extension_and_user_data(s, gb, 4);
3478 
3479  return 0;
3480 }
3481 
3482 static int decode_studiovisualobject(Mpeg4DecContext *ctx, GetBitContext *gb)
3483 {
3484  MpegEncContext *s = &ctx->m;
3485  int visual_object_type;
3486 
3487  skip_bits(gb, 4); /* visual_object_verid */
3488  visual_object_type = get_bits(gb, 4);
3489  if (visual_object_type != VOT_VIDEO_ID) {
3490  avpriv_request_sample(s->avctx, "VO type %u", visual_object_type);
3491  return AVERROR_PATCHWELCOME;
3492  }
3493 
3494  next_start_code_studio(gb);
3495  extension_and_user_data(s, gb, 1);
3496 
3497  return 0;
3498 }
3499 
3500 /**
3501  * Decode MPEG-4 headers.
3502  *
3503  * @param header If set the absence of a VOP is not treated as error; otherwise, it is treated as such.
3504  * @param parse_only If set, things only relevant to a decoder may be skipped;
3505  * furthermore, the VLC tables may be uninitialized.
3506  * @return <0 if an error occurred
3507  * FRAME_SKIPPED if a not coded VOP is found
3508  * 0 else
3509  */
3510 int ff_mpeg4_parse_picture_header(Mpeg4DecContext *ctx, GetBitContext *gb,
3511  int header, int parse_only)
3512 {
3513  MpegEncContext *s = &ctx->m;
3514  unsigned startcode, v;
3515  int ret;
3516  int vol = 0;
3517 
3518  /* search next start code */
3519  align_get_bits(gb);
3520 
3521  // If we have not switched to studio profile than we also did not switch bps
3522  // that means something else (like a previous instance) outside set bps which
3523  // would be inconsistant with the currect state, thus reset it
3524  if (!s->studio_profile && s->avctx->bits_per_raw_sample != 8)
3525  s->avctx->bits_per_raw_sample = 0;
3526 
3527  if (s->codec_tag == AV_RL32("WV1F") && show_bits(gb, 24) == 0x575630) {
3528  skip_bits(gb, 24);
3529  if (get_bits(gb, 8) == 0xF0)
3530  goto end;
3531  }
3532 
3533  startcode = 0xff;
3534  for (;;) {
3535  if (get_bits_count(gb) >= gb->size_in_bits) {
3536  if (gb->size_in_bits == 8 &&
3537  (ctx->divx_version >= 0 || ctx->xvid_build >= 0) || s->codec_tag == AV_RL32("QMP4")) {
3538  av_log(s->avctx, AV_LOG_VERBOSE, "frame skip %d\n", gb->size_in_bits);
3539  return FRAME_SKIPPED; // divx bug
3540  } else if (header && get_bits_count(gb) == gb->size_in_bits) {
3541  return 0; // ordinary return value for parsing of extradata
3542  } else
3543  return AVERROR_INVALIDDATA; // end of stream
3544  }
3545 
3546  /* use the bits after the test */
3547  v = get_bits(gb, 8);
3548  startcode = ((startcode << 8) | v) & 0xffffffff;
3549 
3550  if ((startcode & 0xFFFFFF00) != 0x100)
3551  continue; // no startcode
3552 
3553  if (s->avctx->debug & FF_DEBUG_STARTCODE) {
3554  const char *name;
3555  if (startcode <= 0x11F)
3556  name = "Video Object Start";
3557  else if (startcode <= 0x12F)
3558  name = "Video Object Layer Start";
3559  else if (startcode <= 0x13F)
3560  name = "Reserved";
3561  else if (startcode <= 0x15F)
3562  name = "FGS bp start";
3563  else if (startcode <= 0x1AF)
3564  name = "Reserved";
3565  else if (startcode == 0x1B0)
3566  name = "Visual Object Seq Start";
3567  else if (startcode == 0x1B1)
3568  name = "Visual Object Seq End";
3569  else if (startcode == 0x1B2)
3570  name = "User Data";
3571  else if (startcode == 0x1B3)
3572  name = "Group of VOP start";
3573  else if (startcode == 0x1B4)
3574  name = "Video Session Error";
3575  else if (startcode == 0x1B5)
3576  name = "Visual Object Start";
3577  else if (startcode == 0x1B6)
3578  name = "Video Object Plane start";
3579  else if (startcode == 0x1B7)
3580  name = "slice start";
3581  else if (startcode == 0x1B8)
3582  name = "extension start";
3583  else if (startcode == 0x1B9)
3584  name = "fgs start";
3585  else if (startcode == 0x1BA)
3586  name = "FBA Object start";
3587  else if (startcode == 0x1BB)
3588  name = "FBA Object Plane start";
3589  else if (startcode == 0x1BC)
3590  name = "Mesh Object start";
3591  else if (startcode == 0x1BD)
3592  name = "Mesh Object Plane start";
3593  else if (startcode == 0x1BE)
3594  name = "Still Texture Object start";
3595  else if (startcode == 0x1BF)
3596  name = "Texture Spatial Layer start";
3597  else if (startcode == 0x1C0)
3598  name = "Texture SNR Layer start";
3599  else if (startcode == 0x1C1)
3600  name = "Texture Tile start";
3601  else if (startcode == 0x1C2)
3602  name = "Texture Shape Layer start";
3603  else if (startcode == 0x1C3)
3604  name = "stuffing start";
3605  else if (startcode <= 0x1C5)
3606  name = "Reserved";
3607  else if (startcode <= 0x1FF)
3608  name = "System start";
3609  av_log(s->avctx, AV_LOG_DEBUG, "startcode: %3X %s at %d\n",
3610  startcode, name, get_bits_count(gb));
3611  }
3612 
3613  if (startcode >= 0x120 && startcode <= 0x12F) {
3614  if (vol) {
3615  av_log(s->avctx, AV_LOG_WARNING, "Ignoring multiple VOL headers\n");
3616  continue;
3617  }
3618  vol++;
3619  if ((ret = decode_vol_header(ctx, gb)) < 0)
3620  return ret;
3621  } else if (startcode == USER_DATA_STARTCODE) {
3622  decode_user_data(ctx, gb);
3623  } else if (startcode == GOP_STARTCODE) {
3624  mpeg4_decode_gop_header(s, gb);
3625  } else if (startcode == VOS_STARTCODE) {
3626  int profile, level;
3627  mpeg4_decode_profile_level(s, gb, &profile, &level);
3628  if (profile == AV_PROFILE_MPEG4_SIMPLE_STUDIO &&
3629  (level > 0 && level < 9)) {
3630  s->studio_profile = 1;
3631  next_start_code_studio(gb);
3632  extension_and_user_data(s, gb, 0);
3633  } else if (s->studio_profile) {
3634  avpriv_request_sample(s->avctx, "Mix of studio and non studio profile");
3635  return AVERROR_PATCHWELCOME;
3636  }
3637  s->avctx->profile = profile;
3638  s->avctx->level = level;
3639  } else if (startcode == VISUAL_OBJ_STARTCODE) {
3640  if (s->studio_profile) {
3641  if ((ret = decode_studiovisualobject(ctx, gb)) < 0)
3642  return ret;
3643  } else
3644  mpeg4_decode_visual_object(s, gb);
3645  } else if (startcode == VOP_STARTCODE) {
3646  break;
3647  }
3648 
3649  align_get_bits(gb);
3650  startcode = 0xff;
3651  }
3652 
3653 end:
3654  if (s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY)
3655  s->low_delay = 1;
3656  s->avctx->has_b_frames = !s->low_delay;
3657 
3658  if (s->studio_profile) {
3659  if (!s->avctx->bits_per_raw_sample) {
3660  av_log(s->avctx, AV_LOG_ERROR, "Missing VOL header\n");
3661  return AVERROR_INVALIDDATA;
3662  }
3663  return decode_studio_vop_header(ctx, gb);
3664  } else
3665  return decode_vop_header(ctx, gb, parse_only);
3666 }
3667 
3668 int ff_mpeg4_decode_picture_header(MpegEncContext *s)
3669 {
3670  Mpeg4DecContext *const ctx = (Mpeg4DecContext*)s;
3671 
3672  if (ctx->bitstream_buffer) {
3673  int buf_size = get_bits_left(&s->gb) / 8U;
3674  int bitstream_buffer_size = ctx->bitstream_buffer->size;
3675  const uint8_t *buf = s->gb.buffer;
3676 
3677  if (s->divx_packed) {
3678  for (int i = 0; i < buf_size - 3; i++) {
3679  if (buf[i] == 0 && buf[i+1] == 0 && buf[i+2] == 1) {
3680  if (buf[i+3] == 0xB0) {
3681  av_log(s->avctx, AV_LOG_WARNING, "Discarding excessive bitstream in packed xvid\n");
3682  bitstream_buffer_size = 0;
3683  }
3684  break;
3685  }
3686  }
3687  }
3688  ctx->bitstream_buffer->size = 0;
3689  if (bitstream_buffer_size && (s->divx_packed || buf_size <= MAX_NVOP_SIZE)) {// divx 5.01+/xvid frame reorder
3690  int ret = init_get_bits8(&s->gb, ctx->bitstream_buffer->data,
3691  bitstream_buffer_size);
3692  if (ret < 0)
3693  return ret;
3694  } else
3695  av_buffer_unref(&ctx->bitstream_buffer);
3696  }
3697 
3698  return ff_mpeg4_parse_picture_header(ctx, &s->gb, 0, 0);
3699 }
3700 
3701 int ff_mpeg4_frame_end(AVCodecContext *avctx, const AVPacket *pkt)
3702 {
3703  Mpeg4DecContext *ctx = avctx->priv_data;
3704  MpegEncContext *s = &ctx->m;
3705  int ret;
3706 
3707  av_assert1(!ctx->bitstream_buffer || !ctx->bitstream_buffer->size);
3708 
3709  /* divx 5.01+ bitstream reorder stuff */
3710  if (s->divx_packed) {
3711  int current_pos = ctx->bitstream_buffer && s->gb.buffer == ctx->bitstream_buffer->data ? 0 : (get_bits_count(&s->gb) >> 3);
3712  int startcode_found = 0;
3713  uint8_t *buf = pkt->data;
3714  int buf_size = pkt->size;
3715 
3716  if (buf_size - current_pos > 7) {
3717 
3718  int i;
3719  for (i = current_pos; i < buf_size - 4; i++)
3720 
3721  if (buf[i] == 0 &&
3722  buf[i + 1] == 0 &&
3723  buf[i + 2] == 1 &&
3724  buf[i + 3] == 0xB6) {
3725  startcode_found = !(buf[i + 4] & 0x40);
3726  break;
3727  }
3728  }
3729 
3730  if (startcode_found) {
3731  if (!ctx->showed_packed_warning) {
3732  av_log(s->avctx, AV_LOG_INFO, "Video uses a non-standard and "
3733  "wasteful way to store B-frames ('packed B-frames'). "
3734  "Consider using the mpeg4_unpack_bframes bitstream filter without encoding but stream copy to fix it.\n");
3735  ctx->showed_packed_warning = 1;
3736  }
3737  ret = av_buffer_replace(&ctx->bitstream_buffer, pkt->buf);
3738  if (ret < 0)
3739  return ret;
3740 
3741  ctx->bitstream_buffer->data = buf + current_pos;
3742  ctx->bitstream_buffer->size = buf_size - current_pos;
3743  }
3744  }
3745 
3746  return 0;
3747 }
3748 
3749 #if CONFIG_MPEG4_DECODER
3750 #if HAVE_THREADS
3751 static int mpeg4_update_thread_context(AVCodecContext *dst,
3752  const AVCodecContext *src)
3753 {
3754  Mpeg4DecContext *s = dst->priv_data;
3755  const Mpeg4DecContext *s1 = src->priv_data;
3756  int init = s->m.context_initialized;
3757 
3758  int ret = ff_mpeg_update_thread_context(dst, src);
3759 
3760  if (ret < 0)
3761  return ret;
3762 
3763  // copy all the necessary fields explicitly
3764  s->time_increment_bits = s1->time_increment_bits;
3765  s->shape = s1->shape;
3766  s->vol_sprite_usage = s1->vol_sprite_usage;
3767  s->sprite_brightness_change = s1->sprite_brightness_change;
3768  s->sprite_warping_accuracy = s1->sprite_warping_accuracy;
3769  s->num_sprite_warping_points = s1->num_sprite_warping_points;
3770  s->m.data_partitioning = s1->m.data_partitioning;
3771  s->rvlc = s1->rvlc;
3772  s->resync_marker = s1->resync_marker;
3773  s->t_frame = s1->t_frame;
3774  s->new_pred = s1->new_pred;
3775  s->enhancement_type = s1->enhancement_type;
3776  s->scalability = s1->scalability;
3777  s->intra_dc_threshold = s1->intra_dc_threshold;
3778  s->m.divx_packed = s1->m.divx_packed;
3779  s->divx_version = s1->divx_version;
3780  s->divx_build = s1->divx_build;
3781  s->xvid_build = s1->xvid_build;
3782  s->lavc_build = s1->lavc_build;
3783  s->vo_type = s1->vo_type;
3784  s->showed_packed_warning = s1->showed_packed_warning;
3785  s->vol_control_parameters = s1->vol_control_parameters;
3786  s->cplx_estimation_trash_i = s1->cplx_estimation_trash_i;
3787  s->cplx_estimation_trash_p = s1->cplx_estimation_trash_p;
3788  s->cplx_estimation_trash_b = s1->cplx_estimation_trash_b;
3789  s->rgb = s1->rgb;
3790 
3791  memcpy(s->sprite_shift, s1->sprite_shift, sizeof(s1->sprite_shift));
3792  memcpy(s->sprite_traj, s1->sprite_traj, sizeof(s1->sprite_traj));
3793 
3794  ret = av_buffer_replace(&s->bitstream_buffer, s1->bitstream_buffer);
3795 
3796  if (!init && s1->xvid_build >= 0)
3797  ff_xvid_idct_init(&s->m.idsp, dst);
3798 
3799  return 0;
3800 }
3801 
3802 static int mpeg4_update_thread_context_for_user(AVCodecContext *dst,
3803  const AVCodecContext *src)
3804 {
3805  MpegEncContext *m = dst->priv_data;
3806  const MpegEncContext *m1 = src->priv_data;
3807 
3808  m->quarter_sample = m1->quarter_sample;
3809  m->divx_packed = m1->divx_packed;
3810 
3811  return 0;
3812 }
3813 #endif
3814 
3815 static av_cold void mpeg4_init_static(void)
3816 {
3817  static uint8_t mpeg4_rvlc_rl_tables[2][2][2 * MAX_RUN + MAX_LEVEL + 3];
3818  static VLCElem vlc_buf[6498];
3819  VLCInitState state = VLC_INIT_STATE(vlc_buf);
3820 
3821  VLC_INIT_STATIC_TABLE_FROM_LENGTHS(studio_luma_dc, STUDIO_INTRA_BITS, 19,
3822  &ff_mpeg4_studio_dc_luma[0][1], 2,
3823  &ff_mpeg4_studio_dc_luma[0][0], 2, 1,
3824  0, 0);
3825 
3826  VLC_INIT_STATIC_TABLE_FROM_LENGTHS(studio_chroma_dc, STUDIO_INTRA_BITS, 19,
3827  &ff_mpeg4_studio_dc_chroma[0][1], 2,
3828  &ff_mpeg4_studio_dc_chroma[0][0], 2, 1,
3829  0, 0);
3830 
3831  for (unsigned i = 0; i < 12; i++) {
3832  studio_intra_tab[i] =
3833  ff_vlc_init_tables_from_lengths(&state, STUDIO_INTRA_BITS, 24,
3834  &ff_mpeg4_studio_intra[i][0][1], 2,
3835  &ff_mpeg4_studio_intra[i][0][0], 2, 1,
3836  0, 0);
3837  }
3838 
3839  ff_mpeg4_init_rl_intra();
3840  ff_rl_init(&ff_rvlc_rl_inter, mpeg4_rvlc_rl_tables[0]);
3841  ff_rl_init(&ff_rvlc_rl_intra, mpeg4_rvlc_rl_tables[1]);
3842  INIT_FIRST_VLC_RL(ff_mpeg4_rl_intra, 554);
3843  VLC_INIT_RL(ff_rvlc_rl_inter, 1072);
3844  INIT_FIRST_VLC_RL(ff_rvlc_rl_intra, 1072);
3845  VLC_INIT_STATIC_TABLE(dc_lum, DC_VLC_BITS, 10 /* 13 */,
3846  &ff_mpeg4_DCtab_lum[0][1], 2, 1,
3847  &ff_mpeg4_DCtab_lum[0][0], 2, 1, 0);
3848  VLC_INIT_STATIC_TABLE(dc_chrom, DC_VLC_BITS, 10 /* 13 */,
3849  &ff_mpeg4_DCtab_chrom[0][1], 2, 1,
3850  &ff_mpeg4_DCtab_chrom[0][0], 2, 1, 0);
3851  VLC_INIT_STATIC_TABLE_FROM_LENGTHS(sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15,
3852  ff_sprite_trajectory_lens, 1,
3853  NULL, 0, 0, 0, 0);
3854  VLC_INIT_STATIC_SPARSE_TABLE(mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
3855  &ff_mb_type_b_tab[0][1], 2, 1,
3856  &ff_mb_type_b_tab[0][0], 2, 1,
3857  mb_type_b_map, 2, 2, 0);
3858 }
3859 
3860 static av_cold int decode_init(AVCodecContext *avctx)
3861 {
3862  static AVOnce init_static_once = AV_ONCE_INIT;
3863  Mpeg4DecContext *ctx = avctx->priv_data;
3864  MpegEncContext *s = &ctx->m;
3865  int ret;
3866 
3867  ctx->divx_version =
3868  ctx->divx_build =
3869  ctx->xvid_build =
3870  ctx->lavc_build = -1;
3871 
3872  if ((ret = ff_h263_decode_init(avctx)) < 0)
3873  return ret;
3874 
3875  s->h263_pred = 1;
3876  s->low_delay = 0; /* default, might be overridden in the vol header during header parsing */
3877  s->decode_mb = mpeg4_decode_mb;
3878  ctx->time_increment_bits = 4; /* default value for broken headers */
3879  ctx->quant_precision = 5;
3880 
3881  avctx->chroma_sample_location = AVCHROMA_LOC_LEFT;
3882 
3883  ff_qpeldsp_init(&s->qdsp);
3884  ff_mpeg4videodsp_init(&ctx->mdsp);
3885 
3886  ff_thread_once(&init_static_once, mpeg4_init_static);
3887 
3888  /* Must be after initializing the MPEG-4 static tables */
3889  if (avctx->extradata_size && !avctx->internal->is_copy) {
3890  GetBitContext gb;
3891 
3892  if (init_get_bits8(&gb, avctx->extradata, avctx->extradata_size) >= 0)
3893  ff_mpeg4_parse_picture_header(ctx, &gb, 1, 0);
3894  }
3895 
3896  return 0;
3897 }
3898 
3899 static av_cold void mpeg4_flush(AVCodecContext *avctx)
3900 {
3901  Mpeg4DecContext *const ctx = avctx->priv_data;
3902 
3903  av_buffer_unref(&ctx->bitstream_buffer);
3904  ff_mpeg_flush(avctx);
3905 }
3906 
3907 static av_cold int mpeg4_close(AVCodecContext *avctx)
3908 {
3909  Mpeg4DecContext *const ctx = avctx->priv_data;
3910 
3911  av_buffer_unref(&ctx->bitstream_buffer);
3912 
3913  return ff_mpv_decode_close(avctx);
3914 }
3915 
3916 #define OFFSET(x) offsetof(MpegEncContext, x)
3917 #define FLAGS AV_OPT_FLAG_EXPORT | AV_OPT_FLAG_READONLY
3918 static const AVOption mpeg4_options[] = {
3919  {"quarter_sample", "1/4 subpel MC", OFFSET(quarter_sample), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, FLAGS},
3920  {"divx_packed", "divx style packed b frames", OFFSET(divx_packed), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, FLAGS},
3921  {NULL}
3922 };
3923 
3924 static const AVClass mpeg4_class = {
3925  .class_name = "MPEG4 Video Decoder",
3926  .item_name = av_default_item_name,
3927  .option = mpeg4_options,
3928  .version = LIBAVUTIL_VERSION_INT,
3929 };
3930 
3931 const FFCodec ff_mpeg4_decoder = {
3932  .p.name = "mpeg4",
3933  CODEC_LONG_NAME("MPEG-4 part 2"),
3934  .p.type = AVMEDIA_TYPE_VIDEO,
3935  .p.id = AV_CODEC_ID_MPEG4,
3936  .priv_data_size = sizeof(Mpeg4DecContext),
3937  .init = decode_init,
3938  FF_CODEC_DECODE_CB(ff_h263_decode_frame),
3939  .close = mpeg4_close,
3940  .p.capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 |
3941  AV_CODEC_CAP_DELAY | AV_CODEC_CAP_FRAME_THREADS,
3942  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP |
3943  FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
3944  .flush = mpeg4_flush,
3945  .p.max_lowres = 3,
3946  .p.profiles = NULL_IF_CONFIG_SMALL(ff_mpeg4_video_profiles),
3947  UPDATE_THREAD_CONTEXT(mpeg4_update_thread_context),
3948  UPDATE_THREAD_CONTEXT_FOR_USER(mpeg4_update_thread_context_for_user),
3949  .p.priv_class = &mpeg4_class,
3950  .hw_configs = (const AVCodecHWConfigInternal *const []) {
3951 #if CONFIG_MPEG4_NVDEC_HWACCEL
3952  HWACCEL_NVDEC(mpeg4),
3953 #endif
3954 #if CONFIG_MPEG4_VAAPI_HWACCEL
3955  HWACCEL_VAAPI(mpeg4),
3956 #endif
3957 #if CONFIG_MPEG4_VDPAU_HWACCEL
3958  HWACCEL_VDPAU(mpeg4),
3959 #endif
3960 #if CONFIG_MPEG4_VIDEOTOOLBOX_HWACCEL
3961  HWACCEL_VIDEOTOOLBOX(mpeg4),
3962 #endif
3963  NULL
3964  },
3965 };
3966 #endif /* CONFIG_MPEG4_DECODER */
SIMPLE_VO_TYPE
#define SIMPLE_VO_TYPE
Definition: mpeg4videodefs.h:32
hwconfig.h
VOT_VIDEO_ID
#define VOT_VIDEO_ID
Definition: mpeg4videodefs.h:42
IS_8X8
#define IS_8X8(a)
Definition: mpegutils.h:83
FF_BUG_DC_CLIP
#define FF_BUG_DC_CLIP
Definition: avcodec.h:1379
ff_mpeg4_video_profiles
const AVProfile ff_mpeg4_video_profiles[]
Definition: profiles.c:127
MV_TYPE_16X16
#define MV_TYPE_16X16
1 vector for the whole mb
Definition: mpegvideo.h:264
skip_bits_long
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
Definition: get_bits.h:261
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:215
h263data.h
ff_h263_cbpy_vlc
VLCElem ff_h263_cbpy_vlc[]
Definition: ituh263dec.c:104
FF_ASPECT_EXTENDED
#define FF_ASPECT_EXTENDED
Definition: h263.h:26
name
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option name
Definition: writing_filters.txt:88
Mpeg4DecContext::sprite_warping_accuracy
int sprite_warping_accuracy
Definition: mpeg4videodec.h:42
level
uint8_t level
Definition: svq3.c:205
MpegEncContext::data_partitioning
int data_partitioning
data partitioning flag from header
Definition: mpegvideo.h:387
av_clip
#define av_clip
Definition: common.h:100
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
show_bits_long
static unsigned int show_bits_long(GetBitContext *s, int n)
Show 0-32 bits.
Definition: get_bits.h:478
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:678
IS_ACPRED
#define IS_ACPRED(a)
Definition: mpegutils.h:84
r
const char * r
Definition: vf_curves.c:127
Mpeg4DecContext::vol_sprite_usage
int vol_sprite_usage
Definition: mpeg4videodec.h:40
opt.h
threadprogress.h
ff_xvid_idct_init
av_cold void ff_xvid_idct_init(IDCTDSPContext *c, AVCodecContext *avctx)
Definition: xvididct.c:333
IS_3IV1
#define IS_3IV1
Definition: mpeg4videodec.c:55
Mpeg4DecContext::showed_packed_warning
int showed_packed_warning
flag for having shown the warning about invalid Divx B-frames
Definition: mpeg4videodec.h:79
mpeg4_block_count
static const uint8_t mpeg4_block_count[4]
Definition: mpeg4videodec.c:74
AV_EF_COMPLIANT
#define AV_EF_COMPLIANT
consider all spec non compliances as errors
Definition: defs.h:55
ff_sprite_trajectory_lens
const uint8_t ff_sprite_trajectory_lens[15]
Definition: mpeg4data.h:325
decode_vop_header
static int decode_vop_header(Mpeg4DecContext *ctx, GetBitContext *gb, int parse_only)
Definition: mpeg4videodec.c:3139
thread.h
mpeg4videodec.h
get_bits_long
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:404
int64_t
long long int64_t
Definition: coverity.c:34
MB_TYPE_16x8
#define MB_TYPE_16x8
Definition: mpegutils.h:42
output
filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce output
Definition: filter_design.txt:225
MAX_RUN
#define MAX_RUN
Definition: rl.h:35
ff_qpeldsp_init
av_cold void ff_qpeldsp_init(QpelDSPContext *c)
Definition: qpeldsp.c:784
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:249
ac_state_tab
static const uint8_t ac_state_tab[22][2]
Definition: mpeg4videodec.c:2084
GetBitContext::size_in_bits
int size_in_bits
Definition: get_bits.h:111
MV_DIRECT
#define MV_DIRECT
bidirectional mode where the difference equals the MV of the last P/S/I-Frame (MPEG-4)
Definition: mpegvideo.h:262
AV_CODEC_ID_MPEG4
@ AV_CODEC_ID_MPEG4
Definition: codec_id.h:64
step
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about which is also called distortion Distortion can be quantified by almost any quality measurement one chooses the sum of squared differences is used but more complex methods that consider psychovisual effects can be used as well It makes no difference in this discussion First step
Definition: rate_distortion.txt:58
w
uint8_t w
Definition: llviddspenc.c:38
FF_BUG_EDGE
#define FF_BUG_EDGE
Definition: avcodec.h:1377
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:746
STATIC_SPRITE
#define STATIC_SPRITE
Definition: mpeg4videodefs.h:49
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:539
mpeg4_decode_studio_mb
static int mpeg4_decode_studio_mb(MpegEncContext *s, int16_t block_[12][64])
Definition: mpeg4videodec.c:2308
VOS_STARTCODE
#define VOS_STARTCODE
Definition: mpeg4videodefs.h:55
ff_mpeg4_decode_studio_slice_header
int ff_mpeg4_decode_studio_slice_header(Mpeg4DecContext *ctx)
Decode the next video packet.
Definition: mpeg4videodec.c:800
AVOption
AVOption.
Definition: opt.h:429
mpeg4_decode_gop_header
static int mpeg4_decode_gop_header(MpegEncContext *s, GetBitContext *gb)
Definition: mpeg4videodec.c:2356
Mpeg4DecContext::rvlc
int rvlc
Definition: mpeg4videodec.h:53
CORE_STUDIO_VO_TYPE
#define CORE_STUDIO_VO_TYPE
Definition: mpeg4videodefs.h:39
MB_TYPE_16x16
#define MB_TYPE_16x16
Definition: mpegutils.h:41
decode_studiovisualobject
static int decode_studiovisualobject(Mpeg4DecContext *ctx, GetBitContext *gb)
Definition: mpeg4videodec.c:3482
FFCodec
Definition: codec_internal.h:127
FLAGS
#define FLAGS
Definition: cmdutils.c:595
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:225
ff_clean_intra_table_entries
void ff_clean_intra_table_entries(MpegEncContext *s)
Clean dc, ac for the current non-intra MB.
Definition: mpegvideo.c:791
Mpeg4DecContext::new_pred
int new_pred
Definition: mpeg4videodec.h:59
ff_er_add_slice
void ff_er_add_slice(ERContext *s, int startx, int starty, int endx, int endy, int status)
Add a slice.
Definition: error_resilience.c:826
ff_init_block_index
void ff_init_block_index(MpegEncContext *s)
Definition: mpegvideo.c:815
max
#define max(a, b)
Definition: cuda_runtime.h:33
mpegvideo.h
UPDATE_CACHE
#define UPDATE_CACHE(name, gb)
Definition: get_bits.h:208
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
ff_mpeg4_decoder
const FFCodec ff_mpeg4_decoder
FF_BUG_HPEL_CHROMA
#define FF_BUG_HPEL_CHROMA
Definition: avcodec.h:1378
ER_DC_END
#define ER_DC_END
Definition: error_resilience.h:34
decode_smpte_tc
static void decode_smpte_tc(Mpeg4DecContext *ctx, GetBitContext *gb)
Definition: mpeg4videodec.c:3417
mpegutils.h
SLICE_STARTCODE
#define SLICE_STARTCODE
Definition: mpeg4videodefs.h:60
FF_IDCT_AUTO
#define FF_IDCT_AUTO
Definition: avcodec.h:1567
mpeg4_decode_visual_object
static int mpeg4_decode_visual_object(MpegEncContext *s, GetBitContext *gb)
Definition: mpeg4videodec.c:2392
ff_mpeg4_init_rl_intra
av_cold void ff_mpeg4_init_rl_intra(void)
Definition: mpeg4video.c:36
ER_MV_ERROR
#define ER_MV_ERROR
Definition: error_resilience.h:32
FF_DEBUG_PICT_INFO
#define FF_DEBUG_PICT_INFO
Definition: avcodec.h:1415
MV_DIR_BACKWARD
#define MV_DIR_BACKWARD
Definition: mpegvideo.h:261
mpeg4_get_level_dc
static int mpeg4_get_level_dc(MpegEncContext *s, int n, int pred, int level)
Definition: mpeg4videodec.c:889
FF_IDCT_XVID
#define FF_IDCT_XVID
Definition: avcodec.h:1574
hsub
static void hsub(htype *dst, const htype *src, int bins)
Definition: vf_median.c:74
GET_CACHE
#define GET_CACHE(name, gb)
Definition: get_bits.h:246
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:364
studio_luma_dc
static VLCElem studio_luma_dc[528]
Definition: mpeg4videodec.c:71
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
AVCodecInternal::is_copy
int is_copy
When using frame-threaded decoding, this field is set for the first worker thread (e....
Definition: internal.h:54
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:318
rgb
Definition: rpzaenc.c:60
ff_mpeg4_DCtab_chrom
const uint8_t ff_mpeg4_DCtab_chrom[13][2]
Definition: mpeg4data.h:40
mx
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t mx
Definition: dsp.h:53
decode_user_data
static int decode_user_data(Mpeg4DecContext *ctx, GetBitContext *gb)
Decode the user data stuff in the header.
Definition: mpeg4videodec.c:2965
SKIP_CACHE
#define SKIP_CACHE(name, gb, num)
Definition: get_bits.h:211
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
get_amv
static int get_amv(Mpeg4DecContext *ctx, int n)
Get the average motion vector for a GMC MB.
Definition: mpeg4videodec.c:842
ff_h263_pred_motion
int16_t * ff_h263_pred_motion(MpegEncContext *s, int block, int dir, int *px, int *py)
Definition: h263.c:179
MB_TYPE_B_VLC_BITS
#define MB_TYPE_B_VLC_BITS
Definition: mpeg4videodec.c:64
STUDIO_INTRA_BITS
#define STUDIO_INTRA_BITS
Definition: mpeg4videodec.c:65
FF_BUG_QPEL_CHROMA2
#define FF_BUG_QPEL_CHROMA2
Definition: avcodec.h:1375
AV_PIX_FMT_GBRP10
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:541
ff_mpeg4_pred_ac
void ff_mpeg4_pred_ac(MpegEncContext *s, int16_t *block, int n, int dir)
Predict the ac.
Definition: mpeg4videodec.c:321
ff_rvlc_rl_intra
RLTable ff_rvlc_rl_intra
Definition: mpeg4data.h:317
ff_h263_pixel_aspect
const AVRational ff_h263_pixel_aspect[16]
Definition: h263data.c:273
VOP_STARTCODE
#define VOP_STARTCODE
Definition: mpeg4videodefs.h:59
RLTable
RLTable.
Definition: rl.h:39
ff_mpeg4_get_video_packet_prefix_length
int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s)
Definition: mpeg4video.c:42
GetBitContext
Definition: get_bits.h:108
AV_EF_BITSTREAM
#define AV_EF_BITSTREAM
detect bitstream specification deviations
Definition: defs.h:49
studio_intra_tab
static const VLCElem * studio_intra_tab[12]
Definition: mpeg4videodec.c:70
ff_rvlc_rl_inter
RLTable ff_rvlc_rl_inter
Definition: mpeg4data.h:213
mpeg4_decode_profile_level
static int mpeg4_decode_profile_level(MpegEncContext *s, GetBitContext *gb, int *profile, int *level)
Definition: mpeg4videodec.c:2378
HWACCEL_VDPAU
#define HWACCEL_VDPAU(codec)
Definition: hwconfig.h:72
AV_CODEC_FLAG_LOW_DELAY
#define AV_CODEC_FLAG_LOW_DELAY
Force low delay.
Definition: avcodec.h:334
pts
static int64_t pts
Definition: transcode_aac.c:644
VOT_STILL_TEXTURE_ID
#define VOT_STILL_TEXTURE_ID
Definition: mpeg4videodefs.h:43
SLICE_END
#define SLICE_END
end marker found
Definition: mpegvideo.h:478
DC_VLC_BITS
#define DC_VLC_BITS
Definition: mpeg4videodec.c:63
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:528
ff_h263_decode_motion
int ff_h263_decode_motion(MpegEncContext *s, int pred, int f_code)
Definition: ituh263dec.c:274
HAS_FORWARD_MV
#define HAS_FORWARD_MV(a)
Definition: mpegutils.h:88
ff_thread_once
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:205
mpegvideodec.h
Mpeg4DecContext::sprite_brightness_change
int sprite_brightness_change
Definition: mpeg4videodec.h:41
pkt
AVPacket * pkt
Definition: movenc.c:60
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:209
INIT_FIRST_VLC_RL
#define INIT_FIRST_VLC_RL(rl, static_size)
Definition: rl.h:93
ER_DC_ERROR
#define ER_DC_ERROR
Definition: error_resilience.h:31
h263dec.h
av_cold
#define av_cold
Definition: attributes.h:90
ff_mpeg4_decode_partitions
int ff_mpeg4_decode_partitions(Mpeg4DecContext *ctx)
Decode the first and second partition.
Definition: mpeg4videodec.c:1267
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:528
AV_PROFILE_UNKNOWN
#define AV_PROFILE_UNKNOWN
Definition: defs.h:65
extension_and_user_data
static void extension_and_user_data(MpegEncContext *s, GetBitContext *gb, int id)
Definition: mpeg4videodec.c:2490
MB_TYPE_ACPRED
#define MB_TYPE_ACPRED
Definition: mpegutils.h:62
VLCInitState
For static VLCs, the number of bits can often be hardcoded at each get_vlc2() callsite.
Definition: vlc.h:212
ff_mpeg4_set_direct_mv
int ff_mpeg4_set_direct_mv(MpegEncContext *s, int mx, int my)
Definition: mpeg4video.c:129
sprite_trajectory
static VLCElem sprite_trajectory[128]
Definition: mpeg4videodec.c:68
CLOSE_READER
#define CLOSE_READER(name, gb)
Definition: get_bits.h:184
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:538
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:341
RLTable::max_level
int8_t * max_level[2]
encoding & decoding
Definition: rl.h:46
s
#define s(width, name)
Definition: cbs_vp9.c:198
CHROMA_422
#define CHROMA_422
Definition: mpegvideo.h:456
Mpeg4DecContext::cplx_estimation_trash_b
int cplx_estimation_trash_b
Definition: mpeg4videodec.h:85
SHOW_SBITS
#define SHOW_SBITS(name, gb, num)
Definition: get_bits.h:243
FF_BUG_NO_PADDING
#define FF_BUG_NO_PADDING
Definition: avcodec.h:1371
ff_mpeg4_rl_intra
RLTable ff_mpeg4_rl_intra
Definition: mpeg4data.h:108
bits
uint8_t bits
Definition: vp3data.h:128
AV_EF_IGNORE_ERR
#define AV_EF_IGNORE_ERR
ignore errors and continue
Definition: defs.h:53
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:230
ctx
AVFormatContext * ctx
Definition: movenc.c:49
ff_mpeg4_workaround_bugs
int ff_mpeg4_workaround_bugs(AVCodecContext *avctx)
Definition: mpeg4videodec.c:3022
IS_SKIP
#define IS_SKIP(a)
Definition: mpegutils.h:75
mpeg4_decode_mb
static int mpeg4_decode_mb(MpegEncContext *s, int16_t block[6][64])
Definition: mpeg4videodec.c:1694
DC_MARKER
#define DC_MARKER
Definition: mpeg4videodefs.h:53
SKIP_BITS
#define SKIP_BITS(name, gb, num)
Definition: get_bits.h:224
MpegEncContext::divx_packed
int divx_packed
Definition: mpegvideo.h:396
xvididct.h
RSHIFT
#define RSHIFT(a, b)
Definition: common.h:56
Mpeg4DecContext::bitstream_buffer
AVBufferRef * bitstream_buffer
Divx 5.01 puts several frames in a single one, this is used to reorder them.
Definition: mpeg4videodec.h:74
FF_BUG_DIRECT_BLOCKSIZE
#define FF_BUG_DIRECT_BLOCKSIZE
Definition: avcodec.h:1376
ff_rl_init
av_cold void ff_rl_init(RLTable *rl, uint8_t static_store[2][2 *MAX_RUN+MAX_LEVEL+3])
Initialize index_run, max_level and max_run from n, last, table_vlc, table_run and table_level.
Definition: rl.c:44
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:326
my
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t my
Definition: dsp.h:53
mpeg4_decode_sprite_trajectory
static int mpeg4_decode_sprite_trajectory(Mpeg4DecContext *ctx, GetBitContext *gb)
Definition: mpeg4videodec.c:430
rl_vlc
static const VLCElem * rl_vlc[2]
Definition: mobiclip.c:278
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:74
if
if(ret)
Definition: filter_design.txt:179
ff_mpeg4_DCtab_lum
const uint8_t ff_mpeg4_DCtab_lum[13][2]
Definition: mpeg4data.h:34
AV_CODEC_CAP_FRAME_THREADS
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:110
AVPacket::buf
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
Definition: packet.h:522
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AV_ONCE_INIT
#define AV_ONCE_INIT
Definition: thread.h:203
ff_thread_progress_await
void ff_thread_progress_await(const ThreadProgress *pro_c, int n)
This function is a no-op in no-op mode; otherwise it waits until other threads have reached a certain...
Definition: threadprogress.c:64
mpeg4_load_default_matrices
static void mpeg4_load_default_matrices(MpegEncContext *s)
Definition: mpeg4videodec.c:2424
FF_BUG_UMP4
#define FF_BUG_UMP4
Definition: avcodec.h:1370
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:75
mb_type_b_map
static const int16_t mb_type_b_map[4]
Definition: mpeg4videodec.c:76
NULL
#define NULL
Definition: coverity.c:32
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
Mpeg4DecContext::rgb
int rgb
Definition: mpeg4videodec.h:87
Mpeg4DecContext::shape
int shape
Definition: mpeg4videodec.h:39
run
uint8_t run
Definition: svq3.c:204
GMC_SPRITE
#define GMC_SPRITE
Definition: mpeg4videodefs.h:50
av_buffer_unref
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it.
Definition: buffer.c:139
FF_BUG_STD_QPEL
#define FF_BUG_STD_QPEL
Definition: avcodec.h:1374
ff_mpv_idct_init
av_cold void ff_mpv_idct_init(MpegEncContext *s)
Definition: mpegvideo.c:307
ff_mpeg4_pred_dc
static int ff_mpeg4_pred_dc(MpegEncContext *s, int n, int *dir_ptr)
Predict the dc.
Definition: mpeg4video.h:44
AVCHROMA_LOC_LEFT
@ AVCHROMA_LOC_LEFT
MPEG-2/4 4:2:0, H.264 default for 4:2:0.
Definition: pixfmt.h:767
mpeg4_decode_partitioned_mb
static int mpeg4_decode_partitioned_mb(MpegEncContext *s, int16_t block[6][64])
decode partition C of one MB.
Definition: mpeg4videodec.c:1604
MB_TYPE_GMC
#define MB_TYPE_GMC
Definition: mpegutils.h:60
mpeg4_decode_studio_block
static int mpeg4_decode_studio_block(MpegEncContext *s, int32_t block[64], int n)
Definition: mpeg4videodec.c:2110
AVCodecContext::internal
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:486
SLICE_NOEND
#define SLICE_NOEND
no end marker or error found but mb count exceeded
Definition: mpegvideo.h:479
MB_TYPE_8x8
#define MB_TYPE_8x8
Definition: mpegutils.h:44
ROUNDED_DIV
#define ROUNDED_DIV(a, b)
Definition: common.h:58
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:239
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:279
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:371
profiles.h
ff_set_qscale
void ff_set_qscale(MpegEncContext *s, int qscale)
set qscale and update qscale dependent variables.
Definition: mpegvideo.c:848
ff_h263_decode_frame
int ff_h263_decode_frame(AVCodecContext *avctx, AVFrame *pict, int *got_frame, AVPacket *avpkt)
Definition: h263dec.c:412
LAST_SKIP_BITS
#define LAST_SKIP_BITS(name, gb, num)
Definition: get_bits.h:230
FF_BUG_IEDGE
#define FF_BUG_IEDGE
Definition: avcodec.h:1382
ff_h263_intra_MCBPC_vlc
VLCElem ff_h263_intra_MCBPC_vlc[]
Definition: ituh263dec.c:102
MB_TYPE_BIDIR_MV
#define MB_TYPE_BIDIR_MV
Definition: mpegutils.h:51
MOTION_MARKER
#define MOTION_MARKER
Definition: mpeg4videodefs.h:52
lowres
static int lowres
Definition: ffplay.c:330
qpeldsp.h
SET_QPEL_FUNC
#define SET_QPEL_FUNC(postfix1, postfix2)
Mpeg4DecContext::cplx_estimation_trash_i
int cplx_estimation_trash_i
Definition: mpeg4videodec.h:83
Mpeg4DecContext
Definition: mpeg4videodec.h:34
UPDATE_THREAD_CONTEXT
#define UPDATE_THREAD_CONTEXT(func)
Definition: codec_internal.h:335
ff_alternate_horizontal_scan
const uint8_t ff_alternate_horizontal_scan[64]
Definition: mpegvideodata.c:52
FASTDIV
#define FASTDIV(a, b)
Definition: mathops.h:212
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:526
mpeg4_options
static const AVOption mpeg4_options[]
Definition: v4l2_m2m_enc.c:397
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:635
VISUAL_OBJ_STARTCODE
#define VISUAL_OBJ_STARTCODE
Definition: mpeg4videodefs.h:58
ff_mpeg4_dc_threshold
const uint8_t ff_mpeg4_dc_threshold[8]
Definition: mpeg4data.h:365
HAS_BACKWARD_MV
#define HAS_BACKWARD_MV(a)
Definition: mpegutils.h:89
AVOnce
#define AVOnce
Definition: thread.h:202
get_unary
static int get_unary(GetBitContext *gb, int stop, int len)
Get unary code of limited length.
Definition: unary.h:46
MV_TYPE_8X8
#define MV_TYPE_8X8
4 vectors (H.263, MPEG-4 4MV)
Definition: mpegvideo.h:265
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:28
ADV_SIMPLE_VO_TYPE
#define ADV_SIMPLE_VO_TYPE
Definition: mpeg4videodefs.h:40
Mpeg4DecContext::scalability
int scalability
Definition: mpeg4videodec.h:61
MAX_LEVEL
#define MAX_LEVEL
Definition: rl.h:36
ff_mpeg4_decode_picture_header
int ff_mpeg4_decode_picture_header(MpegEncContext *s)
Definition: mpeg4videodec.c:3668
IS_INTRA
#define IS_INTRA(x, y)
mpeg4_decode_partition_a
static int mpeg4_decode_partition_a(Mpeg4DecContext *ctx)
Decode first partition.
Definition: mpeg4videodec.c:980
Mpeg4DecContext::t_frame
int t_frame
time distance of first I -> B, used for interlaced B-frames
Definition: mpeg4videodec.h:57
check_marker
static int check_marker(void *logctx, GetBitContext *s, const char *msg)
Definition: mpegvideodec.h:81
Mpeg4DecContext::divx_version
int divx_version
Definition: mpeg4videodec.h:69
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:368
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
AV_CODEC_FLAG_GRAY
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:322
AVPacket::size
int size
Definition: packet.h:540
ff_h263_rl_inter
RLTable ff_h263_rl_inter
Definition: h263data.c:159
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
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:94
ff_mpeg4_y_dc_scale_table
const uint8_t ff_mpeg4_y_dc_scale_table[32]
Definition: mpeg4data.h:356
state
static struct @474 state
height
#define height
Definition: dsp.h:85
RL_VLC_ELEM
Definition: vlc.h:56
codec_internal.h
Mpeg4DecContext::lavc_build
int lavc_build
Definition: mpeg4videodec.h:72
shift
static int shift(int a, int b)
Definition: bonk.c:261
dst
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition: dsp.h:83
Mpeg4DecContext::sprite_shift
int sprite_shift[2]
sprite shift [isChroma]
Definition: mpeg4videodec.h:50
FRAME_SKIPPED
#define FRAME_SKIPPED
Return value for header parsers if frame is not coded.
Definition: h263dec.h:29
ff_update_block_index
static void ff_update_block_index(MpegEncContext *s, int bits_per_raw_sample, int lowres, int chroma_x_shift)
Definition: mpegvideo.h:590
mpeg4_decode_block
static int mpeg4_decode_block(Mpeg4DecContext *ctx, int16_t *block, int n, int coded, int intra, int use_intra_dc_vlc, int rvlc)
Decode a block.
Definition: mpeg4videodec.c:1332
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:424
FF_DEBUG_BUGS
#define FF_DEBUG_BUGS
Definition: avcodec.h:1425
ff_mpeg4_default_intra_matrix
const int16_t ff_mpeg4_default_intra_matrix[64]
Definition: mpeg4data.h:334
VLCElem
Definition: vlc.h:32
read_quant_matrix_ext
static int read_quant_matrix_ext(MpegEncContext *s, GetBitContext *gb)
Definition: mpeg4videodec.c:2441
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
CBPY_VLC_BITS
#define CBPY_VLC_BITS
Definition: h263dec.h:38
FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM
#define FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM
The decoder extracts and fills its parameters even if the frame is skipped due to the skip_frame sett...
Definition: codec_internal.h:54
MB_TYPE_SKIP
#define MB_TYPE_SKIP
Definition: mpegutils.h:61
EXT_STARTCODE
#define EXT_STARTCODE
Definition: mpeg4videodefs.h:61
AVCodecHWConfigInternal
Definition: hwconfig.h:25
MpegEncContext::quarter_sample
int quarter_sample
1->qpel, 0->half pel ME/MC
Definition: mpegvideo.h:386
header
static const uint8_t header[24]
Definition: sdr2.c:68
ff_mpeg4_parse_picture_header
int ff_mpeg4_parse_picture_header(Mpeg4DecContext *ctx, GetBitContext *gb, int header, int parse_only)
Decode MPEG-4 headers.
Definition: mpeg4videodec.c:3510
MB_TYPE_INTERLACED
#define MB_TYPE_INTERLACED
Definition: mpegutils.h:45
OPEN_READER
#define OPEN_READER(name, gb)
Definition: get_bits.h:173
ff_mpeg_flush
void ff_mpeg_flush(AVCodecContext *avctx)
Definition: mpegvideo_dec.c:430
ff_mpeg4videodsp_init
av_cold void ff_mpeg4videodsp_init(Mpeg4VideoDSPContext *c)
Definition: mpeg4videodsp.c:110
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
ff_mpeg4_default_non_intra_matrix
const int16_t ff_mpeg4_default_non_intra_matrix[64]
Definition: mpeg4data.h:345
mpegvideodata.h
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
MV_TYPE_FIELD
#define MV_TYPE_FIELD
2 vectors, one per field
Definition: mpegvideo.h:267
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:275
skip_bits1
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:396
HWACCEL_NVDEC
#define HWACCEL_NVDEC(codec)
Definition: hwconfig.h:68
Mpeg4DecContext::sprite_traj
uint16_t sprite_traj[4][2]
sprite trajectory points
Definition: mpeg4videodec.h:48
Mpeg4DecContext::cplx_estimation_trash_p
int cplx_estimation_trash_p
Definition: mpeg4videodec.h:84
IS_DIRECT
#define IS_DIRECT(a)
Definition: mpegutils.h:78
unary.h
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:220
gmc_motion
static void gmc_motion(MpegEncContext *s, const Mpeg4DecContext *ctx, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, uint8_t *const *ref_picture)
Definition: mpeg4videodec.c:180
BIN_ONLY_SHAPE
#define BIN_ONLY_SHAPE
Definition: mpeg4videodefs.h:29
ff_init_scantable
av_cold void ff_init_scantable(const uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable)
Definition: mpegvideo.c:293
Mpeg4DecContext::time_increment_bits
int time_increment_bits
number of bits to represent the fractional part of time
Definition: mpeg4videodec.h:38
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:67
mpeg4_decode_dc
static int mpeg4_decode_dc(MpegEncContext *s, int n, int *dir_ptr)
Decode the dc value.
Definition: mpeg4videodec.c:932
SKIP_COUNTER
#define SKIP_COUNTER(name, gb, num)
Definition: get_bits.h:216
Mpeg4DecContext::num_sprite_warping_points
int num_sprite_warping_points
Definition: mpeg4videodec.h:43
CHROMA_420
#define CHROMA_420
Definition: mpegvideo.h:455
RECT_SHAPE
#define RECT_SHAPE
Definition: mpeg4videodefs.h:27
ff_mpeg4_mcsel_motion
void ff_mpeg4_mcsel_motion(MpegEncContext *s, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, uint8_t *const *ref_picture)
Definition: mpeg4videodec.c:238
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
ff_alternate_vertical_scan
const uint8_t ff_alternate_vertical_scan[64]
Definition: mpegvideodata.c:63
AVCodecContext::extradata
uint8_t * extradata
Out-of-band global headers that may be used by some codecs.
Definition: avcodec.h:537
show_bits
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:354
RLTable::max_run
int8_t * max_run[2]
encoding & decoding
Definition: rl.h:47
internal.h
ff_mpeg4_decode_video_packet_header
int ff_mpeg4_decode_video_packet_header(Mpeg4DecContext *ctx)
Decode the next video packet.
Definition: mpeg4videodec.c:701
INTRA_MCBPC_VLC_BITS
#define INTRA_MCBPC_VLC_BITS
Definition: h263dec.h:36
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:56
FF_BUG_AUTODETECT
#define FF_BUG_AUTODETECT
autodetection
Definition: avcodec.h:1368
delta
float delta
Definition: vorbis_enc_data.h:430
MB_TYPE_BACKWARD_MV
#define MB_TYPE_BACKWARD_MV
Definition: mpegutils.h:50
FF_DEBUG_STARTCODE
#define FF_DEBUG_STARTCODE
Definition: avcodec.h:1422
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
decode_init
static av_cold int decode_init(AVCodecContext *avctx)
Definition: 4xm.c:994
AVCodecContext::idct_algo
int idct_algo
IDCT algorithm, see FF_IDCT_* below.
Definition: avcodec.h:1566
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
ff_h263_decode_init
av_cold int ff_h263_decode_init(AVCodecContext *avctx)
Definition: h263dec.c:90
av_buffer_replace
int av_buffer_replace(AVBufferRef **pdst, const AVBufferRef *src)
Ensure dst refers to the same data as src.
Definition: buffer.c:233
AVCodecContext::chroma_sample_location
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Definition: avcodec.h:716
len
int len
Definition: vorbis_enc_data.h:426
Mpeg4DecContext::vol_control_parameters
int vol_control_parameters
does the stream contain the low_delay flag, used to work around buggy encoders.
Definition: mpeg4videodec.h:82
AV_PROFILE_MPEG4_SIMPLE_STUDIO
#define AV_PROFILE_MPEG4_SIMPLE_STUDIO
Definition: defs.h:145
profile
int profile
Definition: mxfenc.c:2250
FF_BUG_QPEL_CHROMA
#define FF_BUG_QPEL_CHROMA
Definition: avcodec.h:1373
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
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:729
HWACCEL_VIDEOTOOLBOX
#define HWACCEL_VIDEOTOOLBOX(codec)
Definition: hwconfig.h:74
idctdsp.h
SPRITE_TRAJ_VLC_BITS
#define SPRITE_TRAJ_VLC_BITS
Definition: mpeg4videodec.c:62
stride
#define stride
Definition: h264pred_template.c:536
ff_mpeg4_studio_dc_luma
const uint8_t ff_mpeg4_studio_dc_luma[19][2]
Definition: mpeg4data.h:370
GET_RL_VLC
#define GET_RL_VLC(level, run, name, gb, table, bits, max_depth, need_update)
Definition: get_bits.h:589
ff_zigzag_direct
const uint8_t ff_zigzag_direct[64]
Definition: mathtables.c:98
av_uninit
#define av_uninit(x)
Definition: attributes.h:154
mpeg4videodefs.h
ret
ret
Definition: filter_design.txt:187
SLICE_OK
#define SLICE_OK
Definition: mpegvideo.h:476
AV_EF_AGGRESSIVE
#define AV_EF_AGGRESSIVE
consider things that a sane encoder/muxer should not do as an error
Definition: defs.h:56
pred
static const float pred[4]
Definition: siprdata.h:259
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:80
GRAY_SHAPE
#define GRAY_SHAPE
Definition: mpeg4videodefs.h:30
ff_mpeg4_studio_dc_chroma
const uint8_t ff_mpeg4_studio_dc_chroma[19][2]
Definition: mpeg4data.h:377
align_get_bits
static const uint8_t * align_get_bits(GetBitContext *s)
Definition: get_bits.h:544
TEX_VLC_BITS
#define TEX_VLC_BITS
Definition: dvdec.c:147
pos
unsigned int pos
Definition: spdifenc.c:414
ff_mpeg4_init_direct_mv
void ff_mpeg4_init_direct_mv(MpegEncContext *s)
Definition: mpeg4video.c:83
left
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 left
Definition: snow.txt:386
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
U
#define U(x)
Definition: vpx_arith.h:37
ff_mpeg_update_thread_context
int ff_mpeg_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
Definition: mpegvideo_dec.c:77
OFFSET
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option keep it simple and lowercase description are in without and describe what they for example set the foo of the bar offset is the offset of the field in your see the OFFSET() macro
ff_mpeg4_decode_studio
void ff_mpeg4_decode_studio(MpegEncContext *s, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, int block_size, int uvlinesize, int dct_linesize, int dct_offset)
Definition: mpeg4videodec.c:253
mb_type_b_vlc
static VLCElem mb_type_b_vlc[16]
Definition: mpeg4videodec.c:69
AVCodecContext
main external API structure.
Definition: avcodec.h:451
Mpeg4DecContext::m
MpegEncContext m
Definition: mpeg4videodec.h:35
mpeg4_decode_partition_b
static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count)
decode second partition.
Definition: mpeg4videodec.c:1174
SHOW_UBITS
#define SHOW_UBITS(name, gb, num)
Definition: get_bits.h:242
ff_mb_type_b_tab
const uint8_t ff_mb_type_b_tab[4][2]
Definition: mpeg4data.h:329
AV_PICTURE_TYPE_B
@ AV_PICTURE_TYPE_B
Bi-dir predicted.
Definition: avutil.h:281
mpeg4video.h
error_resilience.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
Mpeg4DecContext::resync_marker
int resync_marker
could this stream contain resync markers
Definition: mpeg4videodec.h:55
Mpeg4DecContext::enhancement_type
int enhancement_type
Definition: mpeg4videodec.h:60
AV_CODEC_CAP_DELAY
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition: codec.h:76
decode_studio_vol_header
static int decode_studio_vol_header(Mpeg4DecContext *ctx, GetBitContext *gb)
Definition: mpeg4videodec.c:2507
USER_DATA_STARTCODE
#define USER_DATA_STARTCODE
Definition: mpeg4videodefs.h:56
decode_vol_header
static int decode_vol_header(Mpeg4DecContext *ctx, GetBitContext *gb)
Definition: mpeg4videodec.c:2593
AVCodecContext::debug
int debug
debug
Definition: avcodec.h:1414
ff_vlc_init_tables_from_lengths
const av_cold VLCElem * ff_vlc_init_tables_from_lengths(VLCInitState *state, int nb_bits, int nb_codes, const int8_t *lens, int lens_wrap, const void *symbols, int symbols_wrap, int symbols_size, int offset, int flags)
Definition: vlc.c:366
mpeg4_is_resync
static int mpeg4_is_resync(Mpeg4DecContext *ctx)
check if the next stuff is a resync marker or the end.
Definition: mpeg4videodec.c:376
studio_chroma_dc
static VLCElem studio_chroma_dc[528]
Definition: mpeg4videodec.c:72
mpeg4_decode_dpcm_macroblock
static int mpeg4_decode_dpcm_macroblock(MpegEncContext *s, int16_t macroblock[256], int n)
Definition: mpeg4videodec.c:2225
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:280
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
get_bitsz
static av_always_inline int get_bitsz(GetBitContext *s, int n)
Read 0-25 bits.
Definition: get_bits.h:334
overflow
Undefined Behavior In the C some operations are like signed integer overflow
Definition: undefined.txt:3
FF_BUG_XVID_ILACE
#define FF_BUG_XVID_ILACE
Definition: avcodec.h:1369
ff_h263_inter_MCBPC_vlc
VLCElem ff_h263_inter_MCBPC_vlc[]
Definition: ituh263dec.c:103
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:36
reset_studio_dc_predictors
static void reset_studio_dc_predictors(MpegEncContext *s)
Definition: mpeg4videodec.c:788
MAX_NVOP_SIZE
#define MAX_NVOP_SIZE
Definition: mpeg4videodefs.h:66
ff_mpeg4_c_dc_scale_table
const uint8_t ff_mpeg4_c_dc_scale_table[32]
Definition: mpeg4data.h:360
ER_MV_END
#define ER_MV_END
Definition: error_resilience.h:35
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:280
VLC_INIT_RL
#define VLC_INIT_RL(rl, static_size)
Definition: rl.h:83
ff_mpeg4_frame_end
int ff_mpeg4_frame_end(AVCodecContext *avctx, const AVPacket *pkt)
Definition: mpeg4videodec.c:3701
scale
static void scale(int *out, const int *in, const int w, const int h, const int shift)
Definition: intra.c:291
next_start_code_studio
static void next_start_code_studio(GetBitContext *gb)
Definition: mpeg4videodec.c:2074
ff_tlog
#define ff_tlog(ctx,...)
Definition: internal.h:141
MV_DIR_FORWARD
#define MV_DIR_FORWARD
Definition: mpegvideo.h:260
VLC_INIT_STATE
#define VLC_INIT_STATE(_table)
Definition: vlc.h:217
alpha
static const int16_t alpha[]
Definition: ilbcdata.h:55
AVPacket
This structure stores compressed data.
Definition: packet.h:516
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:478
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Underlying C type is int.
Definition: opt.h:327
decode_studio_vop_header
static int decode_studio_vop_header(Mpeg4DecContext *ctx, GetBitContext *gb)
Decode the next studio vop header.
Definition: mpeg4videodec.c:3436
mpeg4videodata.h
dc_chrom
static VLCElem dc_chrom[512]
Definition: mpeg4videodec.c:67
mpeg_get_qscale
static int mpeg_get_qscale(MpegEncContext *s)
Definition: mpegvideodec.h:72
GOP_STARTCODE
#define GOP_STARTCODE
Definition: mpeg4videodefs.h:57
HWACCEL_VAAPI
#define HWACCEL_VAAPI(codec)
Definition: hwconfig.h:70
dc_lum
static VLCElem dc_lum[512]
Definition: mpeg4videodec.c:67
gmc1_motion
static void gmc1_motion(MpegEncContext *s, const Mpeg4DecContext *ctx, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, uint8_t *const *ref_picture)
Definition: mpeg4videodec.c:83
int32_t
int32_t
Definition: audioconvert.c:56
MB_TYPE_DIRECT2
#define MB_TYPE_DIRECT2
Definition: mpegutils.h:46
rgb
static const SheerTable rgb[2]
Definition: sheervideodata.h:32
AV_CODEC_CAP_DRAW_HORIZ_BAND
#define AV_CODEC_CAP_DRAW_HORIZ_BAND
Decoder can use draw_horiz_band callback.
Definition: codec.h:44
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
UPDATE_THREAD_CONTEXT_FOR_USER
#define UPDATE_THREAD_CONTEXT_FOR_USER(func)
Definition: codec_internal.h:337
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
Mpeg4DecContext::divx_build
int divx_build
Definition: mpeg4videodec.h:70
Mpeg4DecContext::xvid_build
int xvid_build
Definition: mpeg4videodec.h:71
h
h
Definition: vp9dsp_template.c:2070
decode_new_pred
static int decode_new_pred(Mpeg4DecContext *ctx, GetBitContext *gb)
Definition: mpeg4videodec.c:685
width
#define width
Definition: dsp.h:85
QUANT_MATRIX_EXT_ID
#define QUANT_MATRIX_EXT_ID
Definition: mpeg4videodefs.h:63
FF_BUG_AMV
#define FF_BUG_AMV
Definition: avcodec.h:1372
AV_PICTURE_TYPE_S
@ AV_PICTURE_TYPE_S
S(GMC)-VOP MPEG-4.
Definition: avutil.h:282
MpegEncContext
MpegEncContext.
Definition: mpegvideo.h:73
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
MB_TYPE_FORWARD_MV
#define MB_TYPE_FORWARD_MV
Definition: mpegutils.h:49
src
#define src
Definition: vp8dsp.c:248
RLTable::rl_vlc
RL_VLC_ELEM * rl_vlc[32]
decoding only
Definition: rl.h:48
ff_mpv_decode_close
int ff_mpv_decode_close(AVCodecContext *avctx)
Definition: mpegvideo_dec.c:144
Mpeg4DecContext::intra_dc_threshold
int intra_dc_threshold
QP above which the ac VLC should be used for intra dc.
Definition: mpeg4videodec.h:66
MB_TYPE_INTRA
#define MB_TYPE_INTRA
Definition: mpegutils.h:64
INTER_MCBPC_VLC_BITS
#define INTER_MCBPC_VLC_BITS
Definition: h263dec.h:37
SIMPLE_STUDIO_VO_TYPE
#define SIMPLE_STUDIO_VO_TYPE
Definition: mpeg4videodefs.h:38
h263.h
ff_mpeg4_studio_intra
const uint8_t ff_mpeg4_studio_intra[12][24][2]
Definition: mpeg4data.h:384
Mpeg4DecContext::vo_type
int vo_type
Definition: mpeg4videodec.h:76
min
float min
Definition: vorbis_enc_data.h:429
Generated on Fri Mar 14 2025 19:22:11 for FFmpeg by   doxygen 1.8.17