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