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