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