mpeg4videodec.c
Go to the documentation of this file.
1 /*
2  * MPEG4 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 Libav.
7  *
8  * Libav 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  * Libav 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 Libav; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 #include "mpegvideo.h"
24 #include "mpeg4video.h"
25 #include "h263.h"
26 #include "thread.h"
27 
28 // The defines below define the number of bits that are read at once for
29 // reading vlc values. Changing these may improve speed and data cache needs
30 // be aware though that decreasing them may need the number of stages that is
31 // passed to get_vlc* to be increased.
32 #define SPRITE_TRAJ_VLC_BITS 6
33 #define DC_VLC_BITS 9
34 #define MB_TYPE_B_VLC_BITS 4
35 
36 
40 
41 static const int mb_type_b_map[4]= {
46 };
47 
49 {
50  static int done = 0;
51  if (!done) {
52  done = 1;
53 
60  INIT_VLC_STATIC(&dc_lum, DC_VLC_BITS, 10 /* 13 */,
61  &ff_mpeg4_DCtab_lum[0][1], 2, 1,
62  &ff_mpeg4_DCtab_lum[0][0], 2, 1, 512);
63  INIT_VLC_STATIC(&dc_chrom, DC_VLC_BITS, 10 /* 13 */,
64  &ff_mpeg4_DCtab_chrom[0][1], 2, 1,
65  &ff_mpeg4_DCtab_chrom[0][0], 2, 1, 512);
66  INIT_VLC_STATIC(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15,
67  &ff_sprite_trajectory_tab[0][1], 4, 2,
68  &ff_sprite_trajectory_tab[0][0], 4, 2, 128);
69  INIT_VLC_STATIC(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
70  &ff_mb_type_b_tab[0][1], 2, 1,
71  &ff_mb_type_b_tab[0][0], 2, 1, 16);
72  }
73 }
74 
81  int dir)
82 {
83  int i;
84  int16_t *ac_val, *ac_val1;
85  int8_t * const qscale_table = s->current_picture.f.qscale_table;
86 
87  /* find prediction */
88  ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
89  ac_val1 = ac_val;
90  if (s->ac_pred) {
91  if (dir == 0) {
92  const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
93  /* left prediction */
94  ac_val -= 16;
95 
96  if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
97  /* same qscale */
98  for(i=1;i<8;i++) {
99  block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
100  }
101  }else{
102  /* different qscale, we must rescale */
103  for(i=1;i<8;i++) {
104  block[s->dsp.idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
105  }
106  }
107  } else {
108  const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
109  /* top prediction */
110  ac_val -= 16 * s->block_wrap[n];
111 
112  if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
113  /* same qscale */
114  for(i=1;i<8;i++) {
115  block[s->dsp.idct_permutation[i]] += ac_val[i + 8];
116  }
117  }else{
118  /* different qscale, we must rescale */
119  for(i=1;i<8;i++) {
120  block[s->dsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
121  }
122  }
123  }
124  }
125  /* left copy */
126  for(i=1;i<8;i++)
127  ac_val1[i ] = block[s->dsp.idct_permutation[i<<3]];
128 
129  /* top copy */
130  for(i=1;i<8;i++)
131  ac_val1[8 + i] = block[s->dsp.idct_permutation[i ]];
132 
133 }
134 
139 static inline int mpeg4_is_resync(MpegEncContext *s){
140  int bits_count= get_bits_count(&s->gb);
141  int v= show_bits(&s->gb, 16);
142 
144  return 0;
145  }
146 
147  while(v<=0xFF){
148  if(s->pict_type==AV_PICTURE_TYPE_B || (v>>(8-s->pict_type)!=1) || s->partitioned_frame)
149  break;
150  skip_bits(&s->gb, 8+s->pict_type);
151  bits_count+= 8+s->pict_type;
152  v= show_bits(&s->gb, 16);
153  }
154 
155  if(bits_count + 8 >= s->gb.size_in_bits){
156  v>>=8;
157  v|= 0x7F >> (7-(bits_count&7));
158 
159  if(v==0x7F)
160  return 1;
161  }else{
162  if(v == ff_mpeg4_resync_prefix[bits_count&7]){
163  int len;
164  GetBitContext gb= s->gb;
165 
166  skip_bits(&s->gb, 1);
167  align_get_bits(&s->gb);
168 
169  for(len=0; len<32; len++){
170  if(get_bits1(&s->gb)) break;
171  }
172 
173  s->gb= gb;
174 
176  return 1;
177  }
178  }
179  return 0;
180 }
181 
183 {
184  int i;
185  int a= 2<<s->sprite_warping_accuracy;
186  int rho= 3-s->sprite_warping_accuracy;
187  int r=16/a;
188  const int vop_ref[4][2]= {{0,0}, {s->width,0}, {0, s->height}, {s->width, s->height}}; // only true for rectangle shapes
189  int d[4][2]={{0,0}, {0,0}, {0,0}, {0,0}};
190  int sprite_ref[4][2];
191  int virtual_ref[2][2];
192  int w2, h2, w3, h3;
193  int alpha=0, beta=0;
194  int w= s->width;
195  int h= s->height;
196  int min_ab;
197 
198  if (w <= 0 || h <= 0)
199  return AVERROR_INVALIDDATA;
200 
201  for(i=0; i<s->num_sprite_warping_points; i++){
202  int length;
203  int x=0, y=0;
204 
205  length= get_vlc2(gb, sprite_trajectory.table, SPRITE_TRAJ_VLC_BITS, 3);
206  if(length){
207  x= get_xbits(gb, length);
208  }
209  if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(gb); /* marker bit */
210 
211  length= get_vlc2(gb, sprite_trajectory.table, SPRITE_TRAJ_VLC_BITS, 3);
212  if(length){
213  y=get_xbits(gb, length);
214  }
215  skip_bits1(gb); /* marker bit */
216  s->sprite_traj[i][0]= d[i][0]= x;
217  s->sprite_traj[i][1]= d[i][1]= y;
218  }
219  for(; i<4; i++)
220  s->sprite_traj[i][0]= s->sprite_traj[i][1]= 0;
221 
222  while((1<<alpha)<w) alpha++;
223  while((1<<beta )<h) beta++; // there seems to be a typo in the mpeg4 std for the definition of w' and h'
224  w2= 1<<alpha;
225  h2= 1<<beta;
226 
227 // Note, the 4th point isn't used for GMC
228  if(s->divx_version==500 && s->divx_build==413){
229  sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0];
230  sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1];
231  sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0];
232  sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1];
233  sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0];
234  sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1];
235  } else {
236  sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]);
237  sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]);
238  sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]);
239  sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]);
240  sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]);
241  sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]);
242  }
243 /* sprite_ref[3][0]= (a>>1)*(2*vop_ref[3][0] + d[0][0] + d[1][0] + d[2][0] + d[3][0]);
244  sprite_ref[3][1]= (a>>1)*(2*vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */
245 
246 // this is mostly identical to the mpeg4 std (and is totally unreadable because of that ...)
247 // perhaps it should be reordered to be more readable ...
248 // the idea behind this virtual_ref mess is to be able to use shifts later per pixel instead of divides
249 // so the distance between points is converted from w&h based to w2&h2 based which are of the 2^x form
250  virtual_ref[0][0]= 16*(vop_ref[0][0] + w2)
251  + ROUNDED_DIV(((w - w2)*(r*sprite_ref[0][0] - 16*vop_ref[0][0]) + w2*(r*sprite_ref[1][0] - 16*vop_ref[1][0])),w);
252  virtual_ref[0][1]= 16*vop_ref[0][1]
253  + ROUNDED_DIV(((w - w2)*(r*sprite_ref[0][1] - 16*vop_ref[0][1]) + w2*(r*sprite_ref[1][1] - 16*vop_ref[1][1])),w);
254  virtual_ref[1][0]= 16*vop_ref[0][0]
255  + ROUNDED_DIV(((h - h2)*(r*sprite_ref[0][0] - 16*vop_ref[0][0]) + h2*(r*sprite_ref[2][0] - 16*vop_ref[2][0])),h);
256  virtual_ref[1][1]= 16*(vop_ref[0][1] + h2)
257  + ROUNDED_DIV(((h - h2)*(r*sprite_ref[0][1] - 16*vop_ref[0][1]) + h2*(r*sprite_ref[2][1] - 16*vop_ref[2][1])),h);
258 
259  switch(s->num_sprite_warping_points)
260  {
261  case 0:
262  s->sprite_offset[0][0]= 0;
263  s->sprite_offset[0][1]= 0;
264  s->sprite_offset[1][0]= 0;
265  s->sprite_offset[1][1]= 0;
266  s->sprite_delta[0][0]= a;
267  s->sprite_delta[0][1]= 0;
268  s->sprite_delta[1][0]= 0;
269  s->sprite_delta[1][1]= a;
270  s->sprite_shift[0]= 0;
271  s->sprite_shift[1]= 0;
272  break;
273  case 1: //GMC only
274  s->sprite_offset[0][0]= sprite_ref[0][0] - a*vop_ref[0][0];
275  s->sprite_offset[0][1]= sprite_ref[0][1] - a*vop_ref[0][1];
276  s->sprite_offset[1][0]= ((sprite_ref[0][0]>>1)|(sprite_ref[0][0]&1)) - a*(vop_ref[0][0]/2);
277  s->sprite_offset[1][1]= ((sprite_ref[0][1]>>1)|(sprite_ref[0][1]&1)) - a*(vop_ref[0][1]/2);
278  s->sprite_delta[0][0]= a;
279  s->sprite_delta[0][1]= 0;
280  s->sprite_delta[1][0]= 0;
281  s->sprite_delta[1][1]= a;
282  s->sprite_shift[0]= 0;
283  s->sprite_shift[1]= 0;
284  break;
285  case 2:
286  s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho))
287  + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0])
288  + ( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1])
289  + (1<<(alpha+rho-1));
290  s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho))
291  + (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0])
292  + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1])
293  + (1<<(alpha+rho-1));
294  s->sprite_offset[1][0]= ( (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][0] + 1)
295  +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-2*vop_ref[0][1] + 1)
296  +2*w2*r*sprite_ref[0][0]
297  - 16*w2
298  + (1<<(alpha+rho+1)));
299  s->sprite_offset[1][1]= ( (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-2*vop_ref[0][0] + 1)
300  +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][1] + 1)
301  +2*w2*r*sprite_ref[0][1]
302  - 16*w2
303  + (1<<(alpha+rho+1)));
304  s->sprite_delta[0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0]);
305  s->sprite_delta[0][1]= (+r*sprite_ref[0][1] - virtual_ref[0][1]);
306  s->sprite_delta[1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1]);
307  s->sprite_delta[1][1]= (-r*sprite_ref[0][0] + virtual_ref[0][0]);
308 
309  s->sprite_shift[0]= alpha+rho;
310  s->sprite_shift[1]= alpha+rho+2;
311  break;
312  case 3:
313  min_ab= FFMIN(alpha, beta);
314  w3= w2>>min_ab;
315  h3= h2>>min_ab;
316  s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+beta+rho-min_ab))
317  + (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-vop_ref[0][0])
318  + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-vop_ref[0][1])
319  + (1<<(alpha+beta+rho-min_ab-1));
320  s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+beta+rho-min_ab))
321  + (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-vop_ref[0][0])
322  + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-vop_ref[0][1])
323  + (1<<(alpha+beta+rho-min_ab-1));
324  s->sprite_offset[1][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-2*vop_ref[0][0] + 1)
325  + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-2*vop_ref[0][1] + 1)
326  + 2*w2*h3*r*sprite_ref[0][0]
327  - 16*w2*h3
328  + (1<<(alpha+beta+rho-min_ab+1));
329  s->sprite_offset[1][1]= (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-2*vop_ref[0][0] + 1)
330  + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-2*vop_ref[0][1] + 1)
331  + 2*w2*h3*r*sprite_ref[0][1]
332  - 16*w2*h3
333  + (1<<(alpha+beta+rho-min_ab+1));
334  s->sprite_delta[0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3;
335  s->sprite_delta[0][1]= (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3;
336  s->sprite_delta[1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3;
337  s->sprite_delta[1][1]= (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3;
338 
339  s->sprite_shift[0]= alpha + beta + rho - min_ab;
340  s->sprite_shift[1]= alpha + beta + rho - min_ab + 2;
341  break;
342  }
343  /* try to simplify the situation */
344  if( s->sprite_delta[0][0] == a<<s->sprite_shift[0]
345  && s->sprite_delta[0][1] == 0
346  && s->sprite_delta[1][0] == 0
347  && s->sprite_delta[1][1] == a<<s->sprite_shift[0])
348  {
349  s->sprite_offset[0][0]>>=s->sprite_shift[0];
350  s->sprite_offset[0][1]>>=s->sprite_shift[0];
351  s->sprite_offset[1][0]>>=s->sprite_shift[1];
352  s->sprite_offset[1][1]>>=s->sprite_shift[1];
353  s->sprite_delta[0][0]= a;
354  s->sprite_delta[0][1]= 0;
355  s->sprite_delta[1][0]= 0;
356  s->sprite_delta[1][1]= a;
357  s->sprite_shift[0]= 0;
358  s->sprite_shift[1]= 0;
360  }
361  else{
362  int shift_y= 16 - s->sprite_shift[0];
363  int shift_c= 16 - s->sprite_shift[1];
364  for(i=0; i<2; i++){
365  s->sprite_offset[0][i]<<= shift_y;
366  s->sprite_offset[1][i]<<= shift_c;
367  s->sprite_delta[0][i]<<= shift_y;
368  s->sprite_delta[1][i]<<= shift_y;
369  s->sprite_shift[i]= 16;
370  }
372  }
373  return 0;
374 }
375 
381 {
382  int mb_num_bits= av_log2(s->mb_num - 1) + 1;
383  int header_extension=0, mb_num, len;
384 
385  /* is there enough space left for a video packet + header */
386  if( get_bits_count(&s->gb) > s->gb.size_in_bits-20) return -1;
387 
388  for(len=0; len<32; len++){
389  if(get_bits1(&s->gb)) break;
390  }
391 
393  av_log(s->avctx, AV_LOG_ERROR, "marker does not match f_code\n");
394  return -1;
395  }
396 
397  if(s->shape != RECT_SHAPE){
398  header_extension= get_bits1(&s->gb);
399  //FIXME more stuff here
400  }
401 
402  mb_num= get_bits(&s->gb, mb_num_bits);
403  if(mb_num>=s->mb_num){
404  av_log(s->avctx, AV_LOG_ERROR, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num);
405  return -1;
406  }
407  if(s->pict_type == AV_PICTURE_TYPE_B){
408  int mb_x = 0, mb_y = 0;
409 
410  while (s->next_picture.f.mbskip_table[s->mb_index2xy[mb_num]]) {
411  if (!mb_x)
413  mb_num++;
414  if (++mb_x == s->mb_width) mb_x = 0;
415  }
416  if(mb_num >= s->mb_num) return -1; // slice contains just skipped MBs which where already decoded
417  }
418 
419  s->mb_x= mb_num % s->mb_width;
420  s->mb_y= mb_num / s->mb_width;
421 
422  if(s->shape != BIN_ONLY_SHAPE){
423  int qscale= get_bits(&s->gb, s->quant_precision);
424  if(qscale)
425  s->chroma_qscale=s->qscale= qscale;
426  }
427 
428  if(s->shape == RECT_SHAPE){
429  header_extension= get_bits1(&s->gb);
430  }
431  if(header_extension){
432  int time_incr=0;
433 
434  while (get_bits1(&s->gb) != 0)
435  time_incr++;
436 
437  check_marker(&s->gb, "before time_increment in video packed header");
438  skip_bits(&s->gb, s->time_increment_bits); /* time_increment */
439  check_marker(&s->gb, "before vop_coding_type in video packed header");
440 
441  skip_bits(&s->gb, 2); /* vop coding type */
442  //FIXME not rect stuff here
443 
444  if(s->shape != BIN_ONLY_SHAPE){
445  skip_bits(&s->gb, 3); /* intra dc vlc threshold */
446 //FIXME don't just ignore everything
448  if (mpeg4_decode_sprite_trajectory(s, &s->gb) < 0)
449  return AVERROR_INVALIDDATA;
450  av_log(s->avctx, AV_LOG_ERROR, "untested\n");
451  }
452 
453  //FIXME reduced res stuff here
454 
455  if (s->pict_type != AV_PICTURE_TYPE_I) {
456  int f_code = get_bits(&s->gb, 3); /* fcode_for */
457  if(f_code==0){
458  av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (f_code=0)\n");
459  }
460  }
461  if (s->pict_type == AV_PICTURE_TYPE_B) {
462  int b_code = get_bits(&s->gb, 3);
463  if(b_code==0){
464  av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (b_code=0)\n");
465  }
466  }
467  }
468  }
469  //FIXME new-pred stuff
470 
471  return 0;
472 }
473 
479 static inline int get_amv(MpegEncContext *s, int n){
480  int x, y, mb_v, sum, dx, dy, shift;
481  int len = 1 << (s->f_code + 4);
482  const int a= s->sprite_warping_accuracy;
483 
484  if(s->workaround_bugs & FF_BUG_AMV)
485  len >>= s->quarter_sample;
486 
487  if(s->real_sprite_warping_points==1){
488  if(s->divx_version==500 && s->divx_build==413)
489  sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample));
490  else
491  sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a);
492  }else{
493  dx= s->sprite_delta[n][0];
494  dy= s->sprite_delta[n][1];
495  shift= s->sprite_shift[0];
496  if(n) dy -= 1<<(shift + a + 1);
497  else dx -= 1<<(shift + a + 1);
498  mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16;
499 
500  sum=0;
501  for(y=0; y<16; y++){
502  int v;
503 
504  v= mb_v + dy*y;
505  //XXX FIXME optimize
506  for(x=0; x<16; x++){
507  sum+= v>>shift;
508  v+= dx;
509  }
510  }
511  sum= RSHIFT(sum, a+8-s->quarter_sample);
512  }
513 
514  if (sum < -len) sum= -len;
515  else if (sum >= len) sum= len-1;
516 
517  return sum;
518 }
519 
526 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
527 {
528  int level, code;
529 
530  if (n < 4)
531  code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1);
532  else
533  code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1);
534  if (code < 0 || code > 9 /* && s->nbit<9 */){
535  av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
536  return -1;
537  }
538  if (code == 0) {
539  level = 0;
540  } else {
541  if(IS_3IV1){
542  if(code==1)
543  level= 2*get_bits1(&s->gb)-1;
544  else{
545  if(get_bits1(&s->gb))
546  level = get_bits(&s->gb, code-1) + (1<<(code-1));
547  else
548  level = -get_bits(&s->gb, code-1) - (1<<(code-1));
549  }
550  }else{
551  level = get_xbits(&s->gb, code);
552  }
553 
554  if (code > 8){
555  if(get_bits1(&s->gb)==0){ /* marker */
557  av_log(s->avctx, AV_LOG_ERROR, "dc marker bit missing\n");
558  return -1;
559  }
560  }
561  }
562  }
563 
564  return ff_mpeg4_pred_dc(s, n, level, dir_ptr, 0);
565 }
566 
572  int mb_num;
573  static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
574 
575  /* decode first partition */
576  mb_num=0;
577  s->first_slice_line=1;
578  for(; s->mb_y<s->mb_height; s->mb_y++){
580  for(; s->mb_x<s->mb_width; s->mb_x++){
581  const int xy= s->mb_x + s->mb_y*s->mb_stride;
582  int cbpc;
583  int dir=0;
584 
585  mb_num++;
587  if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
588  s->first_slice_line=0;
589 
591  int i;
592 
593  do{
594  if(show_bits_long(&s->gb, 19)==DC_MARKER){
595  return mb_num-1;
596  }
597 
599  if (cbpc < 0){
600  av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
601  return -1;
602  }
603  }while(cbpc == 8);
604 
605  s->cbp_table[xy]= cbpc & 3;
607  s->mb_intra = 1;
608 
609  if(cbpc & 4) {
610  ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
611  }
613 
614  s->mbintra_table[xy]= 1;
615  for(i=0; i<6; i++){
616  int dc_pred_dir;
617  int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
618  if(dc < 0){
619  av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
620  return -1;
621  }
622  dir<<=1;
623  if(dc_pred_dir) dir|=1;
624  }
625  s->pred_dir_table[xy]= dir;
626  }else{ /* P/S_TYPE */
627  int mx, my, pred_x, pred_y, bits;
628  int16_t * const mot_val = s->current_picture.f.motion_val[0][s->block_index[0]];
629  const int stride= s->b8_stride*2;
630 
631 try_again:
632  bits= show_bits(&s->gb, 17);
633  if(bits==MOTION_MARKER){
634  return mb_num-1;
635  }
636  skip_bits1(&s->gb);
637  if(bits&0x10000){
638  /* skip mb */
641  mx= get_amv(s, 0);
642  my= get_amv(s, 1);
643  }else{
645  mx=my=0;
646  }
647  mot_val[0 ]= mot_val[2 ]=
648  mot_val[0+stride]= mot_val[2+stride]= mx;
649  mot_val[1 ]= mot_val[3 ]=
650  mot_val[1+stride]= mot_val[3+stride]= my;
651 
652  if(s->mbintra_table[xy])
654  continue;
655  }
656 
658  if (cbpc < 0){
659  av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
660  return -1;
661  }
662  if(cbpc == 20)
663  goto try_again;
664 
665  s->cbp_table[xy]= cbpc&(8+3); //8 is dquant
666 
667  s->mb_intra = ((cbpc & 4) != 0);
668 
669  if(s->mb_intra){
671  s->mbintra_table[xy]= 1;
672  mot_val[0 ]= mot_val[2 ]=
673  mot_val[0+stride]= mot_val[2+stride]= 0;
674  mot_val[1 ]= mot_val[3 ]=
675  mot_val[1+stride]= mot_val[3+stride]= 0;
676  }else{
677  if(s->mbintra_table[xy])
679 
680  if(s->pict_type==AV_PICTURE_TYPE_S && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
681  s->mcsel= get_bits1(&s->gb);
682  else s->mcsel= 0;
683 
684  if ((cbpc & 16) == 0) {
685  /* 16x16 motion prediction */
686 
687  ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
688  if(!s->mcsel){
689  mx = ff_h263_decode_motion(s, pred_x, s->f_code);
690  if (mx >= 0xffff)
691  return -1;
692 
693  my = ff_h263_decode_motion(s, pred_y, s->f_code);
694  if (my >= 0xffff)
695  return -1;
697  } else {
698  mx = get_amv(s, 0);
699  my = get_amv(s, 1);
701  }
702 
703  mot_val[0 ]= mot_val[2 ] =
704  mot_val[0+stride]= mot_val[2+stride]= mx;
705  mot_val[1 ]= mot_val[3 ]=
706  mot_val[1+stride]= mot_val[3+stride]= my;
707  } else {
708  int i;
710  for(i=0;i<4;i++) {
711  int16_t *mot_val= ff_h263_pred_motion(s, i, 0, &pred_x, &pred_y);
712  mx = ff_h263_decode_motion(s, pred_x, s->f_code);
713  if (mx >= 0xffff)
714  return -1;
715 
716  my = ff_h263_decode_motion(s, pred_y, s->f_code);
717  if (my >= 0xffff)
718  return -1;
719  mot_val[0] = mx;
720  mot_val[1] = my;
721  }
722  }
723  }
724  }
725  }
726  s->mb_x= 0;
727  }
728 
729  return mb_num;
730 }
731 
736 static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count){
737  int mb_num=0;
738  static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
739 
740  s->mb_x= s->resync_mb_x;
741  s->first_slice_line=1;
742  for(s->mb_y= s->resync_mb_y; mb_num < mb_count; s->mb_y++){
744  for(; mb_num < mb_count && s->mb_x<s->mb_width; s->mb_x++){
745  const int xy= s->mb_x + s->mb_y*s->mb_stride;
746 
747  mb_num++;
749  if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
750  s->first_slice_line=0;
751 
753  int ac_pred= get_bits1(&s->gb);
754  int cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
755  if(cbpy<0){
756  av_log(s->avctx, AV_LOG_ERROR, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
757  return -1;
758  }
759 
760  s->cbp_table[xy]|= cbpy<<2;
761  s->current_picture.f.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
762  }else{ /* P || S_TYPE */
763  if (IS_INTRA(s->current_picture.f.mb_type[xy])) {
764  int dir=0,i;
765  int ac_pred = get_bits1(&s->gb);
766  int cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
767 
768  if(cbpy<0){
769  av_log(s->avctx, AV_LOG_ERROR, "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
770  return -1;
771  }
772 
773  if(s->cbp_table[xy] & 8) {
774  ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
775  }
776  s->current_picture.f.qscale_table[xy] = s->qscale;
777 
778  for(i=0; i<6; i++){
779  int dc_pred_dir;
780  int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
781  if(dc < 0){
782  av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
783  return -1;
784  }
785  dir<<=1;
786  if(dc_pred_dir) dir|=1;
787  }
788  s->cbp_table[xy]&= 3; //remove dquant
789  s->cbp_table[xy]|= cbpy<<2;
790  s->current_picture.f.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
791  s->pred_dir_table[xy]= dir;
792  } else if (IS_SKIP(s->current_picture.f.mb_type[xy])) {
793  s->current_picture.f.qscale_table[xy] = s->qscale;
794  s->cbp_table[xy]= 0;
795  }else{
796  int cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
797 
798  if(cbpy<0){
799  av_log(s->avctx, AV_LOG_ERROR, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
800  return -1;
801  }
802 
803  if(s->cbp_table[xy] & 8) {
804  ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
805  }
806  s->current_picture.f.qscale_table[xy] = s->qscale;
807 
808  s->cbp_table[xy]&= 3; //remove dquant
809  s->cbp_table[xy]|= (cbpy^0xf)<<2;
810  }
811  }
812  }
813  if(mb_num >= mb_count) return 0;
814  s->mb_x= 0;
815  }
816  return 0;
817 }
818 
824 {
825  int mb_num;
826  const int part_a_error= s->pict_type==AV_PICTURE_TYPE_I ? (ER_DC_ERROR|ER_MV_ERROR) : ER_MV_ERROR;
827  const int part_a_end = s->pict_type==AV_PICTURE_TYPE_I ? (ER_DC_END |ER_MV_END) : ER_MV_END;
828 
829  mb_num= mpeg4_decode_partition_a(s);
830  if(mb_num<0){
831  ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
832  return -1;
833  }
834 
835  if(s->resync_mb_x + s->resync_mb_y*s->mb_width + mb_num > s->mb_num){
836  av_log(s->avctx, AV_LOG_ERROR, "slice below monitor ...\n");
837  ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
838  return -1;
839  }
840 
841  s->mb_num_left= mb_num;
842 
844  while(show_bits(&s->gb, 9) == 1)
845  skip_bits(&s->gb, 9);
846  if(get_bits_long(&s->gb, 19)!=DC_MARKER){
847  av_log(s->avctx, AV_LOG_ERROR, "marker missing after first I partition at %d %d\n", s->mb_x, s->mb_y);
848  return -1;
849  }
850  }else{
851  while(show_bits(&s->gb, 10) == 1)
852  skip_bits(&s->gb, 10);
853  if(get_bits(&s->gb, 17)!=MOTION_MARKER){
854  av_log(s->avctx, AV_LOG_ERROR, "marker missing after first P partition at %d %d\n", s->mb_x, s->mb_y);
855  return -1;
856  }
857  }
858  ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, part_a_end);
859 
860  if( mpeg4_decode_partition_b(s, mb_num) < 0){
863  return -1;
864  }else{
867  }
868 
869  return 0;
870 }
871 
877  int n, int coded, int intra, int rvlc)
878 {
879  int level, i, last, run;
880  int dc_pred_dir;
881  RLTable * rl;
882  RL_VLC_ELEM * rl_vlc;
883  const uint8_t * scan_table;
884  int qmul, qadd;
885 
886  //Note intra & rvlc should be optimized away if this is inlined
887 
888  if(intra) {
889  if(s->use_intra_dc_vlc){
890  /* DC coef */
891  if(s->partitioned_frame){
892  level = s->dc_val[0][ s->block_index[n] ];
893  if(n<4) level= FASTDIV((level + (s->y_dc_scale>>1)), s->y_dc_scale);
894  else level= FASTDIV((level + (s->c_dc_scale>>1)), s->c_dc_scale);
895  dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_stride]<<n)&32;
896  }else{
897  level = mpeg4_decode_dc(s, n, &dc_pred_dir);
898  if (level < 0)
899  return -1;
900  }
901  block[0] = level;
902  i = 0;
903  }else{
904  i = -1;
905  ff_mpeg4_pred_dc(s, n, 0, &dc_pred_dir, 0);
906  }
907  if (!coded)
908  goto not_coded;
909 
910  if(rvlc){
911  rl = &ff_rvlc_rl_intra;
912  rl_vlc = ff_rvlc_rl_intra.rl_vlc[0];
913  }else{
914  rl = &ff_mpeg4_rl_intra;
915  rl_vlc = ff_mpeg4_rl_intra.rl_vlc[0];
916  }
917  if (s->ac_pred) {
918  if (dc_pred_dir == 0)
919  scan_table = s->intra_v_scantable.permutated; /* left */
920  else
921  scan_table = s->intra_h_scantable.permutated; /* top */
922  } else {
923  scan_table = s->intra_scantable.permutated;
924  }
925  qmul=1;
926  qadd=0;
927  } else {
928  i = -1;
929  if (!coded) {
930  s->block_last_index[n] = i;
931  return 0;
932  }
933  if(rvlc) rl = &ff_rvlc_rl_inter;
934  else rl = &ff_h263_rl_inter;
935 
936  scan_table = s->intra_scantable.permutated;
937 
938  if(s->mpeg_quant){
939  qmul=1;
940  qadd=0;
941  if(rvlc){
942  rl_vlc = ff_rvlc_rl_inter.rl_vlc[0];
943  }else{
944  rl_vlc = ff_h263_rl_inter.rl_vlc[0];
945  }
946  }else{
947  qmul = s->qscale << 1;
948  qadd = (s->qscale - 1) | 1;
949  if(rvlc){
950  rl_vlc = ff_rvlc_rl_inter.rl_vlc[s->qscale];
951  }else{
952  rl_vlc = ff_h263_rl_inter.rl_vlc[s->qscale];
953  }
954  }
955  }
956  {
957  OPEN_READER(re, &s->gb);
958  for(;;) {
959  UPDATE_CACHE(re, &s->gb);
960  GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
961  if (level==0) {
962  /* escape */
963  if(rvlc){
964  if(SHOW_UBITS(re, &s->gb, 1)==0){
965  av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in rvlc esc\n");
966  return -1;
967  }; SKIP_CACHE(re, &s->gb, 1);
968 
969  last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
970  run= SHOW_UBITS(re, &s->gb, 6);
971  SKIP_COUNTER(re, &s->gb, 1+1+6);
972  UPDATE_CACHE(re, &s->gb);
973 
974  if(SHOW_UBITS(re, &s->gb, 1)==0){
975  av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in rvlc esc\n");
976  return -1;
977  }; SKIP_CACHE(re, &s->gb, 1);
978 
979  level= SHOW_UBITS(re, &s->gb, 11); SKIP_CACHE(re, &s->gb, 11);
980 
981  if(SHOW_UBITS(re, &s->gb, 5)!=0x10){
982  av_log(s->avctx, AV_LOG_ERROR, "reverse esc missing\n");
983  return -1;
984  }; SKIP_CACHE(re, &s->gb, 5);
985 
986  level= level * qmul + qadd;
987  level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
988  SKIP_COUNTER(re, &s->gb, 1+11+5+1);
989 
990  i+= run + 1;
991  if(last) i+=192;
992  }else{
993  int cache;
994  cache= GET_CACHE(re, &s->gb);
995 
996  if(IS_3IV1)
997  cache ^= 0xC0000000;
998 
999  if (cache&0x80000000) {
1000  if (cache&0x40000000) {
1001  /* third escape */
1002  SKIP_CACHE(re, &s->gb, 2);
1003  last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
1004  run= SHOW_UBITS(re, &s->gb, 6);
1005  SKIP_COUNTER(re, &s->gb, 2+1+6);
1006  UPDATE_CACHE(re, &s->gb);
1007 
1008  if(IS_3IV1){
1009  level= SHOW_SBITS(re, &s->gb, 12); LAST_SKIP_BITS(re, &s->gb, 12);
1010  }else{
1011  if(SHOW_UBITS(re, &s->gb, 1)==0){
1012  av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in 3. esc\n");
1013  return -1;
1014  }; SKIP_CACHE(re, &s->gb, 1);
1015 
1016  level= SHOW_SBITS(re, &s->gb, 12); SKIP_CACHE(re, &s->gb, 12);
1017 
1018  if(SHOW_UBITS(re, &s->gb, 1)==0){
1019  av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in 3. esc\n");
1020  return -1;
1021  }
1022 
1023  SKIP_COUNTER(re, &s->gb, 1+12+1);
1024  }
1025 
1026  if (level>0) level= level * qmul + qadd;
1027  else level= level * qmul - qadd;
1028 
1029  if((unsigned)(level + 2048) > 4095){
1031  if(level > 2560 || level<-2560){
1032  av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc, qp=%d\n", s->qscale);
1033  return -1;
1034  }
1035  }
1036  level= level<0 ? -2048 : 2047;
1037  }
1038 
1039  i+= run + 1;
1040  if(last) i+=192;
1041  } else {
1042  /* second escape */
1043  SKIP_BITS(re, &s->gb, 2);
1044  GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
1045  i+= run + rl->max_run[run>>7][level/qmul] +1; //FIXME opt indexing
1046  level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1047  LAST_SKIP_BITS(re, &s->gb, 1);
1048  }
1049  } else {
1050  /* first escape */
1051  SKIP_BITS(re, &s->gb, 1);
1052  GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
1053  i+= run;
1054  level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
1055  level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1056  LAST_SKIP_BITS(re, &s->gb, 1);
1057  }
1058  }
1059  } else {
1060  i+= run;
1061  level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1062  LAST_SKIP_BITS(re, &s->gb, 1);
1063  }
1064  if (i > 62){
1065  i-= 192;
1066  if(i&(~63)){
1067  av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1068  return -1;
1069  }
1070 
1071  block[scan_table[i]] = level;
1072  break;
1073  }
1074 
1075  block[scan_table[i]] = level;
1076  }
1077  CLOSE_READER(re, &s->gb);
1078  }
1079  not_coded:
1080  if (intra) {
1081  if(!s->use_intra_dc_vlc){
1082  block[0] = ff_mpeg4_pred_dc(s, n, block[0], &dc_pred_dir, 0);
1083 
1084  i -= i>>31; //if(i == -1) i=0;
1085  }
1086 
1087  ff_mpeg4_pred_ac(s, block, n, dc_pred_dir);
1088  if (s->ac_pred) {
1089  i = 63; /* XXX: not optimal */
1090  }
1091  }
1092  s->block_last_index[n] = i;
1093  return 0;
1094 }
1095 
1101 {
1102  int cbp, mb_type;
1103  const int xy= s->mb_x + s->mb_y*s->mb_stride;
1104 
1105  mb_type = s->current_picture.f.mb_type[xy];
1106  cbp = s->cbp_table[xy];
1107 
1109 
1110  if (s->current_picture.f.qscale_table[xy] != s->qscale) {
1112  }
1113 
1115  int i;
1116  for(i=0; i<4; i++){
1117  s->mv[0][i][0] = s->current_picture.f.motion_val[0][s->block_index[i]][0];
1118  s->mv[0][i][1] = s->current_picture.f.motion_val[0][s->block_index[i]][1];
1119  }
1120  s->mb_intra = IS_INTRA(mb_type);
1121 
1122  if (IS_SKIP(mb_type)) {
1123  /* skip mb */
1124  for(i=0;i<6;i++)
1125  s->block_last_index[i] = -1;
1126  s->mv_dir = MV_DIR_FORWARD;
1127  s->mv_type = MV_TYPE_16X16;
1129  s->mcsel=1;
1130  s->mb_skipped = 0;
1131  }else{
1132  s->mcsel=0;
1133  s->mb_skipped = 1;
1134  }
1135  }else if(s->mb_intra){
1136  s->ac_pred = IS_ACPRED(s->current_picture.f.mb_type[xy]);
1137  }else if(!s->mb_intra){
1138 // s->mcsel= 0; //FIXME do we need to init that
1139 
1140  s->mv_dir = MV_DIR_FORWARD;
1141  if (IS_8X8(mb_type)) {
1142  s->mv_type = MV_TYPE_8X8;
1143  } else {
1144  s->mv_type = MV_TYPE_16X16;
1145  }
1146  }
1147  } else { /* I-Frame */
1148  s->mb_intra = 1;
1149  s->ac_pred = IS_ACPRED(s->current_picture.f.mb_type[xy]);
1150  }
1151 
1152  if (!IS_SKIP(mb_type)) {
1153  int i;
1154  s->dsp.clear_blocks(s->block[0]);
1155  /* decode each block */
1156  for (i = 0; i < 6; i++) {
1157  if(mpeg4_decode_block(s, block[i], i, cbp&32, s->mb_intra, s->rvlc) < 0){
1158  av_log(s->avctx, AV_LOG_ERROR, "texture corrupted at %d %d %d\n", s->mb_x, s->mb_y, s->mb_intra);
1159  return -1;
1160  }
1161  cbp+=cbp;
1162  }
1163  }
1164 
1165  /* per-MB end of slice check */
1166 
1167  if(--s->mb_num_left <= 0){
1168  if(mpeg4_is_resync(s))
1169  return SLICE_END;
1170  else
1171  return SLICE_NOEND;
1172  }else{
1173  if(mpeg4_is_resync(s)){
1174  const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
1175  if(s->cbp_table[xy+delta])
1176  return SLICE_END;
1177  }
1178  return SLICE_OK;
1179  }
1180 }
1181 
1183  DCTELEM block[6][64])
1184 {
1185  int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
1186  int16_t *mot_val;
1187  static int8_t quant_tab[4] = { -1, -2, 1, 2 };
1188  const int xy= s->mb_x + s->mb_y * s->mb_stride;
1189 
1190  assert(s->h263_pred);
1191 
1193  do{
1194  if (get_bits1(&s->gb)) {
1195  /* skip mb */
1196  s->mb_intra = 0;
1197  for(i=0;i<6;i++)
1198  s->block_last_index[i] = -1;
1199  s->mv_dir = MV_DIR_FORWARD;
1200  s->mv_type = MV_TYPE_16X16;
1203  s->mcsel=1;
1204  s->mv[0][0][0]= get_amv(s, 0);
1205  s->mv[0][0][1]= get_amv(s, 1);
1206 
1207  s->mb_skipped = 0;
1208  }else{
1210  s->mcsel=0;
1211  s->mv[0][0][0] = 0;
1212  s->mv[0][0][1] = 0;
1213  s->mb_skipped = 1;
1214  }
1215  goto end;
1216  }
1218  if (cbpc < 0){
1219  av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
1220  return -1;
1221  }
1222  }while(cbpc == 20);
1223 
1224  s->dsp.clear_blocks(s->block[0]);
1225  dquant = cbpc & 8;
1226  s->mb_intra = ((cbpc & 4) != 0);
1227  if (s->mb_intra) goto intra;
1228 
1229  if(s->pict_type==AV_PICTURE_TYPE_S && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
1230  s->mcsel= get_bits1(&s->gb);
1231  else s->mcsel= 0;
1232  cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1) ^ 0x0F;
1233 
1234  cbp = (cbpc & 3) | (cbpy << 2);
1235  if (dquant) {
1236  ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
1237  }
1238  if((!s->progressive_sequence) && (cbp || (s->workaround_bugs&FF_BUG_XVID_ILACE)))
1239  s->interlaced_dct= get_bits1(&s->gb);
1240 
1241  s->mv_dir = MV_DIR_FORWARD;
1242  if ((cbpc & 16) == 0) {
1243  if(s->mcsel){
1245  /* 16x16 global motion prediction */
1246  s->mv_type = MV_TYPE_16X16;
1247  mx= get_amv(s, 0);
1248  my= get_amv(s, 1);
1249  s->mv[0][0][0] = mx;
1250  s->mv[0][0][1] = my;
1251  }else if((!s->progressive_sequence) && get_bits1(&s->gb)){
1253  /* 16x8 field motion prediction */
1254  s->mv_type= MV_TYPE_FIELD;
1255 
1256  s->field_select[0][0]= get_bits1(&s->gb);
1257  s->field_select[0][1]= get_bits1(&s->gb);
1258 
1259  ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1260 
1261  for(i=0; i<2; i++){
1262  mx = ff_h263_decode_motion(s, pred_x, s->f_code);
1263  if (mx >= 0xffff)
1264  return -1;
1265 
1266  my = ff_h263_decode_motion(s, pred_y/2, s->f_code);
1267  if (my >= 0xffff)
1268  return -1;
1269 
1270  s->mv[0][i][0] = mx;
1271  s->mv[0][i][1] = my;
1272  }
1273  }else{
1275  /* 16x16 motion prediction */
1276  s->mv_type = MV_TYPE_16X16;
1277  ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
1278  mx = ff_h263_decode_motion(s, pred_x, s->f_code);
1279 
1280  if (mx >= 0xffff)
1281  return -1;
1282 
1283  my = ff_h263_decode_motion(s, pred_y, s->f_code);
1284 
1285  if (my >= 0xffff)
1286  return -1;
1287  s->mv[0][0][0] = mx;
1288  s->mv[0][0][1] = my;
1289  }
1290  } else {
1292  s->mv_type = MV_TYPE_8X8;
1293  for(i=0;i<4;i++) {
1294  mot_val = ff_h263_pred_motion(s, i, 0, &pred_x, &pred_y);
1295  mx = ff_h263_decode_motion(s, pred_x, s->f_code);
1296  if (mx >= 0xffff)
1297  return -1;
1298 
1299  my = ff_h263_decode_motion(s, pred_y, s->f_code);
1300  if (my >= 0xffff)
1301  return -1;
1302  s->mv[0][i][0] = mx;
1303  s->mv[0][i][1] = my;
1304  mot_val[0] = mx;
1305  mot_val[1] = my;
1306  }
1307  }
1308  } else if(s->pict_type==AV_PICTURE_TYPE_B) {
1309  int modb1; // first bit of modb
1310  int modb2; // second bit of modb
1311  int mb_type;
1312 
1313  s->mb_intra = 0; //B-frames never contain intra blocks
1314  s->mcsel=0; // ... true gmc blocks
1315 
1316  if(s->mb_x==0){
1317  for(i=0; i<2; i++){
1318  s->last_mv[i][0][0]=
1319  s->last_mv[i][0][1]=
1320  s->last_mv[i][1][0]=
1321  s->last_mv[i][1][1]= 0;
1322  }
1323 
1325  }
1326 
1327  /* if we skipped it in the future P Frame than skip it now too */
1328  s->mb_skipped = s->next_picture.f.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]; // Note, skiptab=0 if last was GMC
1329 
1330  if(s->mb_skipped){
1331  /* skip mb */
1332  for(i=0;i<6;i++)
1333  s->block_last_index[i] = -1;
1334 
1335  s->mv_dir = MV_DIR_FORWARD;
1336  s->mv_type = MV_TYPE_16X16;
1337  s->mv[0][0][0] = 0;
1338  s->mv[0][0][1] = 0;
1339  s->mv[1][0][0] = 0;
1340  s->mv[1][0][1] = 0;
1342  goto end;
1343  }
1344 
1345  modb1= get_bits1(&s->gb);
1346  if(modb1){
1347  mb_type= MB_TYPE_DIRECT2 | MB_TYPE_SKIP | MB_TYPE_L0L1; //like MB_TYPE_B_DIRECT but no vectors coded
1348  cbp=0;
1349  }else{
1350  modb2= get_bits1(&s->gb);
1351  mb_type= get_vlc2(&s->gb, mb_type_b_vlc.table, MB_TYPE_B_VLC_BITS, 1);
1352  if(mb_type<0){
1353  av_log(s->avctx, AV_LOG_ERROR, "illegal MB_type\n");
1354  return -1;
1355  }
1356  mb_type= mb_type_b_map[ mb_type ];
1357  if(modb2) cbp= 0;
1358  else{
1359  s->dsp.clear_blocks(s->block[0]);
1360  cbp= get_bits(&s->gb, 6);
1361  }
1362 
1363  if ((!IS_DIRECT(mb_type)) && cbp) {
1364  if(get_bits1(&s->gb)){
1365  ff_set_qscale(s, s->qscale + get_bits1(&s->gb)*4 - 2);
1366  }
1367  }
1368 
1369  if(!s->progressive_sequence){
1370  if(cbp)
1371  s->interlaced_dct= get_bits1(&s->gb);
1372 
1373  if(!IS_DIRECT(mb_type) && get_bits1(&s->gb)){
1374  mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
1375  mb_type &= ~MB_TYPE_16x16;
1376 
1377  if(USES_LIST(mb_type, 0)){
1378  s->field_select[0][0]= get_bits1(&s->gb);
1379  s->field_select[0][1]= get_bits1(&s->gb);
1380  }
1381  if(USES_LIST(mb_type, 1)){
1382  s->field_select[1][0]= get_bits1(&s->gb);
1383  s->field_select[1][1]= get_bits1(&s->gb);
1384  }
1385  }
1386  }
1387 
1388  s->mv_dir = 0;
1389  if((mb_type & (MB_TYPE_DIRECT2|MB_TYPE_INTERLACED)) == 0){
1390  s->mv_type= MV_TYPE_16X16;
1391 
1392  if(USES_LIST(mb_type, 0)){
1393  s->mv_dir = MV_DIR_FORWARD;
1394 
1395  mx = ff_h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
1396  my = ff_h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
1397  s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
1398  s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my;
1399  }
1400 
1401  if(USES_LIST(mb_type, 1)){
1402  s->mv_dir |= MV_DIR_BACKWARD;
1403 
1404  mx = ff_h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
1405  my = ff_h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
1406  s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
1407  s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my;
1408  }
1409  }else if(!IS_DIRECT(mb_type)){
1410  s->mv_type= MV_TYPE_FIELD;
1411 
1412  if(USES_LIST(mb_type, 0)){
1413  s->mv_dir = MV_DIR_FORWARD;
1414 
1415  for(i=0; i<2; i++){
1416  mx = ff_h263_decode_motion(s, s->last_mv[0][i][0] , s->f_code);
1417  my = ff_h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code);
1418  s->last_mv[0][i][0]= s->mv[0][i][0] = mx;
1419  s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2;
1420  }
1421  }
1422 
1423  if(USES_LIST(mb_type, 1)){
1424  s->mv_dir |= MV_DIR_BACKWARD;
1425 
1426  for(i=0; i<2; i++){
1427  mx = ff_h263_decode_motion(s, s->last_mv[1][i][0] , s->b_code);
1428  my = ff_h263_decode_motion(s, s->last_mv[1][i][1]/2, s->b_code);
1429  s->last_mv[1][i][0]= s->mv[1][i][0] = mx;
1430  s->last_mv[1][i][1]= (s->mv[1][i][1] = my)*2;
1431  }
1432  }
1433  }
1434  }
1435 
1436  if(IS_DIRECT(mb_type)){
1437  if(IS_SKIP(mb_type))
1438  mx=my=0;
1439  else{
1440  mx = ff_h263_decode_motion(s, 0, 1);
1441  my = ff_h263_decode_motion(s, 0, 1);
1442  }
1443 
1445  mb_type |= ff_mpeg4_set_direct_mv(s, mx, my);
1446  }
1447  s->current_picture.f.mb_type[xy] = mb_type;
1448  } else { /* I-Frame */
1449  do{
1451  if (cbpc < 0){
1452  av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
1453  return -1;
1454  }
1455  }while(cbpc == 8);
1456 
1457  dquant = cbpc & 4;
1458  s->mb_intra = 1;
1459 intra:
1460  s->ac_pred = get_bits1(&s->gb);
1461  if(s->ac_pred)
1463  else
1465 
1466  cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
1467  if(cbpy<0){
1468  av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
1469  return -1;
1470  }
1471  cbp = (cbpc & 3) | (cbpy << 2);
1472 
1474 
1475  if (dquant) {
1476  ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
1477  }
1478 
1479  if(!s->progressive_sequence)
1480  s->interlaced_dct= get_bits1(&s->gb);
1481 
1482  s->dsp.clear_blocks(s->block[0]);
1483  /* decode each block */
1484  for (i = 0; i < 6; i++) {
1485  if (mpeg4_decode_block(s, block[i], i, cbp&32, 1, 0) < 0)
1486  return -1;
1487  cbp+=cbp;
1488  }
1489  goto end;
1490  }
1491 
1492  /* decode each block */
1493  for (i = 0; i < 6; i++) {
1494  if (mpeg4_decode_block(s, block[i], i, cbp&32, 0, 0) < 0)
1495  return -1;
1496  cbp+=cbp;
1497  }
1498 end:
1499 
1500  /* per-MB end of slice check */
1501  if(s->codec_id==AV_CODEC_ID_MPEG4){
1502  if(mpeg4_is_resync(s)){
1503  const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
1504 
1505  if (s->pict_type == AV_PICTURE_TYPE_B && s->next_picture.f.mbskip_table[xy + delta]) {
1507  (s->mb_x + delta >= s->mb_width) ? FFMIN(s->mb_y+1, s->mb_height-1) : s->mb_y, 0);
1508  }
1509 
1510  if (s->pict_type == AV_PICTURE_TYPE_B && s->next_picture.f.mbskip_table[xy + delta])
1511  return SLICE_OK;
1512  return SLICE_END;
1513  }
1514  }
1515 
1516  return SLICE_OK;
1517 }
1518 
1519 
1521  int hours, minutes, seconds;
1522  unsigned time_code = show_bits(gb, 18);
1523 
1524  if (time_code & 0x40) { /* marker_bit */
1525  hours = time_code >> 13;
1526  minutes = time_code >> 7 & 0x3f;
1527  seconds = time_code & 0x3f;
1528  s->time_base = seconds + 60*(minutes + 60*hours);
1529  skip_bits(gb, 20); /* time_code, closed_gov, broken_link */
1530  } else {
1531  av_log(s->avctx, AV_LOG_WARNING, "GOP header missing marker_bit\n");
1532  }
1533 
1534  return 0;
1535 }
1536 
1538  int profile_and_level_indication;
1539 
1540  profile_and_level_indication = get_bits(gb, 8);
1541 
1542  s->avctx->profile = (profile_and_level_indication & 0xf0) >> 4;
1543  s->avctx->level = (profile_and_level_indication & 0x0f);
1544 
1545  // for Simple profile, level 0
1546  if (s->avctx->profile == 0 && s->avctx->level == 8) {
1547  s->avctx->level = 0;
1548  }
1549 
1550  return 0;
1551 }
1552 
1554  int width, height, vo_ver_id;
1555 
1556  /* vol header */
1557  skip_bits(gb, 1); /* random access */
1558  s->vo_type= get_bits(gb, 8);
1559  if (get_bits1(gb) != 0) { /* is_ol_id */
1560  vo_ver_id = get_bits(gb, 4); /* vo_ver_id */
1561  skip_bits(gb, 3); /* vo_priority */
1562  } else {
1563  vo_ver_id = 1;
1564  }
1565  s->aspect_ratio_info= get_bits(gb, 4);
1567  s->avctx->sample_aspect_ratio.num= get_bits(gb, 8); // par_width
1568  s->avctx->sample_aspect_ratio.den= get_bits(gb, 8); // par_height
1569  }else{
1571  }
1572 
1573  if ((s->vol_control_parameters=get_bits1(gb))) { /* vol control parameter */
1574  int chroma_format= get_bits(gb, 2);
1575  if(chroma_format!=CHROMA_420){
1576  av_log(s->avctx, AV_LOG_ERROR, "illegal chroma format\n");
1577  }
1578  s->low_delay= get_bits1(gb);
1579  if(get_bits1(gb)){ /* vbv parameters */
1580  get_bits(gb, 15); /* first_half_bitrate */
1581  skip_bits1(gb); /* marker */
1582  get_bits(gb, 15); /* latter_half_bitrate */
1583  skip_bits1(gb); /* marker */
1584  get_bits(gb, 15); /* first_half_vbv_buffer_size */
1585  skip_bits1(gb); /* marker */
1586  get_bits(gb, 3); /* latter_half_vbv_buffer_size */
1587  get_bits(gb, 11); /* first_half_vbv_occupancy */
1588  skip_bits1(gb); /* marker */
1589  get_bits(gb, 15); /* latter_half_vbv_occupancy */
1590  skip_bits1(gb); /* marker */
1591  }
1592  }else{
1593  // set low delay flag only once the smartest? low delay detection won't be overriden
1594  if(s->picture_number==0)
1595  s->low_delay=0;
1596  }
1597 
1598  s->shape = get_bits(gb, 2); /* vol shape */
1599  if(s->shape != RECT_SHAPE) av_log(s->avctx, AV_LOG_ERROR, "only rectangular vol supported\n");
1600  if(s->shape == GRAY_SHAPE && vo_ver_id != 1){
1601  av_log(s->avctx, AV_LOG_ERROR, "Gray shape not supported\n");
1602  skip_bits(gb, 4); //video_object_layer_shape_extension
1603  }
1604 
1605  check_marker(gb, "before time_increment_resolution");
1606 
1607  s->avctx->time_base.den = get_bits(gb, 16);
1608  if(!s->avctx->time_base.den){
1609  av_log(s->avctx, AV_LOG_ERROR, "time_base.den==0\n");
1610  s->avctx->time_base.num = 0;
1611  return -1;
1612  }
1613 
1614  s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
1615  if (s->time_increment_bits < 1)
1616  s->time_increment_bits = 1;
1617 
1618  check_marker(gb, "before fixed_vop_rate");
1619 
1620  if (get_bits1(gb) != 0) { /* fixed_vop_rate */
1622  }else
1623  s->avctx->time_base.num = 1;
1624 
1625  s->t_frame=0;
1626 
1627  if (s->shape != BIN_ONLY_SHAPE) {
1628  if (s->shape == RECT_SHAPE) {
1629  skip_bits1(gb); /* marker */
1630  width = get_bits(gb, 13);
1631  skip_bits1(gb); /* marker */
1632  height = get_bits(gb, 13);
1633  skip_bits1(gb); /* marker */
1634  if(width && height && !(s->width && s->codec_tag == AV_RL32("MP4S"))){ /* they should be non zero but who knows ... */
1635  if (s->width && s->height &&
1636  (s->width != width || s->height != height))
1637  s->context_reinit = 1;
1638  s->width = width;
1639  s->height = height;
1640  }
1641  }
1642 
1644  s->progressive_frame= get_bits1(gb)^1;
1645  s->interlaced_dct=0;
1646  if(!get_bits1(gb) && (s->avctx->debug & FF_DEBUG_PICT_INFO))
1647  av_log(s->avctx, AV_LOG_INFO, "MPEG4 OBMC not supported (very likely buggy encoder)\n"); /* OBMC Disable */
1648  if (vo_ver_id == 1) {
1649  s->vol_sprite_usage = get_bits1(gb); /* vol_sprite_usage */
1650  } else {
1651  s->vol_sprite_usage = get_bits(gb, 2); /* vol_sprite_usage */
1652  }
1653  if(s->vol_sprite_usage==STATIC_SPRITE) av_log(s->avctx, AV_LOG_ERROR, "Static Sprites not supported\n");
1656  s->sprite_width = get_bits(gb, 13);
1657  skip_bits1(gb); /* marker */
1658  s->sprite_height= get_bits(gb, 13);
1659  skip_bits1(gb); /* marker */
1660  s->sprite_left = get_bits(gb, 13);
1661  skip_bits1(gb); /* marker */
1662  s->sprite_top = get_bits(gb, 13);
1663  skip_bits1(gb); /* marker */
1664  }
1666  if(s->num_sprite_warping_points > 3){
1667  av_log(s->avctx, AV_LOG_ERROR, "%d sprite_warping_points\n", s->num_sprite_warping_points);
1669  return -1;
1670  }
1671  s->sprite_warping_accuracy = get_bits(gb, 2);
1674  s->low_latency_sprite= get_bits1(gb);
1675  }
1676  // FIXME sadct disable bit if verid!=1 && shape not rect
1677 
1678  if (get_bits1(gb) == 1) { /* not_8_bit */
1679  s->quant_precision = get_bits(gb, 4); /* quant_precision */
1680  if(get_bits(gb, 4)!=8) av_log(s->avctx, AV_LOG_ERROR, "N-bit not supported\n"); /* bits_per_pixel */
1681  if(s->quant_precision!=5) av_log(s->avctx, AV_LOG_ERROR, "quant precision %d\n", s->quant_precision);
1682  } else {
1683  s->quant_precision = 5;
1684  }
1685 
1686  // FIXME a bunch of grayscale shape things
1687 
1688  if((s->mpeg_quant=get_bits1(gb))){ /* vol_quant_type */
1689  int i, v;
1690 
1691  /* load default matrixes */
1692  for(i=0; i<64; i++){
1693  int j= s->dsp.idct_permutation[i];
1695  s->intra_matrix[j]= v;
1696  s->chroma_intra_matrix[j]= v;
1697 
1699  s->inter_matrix[j]= v;
1700  s->chroma_inter_matrix[j]= v;
1701  }
1702 
1703  /* load custom intra matrix */
1704  if(get_bits1(gb)){
1705  int last=0;
1706  for(i=0; i<64; i++){
1707  int j;
1708  v= get_bits(gb, 8);
1709  if(v==0) break;
1710 
1711  last= v;
1713  s->intra_matrix[j]= v;
1714  s->chroma_intra_matrix[j]= v;
1715  }
1716 
1717  /* replicate last value */
1718  for(; i<64; i++){
1719  int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
1720  s->intra_matrix[j]= last;
1721  s->chroma_intra_matrix[j]= last;
1722  }
1723  }
1724 
1725  /* load custom non intra matrix */
1726  if(get_bits1(gb)){
1727  int last=0;
1728  for(i=0; i<64; i++){
1729  int j;
1730  v= get_bits(gb, 8);
1731  if(v==0) break;
1732 
1733  last= v;
1735  s->inter_matrix[j]= v;
1736  s->chroma_inter_matrix[j]= v;
1737  }
1738 
1739  /* replicate last value */
1740  for(; i<64; i++){
1741  int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
1742  s->inter_matrix[j]= last;
1743  s->chroma_inter_matrix[j]= last;
1744  }
1745  }
1746 
1747  // FIXME a bunch of grayscale shape things
1748  }
1749 
1750  if(vo_ver_id != 1)
1751  s->quarter_sample= get_bits1(gb);
1752  else s->quarter_sample=0;
1753 
1754  if(!get_bits1(gb)){
1755  int pos= get_bits_count(gb);
1756  int estimation_method= get_bits(gb, 2);
1757  if(estimation_method<2){
1758  if(!get_bits1(gb)){
1759  s->cplx_estimation_trash_i += 8*get_bits1(gb); //opaque
1760  s->cplx_estimation_trash_i += 8*get_bits1(gb); //transparent
1761  s->cplx_estimation_trash_i += 8*get_bits1(gb); //intra_cae
1762  s->cplx_estimation_trash_i += 8*get_bits1(gb); //inter_cae
1763  s->cplx_estimation_trash_i += 8*get_bits1(gb); //no_update
1764  s->cplx_estimation_trash_i += 8*get_bits1(gb); //upampling
1765  }
1766  if(!get_bits1(gb)){
1767  s->cplx_estimation_trash_i += 8*get_bits1(gb); //intra_blocks
1768  s->cplx_estimation_trash_p += 8*get_bits1(gb); //inter_blocks
1769  s->cplx_estimation_trash_p += 8*get_bits1(gb); //inter4v_blocks
1770  s->cplx_estimation_trash_i += 8*get_bits1(gb); //not coded blocks
1771  }
1772  if(!check_marker(gb, "in complexity estimation part 1")){
1773  skip_bits_long(gb, pos - get_bits_count(gb));
1774  goto no_cplx_est;
1775  }
1776  if(!get_bits1(gb)){
1777  s->cplx_estimation_trash_i += 8*get_bits1(gb); //dct_coeffs
1778  s->cplx_estimation_trash_i += 8*get_bits1(gb); //dct_lines
1779  s->cplx_estimation_trash_i += 8*get_bits1(gb); //vlc_syms
1780  s->cplx_estimation_trash_i += 4*get_bits1(gb); //vlc_bits
1781  }
1782  if(!get_bits1(gb)){
1783  s->cplx_estimation_trash_p += 8*get_bits1(gb); //apm
1784  s->cplx_estimation_trash_p += 8*get_bits1(gb); //npm
1785  s->cplx_estimation_trash_b += 8*get_bits1(gb); //interpolate_mc_q
1786  s->cplx_estimation_trash_p += 8*get_bits1(gb); //forwback_mc_q
1787  s->cplx_estimation_trash_p += 8*get_bits1(gb); //halfpel2
1788  s->cplx_estimation_trash_p += 8*get_bits1(gb); //halfpel4
1789  }
1790  if(!check_marker(gb, "in complexity estimation part 2")){
1791  skip_bits_long(gb, pos - get_bits_count(gb));
1792  goto no_cplx_est;
1793  }
1794  if(estimation_method==1){
1795  s->cplx_estimation_trash_i += 8*get_bits1(gb); //sadct
1796  s->cplx_estimation_trash_p += 8*get_bits1(gb); //qpel
1797  }
1798  }else
1799  av_log(s->avctx, AV_LOG_ERROR, "Invalid Complexity estimation method %d\n", estimation_method);
1800  }else{
1801 no_cplx_est:
1805  }
1806 
1807  s->resync_marker= !get_bits1(gb); /* resync_marker_disabled */
1808 
1809  s->data_partitioning= get_bits1(gb);
1810  if(s->data_partitioning){
1811  s->rvlc= get_bits1(gb);
1812  }
1813 
1814  if(vo_ver_id != 1) {
1815  s->new_pred= get_bits1(gb);
1816  if(s->new_pred){
1817  av_log(s->avctx, AV_LOG_ERROR, "new pred not supported\n");
1818  skip_bits(gb, 2); /* requested upstream message type */
1819  skip_bits1(gb); /* newpred segment type */
1820  }
1821  s->reduced_res_vop= get_bits1(gb);
1822  if(s->reduced_res_vop) av_log(s->avctx, AV_LOG_ERROR, "reduced resolution VOP not supported\n");
1823  }
1824  else{
1825  s->new_pred=0;
1826  s->reduced_res_vop= 0;
1827  }
1828 
1829  s->scalability= get_bits1(gb);
1830 
1831  if (s->scalability) {
1832  GetBitContext bak= *gb;
1833  int h_sampling_factor_n;
1834  int h_sampling_factor_m;
1835  int v_sampling_factor_n;
1836  int v_sampling_factor_m;
1837 
1838  s->hierachy_type= get_bits1(gb);
1839  skip_bits(gb, 4); /* ref_layer_id */
1840  skip_bits1(gb); /* ref_layer_sampling_dir */
1841  h_sampling_factor_n= get_bits(gb, 5);
1842  h_sampling_factor_m= get_bits(gb, 5);
1843  v_sampling_factor_n= get_bits(gb, 5);
1844  v_sampling_factor_m= get_bits(gb, 5);
1845  s->enhancement_type= get_bits1(gb);
1846 
1847  if( h_sampling_factor_n==0 || h_sampling_factor_m==0
1848  || v_sampling_factor_n==0 || v_sampling_factor_m==0){
1849  /* illegal scalability header (VERY broken encoder),
1850  * trying to workaround */
1851  s->scalability=0;
1852  *gb= bak;
1853  }else
1854  av_log(s->avctx, AV_LOG_ERROR, "scalability not supported\n");
1855 
1856  // bin shape stuff FIXME
1857  }
1858  }
1859  return 0;
1860 }
1861 
1867  char buf[256];
1868  int i;
1869  int e;
1870  int ver = 0, build = 0, ver2 = 0, ver3 = 0;
1871  char last;
1872 
1873  for(i=0; i<255 && get_bits_count(gb) < gb->size_in_bits; i++){
1874  if(show_bits(gb, 23) == 0) break;
1875  buf[i]= get_bits(gb, 8);
1876  }
1877  buf[i]=0;
1878 
1879  /* divx detection */
1880  e=sscanf(buf, "DivX%dBuild%d%c", &ver, &build, &last);
1881  if(e<2)
1882  e=sscanf(buf, "DivX%db%d%c", &ver, &build, &last);
1883  if(e>=2){
1884  s->divx_version= ver;
1885  s->divx_build= build;
1886  s->divx_packed= e==3 && last=='p';
1887  if(s->divx_packed && !s->showed_packed_warning) {
1888  av_log(s->avctx, AV_LOG_WARNING, "Invalid and inefficient vfw-avi packed B frames detected\n");
1889  s->showed_packed_warning=1;
1890  }
1891  }
1892 
1893  /* libavcodec detection */
1894  e=sscanf(buf, "FFmpe%*[^b]b%d", &build)+3;
1895  if(e!=4)
1896  e=sscanf(buf, "FFmpeg v%d.%d.%d / libavcodec build: %d", &ver, &ver2, &ver3, &build);
1897  if(e!=4){
1898  e=sscanf(buf, "Lavc%d.%d.%d", &ver, &ver2, &ver3)+1;
1899  if (e>1)
1900  build= (ver<<16) + (ver2<<8) + ver3;
1901  }
1902  if(e!=4){
1903  if(strcmp(buf, "ffmpeg")==0){
1904  s->lavc_build= 4600;
1905  }
1906  }
1907  if(e==4){
1908  s->lavc_build= build;
1909  }
1910 
1911  /* Xvid detection */
1912  e=sscanf(buf, "XviD%d", &build);
1913  if(e==1){
1914  s->xvid_build= build;
1915  }
1916 
1917  return 0;
1918 }
1919 
1921  int time_incr, time_increment;
1922 
1923  s->pict_type = get_bits(gb, 2) + AV_PICTURE_TYPE_I; /* pict type: I = 0 , P = 1 */
1925  av_log(s->avctx, AV_LOG_ERROR, "low_delay flag incorrectly, clearing it\n");
1926  s->low_delay=0;
1927  }
1928 
1930  if(s->partitioned_frame)
1932  else
1934 
1935  time_incr=0;
1936  while (get_bits1(gb) != 0)
1937  time_incr++;
1938 
1939  check_marker(gb, "before time_increment");
1940 
1941  if(s->time_increment_bits==0 || !(show_bits(gb, s->time_increment_bits+1)&1)){
1942  av_log(s->avctx, AV_LOG_ERROR, "hmm, seems the headers are not complete, trying to guess time_increment_bits\n");
1943 
1945  if ( s->pict_type == AV_PICTURE_TYPE_P
1947  if((show_bits(gb, s->time_increment_bits+6)&0x37) == 0x30) break;
1948  }else
1949  if((show_bits(gb, s->time_increment_bits+5)&0x1F) == 0x18) break;
1950  }
1951 
1952  av_log(s->avctx, AV_LOG_ERROR, "my guess is %d bits ;)\n",s->time_increment_bits);
1953  }
1954 
1955  if(IS_3IV1) time_increment= get_bits1(gb); //FIXME investigate further
1956  else time_increment= get_bits(gb, s->time_increment_bits);
1957 
1958  if(s->pict_type!=AV_PICTURE_TYPE_B){
1959  s->last_time_base= s->time_base;
1960  s->time_base+= time_incr;
1961  s->time= s->time_base*s->avctx->time_base.den + time_increment;
1963  if(s->time < s->last_non_b_time){
1964  /* header is not mpeg-4-compatible, broken encoder,
1965  * trying to workaround */
1966  s->time_base++;
1967  s->time+= s->avctx->time_base.den;
1968  }
1969  }
1970  s->pp_time= s->time - s->last_non_b_time;
1971  s->last_non_b_time= s->time;
1972  }else{
1973  s->time= (s->last_time_base + time_incr)*s->avctx->time_base.den + time_increment;
1974  s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
1975  if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
1976  /* messed up order, maybe after seeking? skipping current b-frame */
1977  return FRAME_SKIPPED;
1978  }
1980 
1981  if(s->t_frame==0) s->t_frame= s->pb_time;
1982  if(s->t_frame==0) s->t_frame=1; // 1/0 protection
1984  - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
1985  s->pb_field_time= ( ROUNDED_DIV(s->time, s->t_frame)
1986  - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
1987  if(!s->progressive_sequence){
1988  if(s->pp_field_time <= s->pb_field_time || s->pb_field_time <= 1)
1989  return FRAME_SKIPPED;
1990  }
1991  }
1992 
1993  if(s->avctx->time_base.num)
1994  s->current_picture_ptr->f.pts = (s->time + s->avctx->time_base.num / 2) / s->avctx->time_base.num;
1995  else
1997  if(s->avctx->debug&FF_DEBUG_PTS)
1998  av_log(s->avctx, AV_LOG_DEBUG, "MPEG4 PTS: %"PRId64"\n",
1999  s->current_picture_ptr->f.pts);
2000 
2001  check_marker(gb, "before vop_coded");
2002 
2003  /* vop coded */
2004  if (get_bits1(gb) != 1){
2006  av_log(s->avctx, AV_LOG_ERROR, "vop not coded\n");
2007  return FRAME_SKIPPED;
2008  }
2009  if (s->shape != BIN_ONLY_SHAPE && ( s->pict_type == AV_PICTURE_TYPE_P
2011  /* rounding type for motion estimation */
2012  s->no_rounding = get_bits1(gb);
2013  } else {
2014  s->no_rounding = 0;
2015  }
2016 //FIXME reduced res stuff
2017 
2018  if (s->shape != RECT_SHAPE) {
2019  if (s->vol_sprite_usage != 1 || s->pict_type != AV_PICTURE_TYPE_I) {
2020  skip_bits(gb, 13); /* width */
2021  skip_bits1(gb); /* marker */
2022  skip_bits(gb, 13); /* height */
2023  skip_bits1(gb); /* marker */
2024  skip_bits(gb, 13); /* hor_spat_ref */
2025  skip_bits1(gb); /* marker */
2026  skip_bits(gb, 13); /* ver_spat_ref */
2027  }
2028  skip_bits1(gb); /* change_CR_disable */
2029 
2030  if (get_bits1(gb) != 0) {
2031  skip_bits(gb, 8); /* constant_alpha_value */
2032  }
2033  }
2034 //FIXME complexity estimation stuff
2035 
2036  if (s->shape != BIN_ONLY_SHAPE) {
2038  if(s->pict_type != AV_PICTURE_TYPE_I)
2040  if(s->pict_type == AV_PICTURE_TYPE_B)
2042 
2044  if(!s->progressive_sequence){
2045  s->top_field_first= get_bits1(gb);
2046  s->alternate_scan= get_bits1(gb);
2047  }else
2048  s->alternate_scan= 0;
2049  }
2050 
2051  if(s->alternate_scan){
2056  } else{
2061  }
2062 
2064  if (mpeg4_decode_sprite_trajectory(s, gb) < 0)
2065  return AVERROR_INVALIDDATA;
2066  if(s->sprite_brightness_change) av_log(s->avctx, AV_LOG_ERROR, "sprite_brightness_change not supported\n");
2067  if(s->vol_sprite_usage==STATIC_SPRITE) av_log(s->avctx, AV_LOG_ERROR, "static sprite not supported\n");
2068  }
2069 
2070  if (s->shape != BIN_ONLY_SHAPE) {
2071  s->chroma_qscale= s->qscale = get_bits(gb, s->quant_precision);
2072  if(s->qscale==0){
2073  av_log(s->avctx, AV_LOG_ERROR, "Error, header damaged or not MPEG4 header (qscale=0)\n");
2074  return -1; // makes no sense to continue, as there is nothing left from the image then
2075  }
2076 
2077  if (s->pict_type != AV_PICTURE_TYPE_I) {
2078  s->f_code = get_bits(gb, 3); /* fcode_for */
2079  if(s->f_code==0){
2080  av_log(s->avctx, AV_LOG_ERROR, "Error, header damaged or not MPEG4 header (f_code=0)\n");
2081  return -1; // makes no sense to continue, as the MV decoding will break very quickly
2082  }
2083  }else
2084  s->f_code=1;
2085 
2086  if (s->pict_type == AV_PICTURE_TYPE_B) {
2087  s->b_code = get_bits(gb, 3);
2088  }else
2089  s->b_code=1;
2090 
2091  if(s->avctx->debug&FF_DEBUG_PICT_INFO){
2092  av_log(s->avctx, AV_LOG_DEBUG, "qp:%d fc:%d,%d %s size:%d pro:%d alt:%d top:%d %spel part:%d resync:%d w:%d a:%d rnd:%d vot:%d%s dc:%d ce:%d/%d/%d\n",
2093  s->qscale, s->f_code, s->b_code,
2094  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")),
2098  }
2099 
2100  if(!s->scalability){
2101  if (s->shape!=RECT_SHAPE && s->pict_type!=AV_PICTURE_TYPE_I) {
2102  skip_bits1(gb); // vop shape coding type
2103  }
2104  }else{
2105  if(s->enhancement_type){
2106  int load_backward_shape= get_bits1(gb);
2107  if(load_backward_shape){
2108  av_log(s->avctx, AV_LOG_ERROR, "load backward shape isn't supported\n");
2109  }
2110  }
2111  skip_bits(gb, 2); //ref_select_code
2112  }
2113  }
2114  /* detect buggy encoders which don't set the low_delay flag (divx4/xvid/opendivx)*/
2115  // note we cannot detect divx5 without b-frames easily (although it's buggy too)
2116  if(s->vo_type==0 && s->vol_control_parameters==0 && s->divx_version==-1 && s->picture_number==0){
2117  av_log(s->avctx, AV_LOG_WARNING, "looks like this file was encoded with (divx4/(old)xvid/opendivx) -> forcing low_delay flag\n");
2118  s->low_delay=1;
2119  }
2120 
2121  s->picture_number++; // better than pic number==0 always ;)
2122 
2123  s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support
2125 
2127  s->h_edge_pos= s->width;
2128  s->v_edge_pos= s->height;
2129  }
2130  return 0;
2131 }
2132 
2140 {
2141  unsigned startcode, v;
2142 
2143  /* search next start code */
2144  align_get_bits(gb);
2145 
2146  if(s->codec_tag == AV_RL32("WV1F") && show_bits(gb, 24) == 0x575630){
2147  skip_bits(gb, 24);
2148  if(get_bits(gb, 8) == 0xF0)
2149  goto end;
2150  }
2151 
2152  startcode = 0xff;
2153  for(;;) {
2154  if(get_bits_count(gb) >= gb->size_in_bits){
2155  if(gb->size_in_bits==8 && (s->divx_version>=0 || s->xvid_build>=0)){
2156  av_log(s->avctx, AV_LOG_WARNING, "frame skip %d\n", gb->size_in_bits);
2157  return FRAME_SKIPPED; //divx bug
2158  }else
2159  return -1; //end of stream
2160  }
2161 
2162  /* use the bits after the test */
2163  v = get_bits(gb, 8);
2164  startcode = ((startcode << 8) | v) & 0xffffffff;
2165 
2166  if((startcode&0xFFFFFF00) != 0x100)
2167  continue; //no startcode
2168 
2169  if(s->avctx->debug&FF_DEBUG_STARTCODE){
2170  av_log(s->avctx, AV_LOG_DEBUG, "startcode: %3X ", startcode);
2171  if (startcode<=0x11F) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Start");
2172  else if(startcode<=0x12F) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Layer Start");
2173  else if(startcode<=0x13F) av_log(s->avctx, AV_LOG_DEBUG, "Reserved");
2174  else if(startcode<=0x15F) av_log(s->avctx, AV_LOG_DEBUG, "FGS bp start");
2175  else if(startcode<=0x1AF) av_log(s->avctx, AV_LOG_DEBUG, "Reserved");
2176  else if(startcode==0x1B0) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Seq Start");
2177  else if(startcode==0x1B1) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Seq End");
2178  else if(startcode==0x1B2) av_log(s->avctx, AV_LOG_DEBUG, "User Data");
2179  else if(startcode==0x1B3) av_log(s->avctx, AV_LOG_DEBUG, "Group of VOP start");
2180  else if(startcode==0x1B4) av_log(s->avctx, AV_LOG_DEBUG, "Video Session Error");
2181  else if(startcode==0x1B5) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Start");
2182  else if(startcode==0x1B6) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Plane start");
2183  else if(startcode==0x1B7) av_log(s->avctx, AV_LOG_DEBUG, "slice start");
2184  else if(startcode==0x1B8) av_log(s->avctx, AV_LOG_DEBUG, "extension start");
2185  else if(startcode==0x1B9) av_log(s->avctx, AV_LOG_DEBUG, "fgs start");
2186  else if(startcode==0x1BA) av_log(s->avctx, AV_LOG_DEBUG, "FBA Object start");
2187  else if(startcode==0x1BB) av_log(s->avctx, AV_LOG_DEBUG, "FBA Object Plane start");
2188  else if(startcode==0x1BC) av_log(s->avctx, AV_LOG_DEBUG, "Mesh Object start");
2189  else if(startcode==0x1BD) av_log(s->avctx, AV_LOG_DEBUG, "Mesh Object Plane start");
2190  else if(startcode==0x1BE) av_log(s->avctx, AV_LOG_DEBUG, "Still Texture Object start");
2191  else if(startcode==0x1BF) av_log(s->avctx, AV_LOG_DEBUG, "Texture Spatial Layer start");
2192  else if(startcode==0x1C0) av_log(s->avctx, AV_LOG_DEBUG, "Texture SNR Layer start");
2193  else if(startcode==0x1C1) av_log(s->avctx, AV_LOG_DEBUG, "Texture Tile start");
2194  else if(startcode==0x1C2) av_log(s->avctx, AV_LOG_DEBUG, "Texture Shape Layer start");
2195  else if(startcode==0x1C3) av_log(s->avctx, AV_LOG_DEBUG, "stuffing start");
2196  else if(startcode<=0x1C5) av_log(s->avctx, AV_LOG_DEBUG, "reserved");
2197  else if(startcode<=0x1FF) av_log(s->avctx, AV_LOG_DEBUG, "System start");
2198  av_log(s->avctx, AV_LOG_DEBUG, " at %d\n", get_bits_count(gb));
2199  }
2200 
2201  if(startcode >= 0x120 && startcode <= 0x12F){
2202  if(decode_vol_header(s, gb) < 0)
2203  return -1;
2204  }
2205  else if(startcode == USER_DATA_STARTCODE){
2206  decode_user_data(s, gb);
2207  }
2208  else if(startcode == GOP_STARTCODE){
2209  mpeg4_decode_gop_header(s, gb);
2210  }
2211  else if(startcode == VOS_STARTCODE){
2213  }
2214  else if(startcode == VOP_STARTCODE){
2215  break;
2216  }
2217 
2218  align_get_bits(gb);
2219  startcode = 0xff;
2220  }
2221 end:
2222  if(s->flags& CODEC_FLAG_LOW_DELAY)
2223  s->low_delay=1;
2224  s->avctx->has_b_frames= !s->low_delay;
2225  return decode_vop_header(s, gb);
2226 }
2227 
2229 {
2230  MpegEncContext *s = avctx->priv_data;
2231  int ret;
2232 
2234 
2235  s->divx_version=
2236  s->divx_build=
2237  s->xvid_build=
2238  s->lavc_build= -1;
2239 
2240  if((ret=ff_h263_decode_init(avctx)) < 0)
2241  return ret;
2242 
2243  s->h263_pred = 1;
2244  s->low_delay = 0; //default, might be overriden in the vol header during header parsing
2246  s->time_increment_bits = 4; /* default value for broken headers */
2248 
2249  return 0;
2250 }
2251 
2253  { FF_PROFILE_MPEG4_SIMPLE, "Simple Profile" },
2254  { FF_PROFILE_MPEG4_SIMPLE_SCALABLE, "Simple Scalable Profile" },
2255  { FF_PROFILE_MPEG4_CORE, "Core Profile" },
2256  { FF_PROFILE_MPEG4_MAIN, "Main Profile" },
2257  { FF_PROFILE_MPEG4_N_BIT, "N-bit Profile" },
2258  { FF_PROFILE_MPEG4_SCALABLE_TEXTURE, "Scalable Texture Profile" },
2259  { FF_PROFILE_MPEG4_SIMPLE_FACE_ANIMATION, "Simple Face Animation Profile" },
2260  { FF_PROFILE_MPEG4_BASIC_ANIMATED_TEXTURE, "Basic Animated Texture Profile" },
2261  { FF_PROFILE_MPEG4_HYBRID, "Hybrid Profile" },
2262  { FF_PROFILE_MPEG4_ADVANCED_REAL_TIME, "Advanced Real Time Simple Profile" },
2263  { FF_PROFILE_MPEG4_CORE_SCALABLE, "Code Scalable Profile" },
2264  { FF_PROFILE_MPEG4_ADVANCED_CODING, "Advanced Coding Profile" },
2265  { FF_PROFILE_MPEG4_ADVANCED_CORE, "Advanced Core Profile" },
2266  { FF_PROFILE_MPEG4_ADVANCED_SCALABLE_TEXTURE, "Advanced Scalable Texture Profile" },
2267  { FF_PROFILE_MPEG4_SIMPLE_STUDIO, "Simple Studio Profile" },
2268  { FF_PROFILE_MPEG4_ADVANCED_SIMPLE, "Advanced Simple Profile" },
2269 };
2270 
2272  .name = "mpeg4",
2273  .type = AVMEDIA_TYPE_VIDEO,
2274  .id = AV_CODEC_ID_MPEG4,
2275  .priv_data_size = sizeof(MpegEncContext),
2276  .init = decode_init,
2279  .capabilities = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 |
2282  .flush = ff_mpeg_flush,
2283  .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2"),
2284  .pix_fmts = ff_hwaccel_pixfmt_list_420,
2285  .profiles = NULL_IF_CONFIG_SMALL(mpeg4_video_profiles),
2286  .update_thread_context = ONLY_IF_THREADS_ENABLED(ff_mpeg_update_thread_context),
2287 };
2288 
2289 
2290 #if CONFIG_MPEG4_VDPAU_DECODER
2291 AVCodec ff_mpeg4_vdpau_decoder = {
2292  .name = "mpeg4_vdpau",
2293  .type = AVMEDIA_TYPE_VIDEO,
2294  .id = AV_CODEC_ID_MPEG4,
2295  .priv_data_size = sizeof(MpegEncContext),
2296  .init = decode_init,
2299  .capabilities = CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY |
2300  CODEC_CAP_HWACCEL_VDPAU,
2301  .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 (VDPAU)"),
2302  .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_VDPAU_MPEG4,
2303  AV_PIX_FMT_NONE },
2304 };
2305 #endif