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