00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023 #include "mpegvideo.h"
00024 #include "mpeg4video.h"
00025 #include "h263.h"
00026 #include "thread.h"
00027
00028
00029
00030
00031
00032 #define SPRITE_TRAJ_VLC_BITS 6
00033 #define DC_VLC_BITS 9
00034 #define MB_TYPE_B_VLC_BITS 4
00035
00036
00037 static VLC dc_lum, dc_chrom;
00038 static VLC sprite_trajectory;
00039 static VLC mb_type_b_vlc;
00040
00041 static const int mb_type_b_map[4]= {
00042 MB_TYPE_DIRECT2 | MB_TYPE_L0L1,
00043 MB_TYPE_L0L1 | MB_TYPE_16x16,
00044 MB_TYPE_L1 | MB_TYPE_16x16,
00045 MB_TYPE_L0 | MB_TYPE_16x16,
00046 };
00047
00053 void mpeg4_pred_ac(MpegEncContext * s, DCTELEM *block, int n,
00054 int dir)
00055 {
00056 int i;
00057 int16_t *ac_val, *ac_val1;
00058 int8_t * const qscale_table = s->current_picture.f.qscale_table;
00059
00060
00061 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
00062 ac_val1 = ac_val;
00063 if (s->ac_pred) {
00064 if (dir == 0) {
00065 const int xy= s->mb_x-1 + s->mb_y*s->mb_stride;
00066
00067 ac_val -= 16;
00068
00069 if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){
00070
00071 for(i=1;i<8;i++) {
00072 block[s->dsp.idct_permutation[i<<3]] += ac_val[i];
00073 }
00074 }else{
00075
00076 for(i=1;i<8;i++) {
00077 block[s->dsp.idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale);
00078 }
00079 }
00080 } else {
00081 const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride;
00082
00083 ac_val -= 16 * s->block_wrap[n];
00084
00085 if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){
00086
00087 for(i=1;i<8;i++) {
00088 block[s->dsp.idct_permutation[i]] += ac_val[i + 8];
00089 }
00090 }else{
00091
00092 for(i=1;i<8;i++) {
00093 block[s->dsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale);
00094 }
00095 }
00096 }
00097 }
00098
00099 for(i=1;i<8;i++)
00100 ac_val1[i ] = block[s->dsp.idct_permutation[i<<3]];
00101
00102
00103 for(i=1;i<8;i++)
00104 ac_val1[8 + i] = block[s->dsp.idct_permutation[i ]];
00105
00106 }
00107
00112 static inline int mpeg4_is_resync(MpegEncContext *s){
00113 int bits_count= get_bits_count(&s->gb);
00114 int v= show_bits(&s->gb, 16);
00115
00116 if(s->workaround_bugs&FF_BUG_NO_PADDING){
00117 return 0;
00118 }
00119
00120 while(v<=0xFF){
00121 if(s->pict_type==AV_PICTURE_TYPE_B || (v>>(8-s->pict_type)!=1) || s->partitioned_frame)
00122 break;
00123 skip_bits(&s->gb, 8+s->pict_type);
00124 bits_count+= 8+s->pict_type;
00125 v= show_bits(&s->gb, 16);
00126 }
00127
00128 if(bits_count + 8 >= s->gb.size_in_bits){
00129 v>>=8;
00130 v|= 0x7F >> (7-(bits_count&7));
00131
00132 if(v==0x7F)
00133 return 1;
00134 }else{
00135 if(v == ff_mpeg4_resync_prefix[bits_count&7]){
00136 int len;
00137 GetBitContext gb= s->gb;
00138
00139 skip_bits(&s->gb, 1);
00140 align_get_bits(&s->gb);
00141
00142 for(len=0; len<32; len++){
00143 if(get_bits1(&s->gb)) break;
00144 }
00145
00146 s->gb= gb;
00147
00148 if(len>=ff_mpeg4_get_video_packet_prefix_length(s))
00149 return 1;
00150 }
00151 }
00152 return 0;
00153 }
00154
00155 static int mpeg4_decode_sprite_trajectory(MpegEncContext *s, GetBitContext *gb)
00156 {
00157 int i;
00158 int a= 2<<s->sprite_warping_accuracy;
00159 int rho= 3-s->sprite_warping_accuracy;
00160 int r=16/a;
00161 const int vop_ref[4][2]= {{0,0}, {s->width,0}, {0, s->height}, {s->width, s->height}};
00162 int d[4][2]={{0,0}, {0,0}, {0,0}, {0,0}};
00163 int sprite_ref[4][2];
00164 int virtual_ref[2][2];
00165 int w2, h2, w3, h3;
00166 int alpha=0, beta=0;
00167 int w= s->width;
00168 int h= s->height;
00169 int min_ab;
00170
00171 if (w <= 0 || h <= 0)
00172 return AVERROR_INVALIDDATA;
00173
00174 for(i=0; i<s->num_sprite_warping_points; i++){
00175 int length;
00176 int x=0, y=0;
00177
00178 length= get_vlc2(gb, sprite_trajectory.table, SPRITE_TRAJ_VLC_BITS, 3);
00179 if(length){
00180 x= get_xbits(gb, length);
00181 }
00182 if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(gb);
00183
00184 length= get_vlc2(gb, sprite_trajectory.table, SPRITE_TRAJ_VLC_BITS, 3);
00185 if(length){
00186 y=get_xbits(gb, length);
00187 }
00188 skip_bits1(gb);
00189 s->sprite_traj[i][0]= d[i][0]= x;
00190 s->sprite_traj[i][1]= d[i][1]= y;
00191 }
00192 for(; i<4; i++)
00193 s->sprite_traj[i][0]= s->sprite_traj[i][1]= 0;
00194
00195 while((1<<alpha)<w) alpha++;
00196 while((1<<beta )<h) beta++;
00197 w2= 1<<alpha;
00198 h2= 1<<beta;
00199
00200
00201 if(s->divx_version==500 && s->divx_build==413){
00202 sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0];
00203 sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1];
00204 sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0];
00205 sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1];
00206 sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0];
00207 sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1];
00208 } else {
00209 sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]);
00210 sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]);
00211 sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]);
00212 sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]);
00213 sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]);
00214 sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]);
00215 }
00216
00217
00218
00219
00220
00221
00222
00223 virtual_ref[0][0]= 16*(vop_ref[0][0] + w2)
00224 + 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);
00225 virtual_ref[0][1]= 16*vop_ref[0][1]
00226 + 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);
00227 virtual_ref[1][0]= 16*vop_ref[0][0]
00228 + 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);
00229 virtual_ref[1][1]= 16*(vop_ref[0][1] + h2)
00230 + 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);
00231
00232 switch(s->num_sprite_warping_points)
00233 {
00234 case 0:
00235 s->sprite_offset[0][0]= 0;
00236 s->sprite_offset[0][1]= 0;
00237 s->sprite_offset[1][0]= 0;
00238 s->sprite_offset[1][1]= 0;
00239 s->sprite_delta[0][0]= a;
00240 s->sprite_delta[0][1]= 0;
00241 s->sprite_delta[1][0]= 0;
00242 s->sprite_delta[1][1]= a;
00243 s->sprite_shift[0]= 0;
00244 s->sprite_shift[1]= 0;
00245 break;
00246 case 1:
00247 s->sprite_offset[0][0]= sprite_ref[0][0] - a*vop_ref[0][0];
00248 s->sprite_offset[0][1]= sprite_ref[0][1] - a*vop_ref[0][1];
00249 s->sprite_offset[1][0]= ((sprite_ref[0][0]>>1)|(sprite_ref[0][0]&1)) - a*(vop_ref[0][0]/2);
00250 s->sprite_offset[1][1]= ((sprite_ref[0][1]>>1)|(sprite_ref[0][1]&1)) - a*(vop_ref[0][1]/2);
00251 s->sprite_delta[0][0]= a;
00252 s->sprite_delta[0][1]= 0;
00253 s->sprite_delta[1][0]= 0;
00254 s->sprite_delta[1][1]= a;
00255 s->sprite_shift[0]= 0;
00256 s->sprite_shift[1]= 0;
00257 break;
00258 case 2:
00259 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho))
00260 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0])
00261 + ( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1])
00262 + (1<<(alpha+rho-1));
00263 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho))
00264 + (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0])
00265 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1])
00266 + (1<<(alpha+rho-1));
00267 s->sprite_offset[1][0]= ( (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][0] + 1)
00268 +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-2*vop_ref[0][1] + 1)
00269 +2*w2*r*sprite_ref[0][0]
00270 - 16*w2
00271 + (1<<(alpha+rho+1)));
00272 s->sprite_offset[1][1]= ( (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-2*vop_ref[0][0] + 1)
00273 +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][1] + 1)
00274 +2*w2*r*sprite_ref[0][1]
00275 - 16*w2
00276 + (1<<(alpha+rho+1)));
00277 s->sprite_delta[0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0]);
00278 s->sprite_delta[0][1]= (+r*sprite_ref[0][1] - virtual_ref[0][1]);
00279 s->sprite_delta[1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1]);
00280 s->sprite_delta[1][1]= (-r*sprite_ref[0][0] + virtual_ref[0][0]);
00281
00282 s->sprite_shift[0]= alpha+rho;
00283 s->sprite_shift[1]= alpha+rho+2;
00284 break;
00285 case 3:
00286 min_ab= FFMIN(alpha, beta);
00287 w3= w2>>min_ab;
00288 h3= h2>>min_ab;
00289 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+beta+rho-min_ab))
00290 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-vop_ref[0][0])
00291 + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-vop_ref[0][1])
00292 + (1<<(alpha+beta+rho-min_ab-1));
00293 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+beta+rho-min_ab))
00294 + (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-vop_ref[0][0])
00295 + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-vop_ref[0][1])
00296 + (1<<(alpha+beta+rho-min_ab-1));
00297 s->sprite_offset[1][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-2*vop_ref[0][0] + 1)
00298 + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-2*vop_ref[0][1] + 1)
00299 + 2*w2*h3*r*sprite_ref[0][0]
00300 - 16*w2*h3
00301 + (1<<(alpha+beta+rho-min_ab+1));
00302 s->sprite_offset[1][1]= (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-2*vop_ref[0][0] + 1)
00303 + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-2*vop_ref[0][1] + 1)
00304 + 2*w2*h3*r*sprite_ref[0][1]
00305 - 16*w2*h3
00306 + (1<<(alpha+beta+rho-min_ab+1));
00307 s->sprite_delta[0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3;
00308 s->sprite_delta[0][1]= (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3;
00309 s->sprite_delta[1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3;
00310 s->sprite_delta[1][1]= (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3;
00311
00312 s->sprite_shift[0]= alpha + beta + rho - min_ab;
00313 s->sprite_shift[1]= alpha + beta + rho - min_ab + 2;
00314 break;
00315 }
00316
00317 if( s->sprite_delta[0][0] == a<<s->sprite_shift[0]
00318 && s->sprite_delta[0][1] == 0
00319 && s->sprite_delta[1][0] == 0
00320 && s->sprite_delta[1][1] == a<<s->sprite_shift[0])
00321 {
00322 s->sprite_offset[0][0]>>=s->sprite_shift[0];
00323 s->sprite_offset[0][1]>>=s->sprite_shift[0];
00324 s->sprite_offset[1][0]>>=s->sprite_shift[1];
00325 s->sprite_offset[1][1]>>=s->sprite_shift[1];
00326 s->sprite_delta[0][0]= a;
00327 s->sprite_delta[0][1]= 0;
00328 s->sprite_delta[1][0]= 0;
00329 s->sprite_delta[1][1]= a;
00330 s->sprite_shift[0]= 0;
00331 s->sprite_shift[1]= 0;
00332 s->real_sprite_warping_points=1;
00333 }
00334 else{
00335 int shift_y= 16 - s->sprite_shift[0];
00336 int shift_c= 16 - s->sprite_shift[1];
00337 for(i=0; i<2; i++){
00338 s->sprite_offset[0][i]<<= shift_y;
00339 s->sprite_offset[1][i]<<= shift_c;
00340 s->sprite_delta[0][i]<<= shift_y;
00341 s->sprite_delta[1][i]<<= shift_y;
00342 s->sprite_shift[i]= 16;
00343 }
00344 s->real_sprite_warping_points= s->num_sprite_warping_points;
00345 }
00346 return 0;
00347 }
00348
00353 int mpeg4_decode_video_packet_header(MpegEncContext *s)
00354 {
00355 int mb_num_bits= av_log2(s->mb_num - 1) + 1;
00356 int header_extension=0, mb_num, len;
00357
00358
00359 if( get_bits_count(&s->gb) > s->gb.size_in_bits-20) return -1;
00360
00361 for(len=0; len<32; len++){
00362 if(get_bits1(&s->gb)) break;
00363 }
00364
00365 if(len!=ff_mpeg4_get_video_packet_prefix_length(s)){
00366 av_log(s->avctx, AV_LOG_ERROR, "marker does not match f_code\n");
00367 return -1;
00368 }
00369
00370 if(s->shape != RECT_SHAPE){
00371 header_extension= get_bits1(&s->gb);
00372
00373 }
00374
00375 mb_num= get_bits(&s->gb, mb_num_bits);
00376 if(mb_num>=s->mb_num){
00377 av_log(s->avctx, AV_LOG_ERROR, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num);
00378 return -1;
00379 }
00380 if(s->pict_type == AV_PICTURE_TYPE_B){
00381 int mb_x = 0, mb_y = 0;
00382
00383 while (s->next_picture.f.mbskip_table[s->mb_index2xy[mb_num]]) {
00384 if (!mb_x) ff_thread_await_progress((AVFrame*)s->next_picture_ptr, mb_y++, 0);
00385 mb_num++;
00386 if (++mb_x == s->mb_width) mb_x = 0;
00387 }
00388 if(mb_num >= s->mb_num) return -1;
00389 }
00390
00391 s->mb_x= mb_num % s->mb_width;
00392 s->mb_y= mb_num / s->mb_width;
00393
00394 if(s->shape != BIN_ONLY_SHAPE){
00395 int qscale= get_bits(&s->gb, s->quant_precision);
00396 if(qscale)
00397 s->chroma_qscale=s->qscale= qscale;
00398 }
00399
00400 if(s->shape == RECT_SHAPE){
00401 header_extension= get_bits1(&s->gb);
00402 }
00403 if(header_extension){
00404 int time_incr=0;
00405
00406 while (get_bits1(&s->gb) != 0)
00407 time_incr++;
00408
00409 check_marker(&s->gb, "before time_increment in video packed header");
00410 skip_bits(&s->gb, s->time_increment_bits);
00411 check_marker(&s->gb, "before vop_coding_type in video packed header");
00412
00413 skip_bits(&s->gb, 2);
00414
00415
00416 if(s->shape != BIN_ONLY_SHAPE){
00417 skip_bits(&s->gb, 3);
00418
00419 if(s->pict_type == AV_PICTURE_TYPE_S && s->vol_sprite_usage==GMC_SPRITE){
00420 if (mpeg4_decode_sprite_trajectory(s, &s->gb) < 0)
00421 return AVERROR_INVALIDDATA;
00422 av_log(s->avctx, AV_LOG_ERROR, "untested\n");
00423 }
00424
00425
00426
00427 if (s->pict_type != AV_PICTURE_TYPE_I) {
00428 int f_code = get_bits(&s->gb, 3);
00429 if(f_code==0){
00430 av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (f_code=0)\n");
00431 }
00432 }
00433 if (s->pict_type == AV_PICTURE_TYPE_B) {
00434 int b_code = get_bits(&s->gb, 3);
00435 if(b_code==0){
00436 av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (b_code=0)\n");
00437 }
00438 }
00439 }
00440 }
00441
00442
00443 return 0;
00444 }
00445
00451 static inline int get_amv(MpegEncContext *s, int n){
00452 int x, y, mb_v, sum, dx, dy, shift;
00453 int len = 1 << (s->f_code + 4);
00454 const int a= s->sprite_warping_accuracy;
00455
00456 if(s->workaround_bugs & FF_BUG_AMV)
00457 len >>= s->quarter_sample;
00458
00459 if(s->real_sprite_warping_points==1){
00460 if(s->divx_version==500 && s->divx_build==413)
00461 sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample));
00462 else
00463 sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a);
00464 }else{
00465 dx= s->sprite_delta[n][0];
00466 dy= s->sprite_delta[n][1];
00467 shift= s->sprite_shift[0];
00468 if(n) dy -= 1<<(shift + a + 1);
00469 else dx -= 1<<(shift + a + 1);
00470 mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16;
00471
00472 sum=0;
00473 for(y=0; y<16; y++){
00474 int v;
00475
00476 v= mb_v + dy*y;
00477
00478 for(x=0; x<16; x++){
00479 sum+= v>>shift;
00480 v+= dx;
00481 }
00482 }
00483 sum= RSHIFT(sum, a+8-s->quarter_sample);
00484 }
00485
00486 if (sum < -len) sum= -len;
00487 else if (sum >= len) sum= len-1;
00488
00489 return sum;
00490 }
00491
00498 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
00499 {
00500 int level, code;
00501
00502 if (n < 4)
00503 code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1);
00504 else
00505 code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1);
00506 if (code < 0 || code > 9 ){
00507 av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
00508 return -1;
00509 }
00510 if (code == 0) {
00511 level = 0;
00512 } else {
00513 if(IS_3IV1){
00514 if(code==1)
00515 level= 2*get_bits1(&s->gb)-1;
00516 else{
00517 if(get_bits1(&s->gb))
00518 level = get_bits(&s->gb, code-1) + (1<<(code-1));
00519 else
00520 level = -get_bits(&s->gb, code-1) - (1<<(code-1));
00521 }
00522 }else{
00523 level = get_xbits(&s->gb, code);
00524 }
00525
00526 if (code > 8){
00527 if(get_bits1(&s->gb)==0){
00528 if(s->err_recognition&AV_EF_BITSTREAM){
00529 av_log(s->avctx, AV_LOG_ERROR, "dc marker bit missing\n");
00530 return -1;
00531 }
00532 }
00533 }
00534 }
00535
00536 return ff_mpeg4_pred_dc(s, n, level, dir_ptr, 0);
00537 }
00538
00543 static int mpeg4_decode_partition_a(MpegEncContext *s){
00544 int mb_num;
00545 static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
00546
00547
00548 mb_num=0;
00549 s->first_slice_line=1;
00550 for(; s->mb_y<s->mb_height; s->mb_y++){
00551 ff_init_block_index(s);
00552 for(; s->mb_x<s->mb_width; s->mb_x++){
00553 const int xy= s->mb_x + s->mb_y*s->mb_stride;
00554 int cbpc;
00555 int dir=0;
00556
00557 mb_num++;
00558 ff_update_block_index(s);
00559 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
00560 s->first_slice_line=0;
00561
00562 if(s->pict_type==AV_PICTURE_TYPE_I){
00563 int i;
00564
00565 do{
00566 if(show_bits_long(&s->gb, 19)==DC_MARKER){
00567 return mb_num-1;
00568 }
00569
00570 cbpc = get_vlc2(&s->gb, ff_h263_intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
00571 if (cbpc < 0){
00572 av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
00573 return -1;
00574 }
00575 }while(cbpc == 8);
00576
00577 s->cbp_table[xy]= cbpc & 3;
00578 s->current_picture.f.mb_type[xy] = MB_TYPE_INTRA;
00579 s->mb_intra = 1;
00580
00581 if(cbpc & 4) {
00582 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
00583 }
00584 s->current_picture.f.qscale_table[xy]= s->qscale;
00585
00586 s->mbintra_table[xy]= 1;
00587 for(i=0; i<6; i++){
00588 int dc_pred_dir;
00589 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
00590 if(dc < 0){
00591 av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
00592 return -1;
00593 }
00594 dir<<=1;
00595 if(dc_pred_dir) dir|=1;
00596 }
00597 s->pred_dir_table[xy]= dir;
00598 }else{
00599 int mx, my, pred_x, pred_y, bits;
00600 int16_t * const mot_val = s->current_picture.f.motion_val[0][s->block_index[0]];
00601 const int stride= s->b8_stride*2;
00602
00603 try_again:
00604 bits= show_bits(&s->gb, 17);
00605 if(bits==MOTION_MARKER){
00606 return mb_num-1;
00607 }
00608 skip_bits1(&s->gb);
00609 if(bits&0x10000){
00610
00611 if(s->pict_type==AV_PICTURE_TYPE_S && s->vol_sprite_usage==GMC_SPRITE){
00612 s->current_picture.f.mb_type[xy] = MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
00613 mx= get_amv(s, 0);
00614 my= get_amv(s, 1);
00615 }else{
00616 s->current_picture.f.mb_type[xy] = MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
00617 mx=my=0;
00618 }
00619 mot_val[0 ]= mot_val[2 ]=
00620 mot_val[0+stride]= mot_val[2+stride]= mx;
00621 mot_val[1 ]= mot_val[3 ]=
00622 mot_val[1+stride]= mot_val[3+stride]= my;
00623
00624 if(s->mbintra_table[xy])
00625 ff_clean_intra_table_entries(s);
00626 continue;
00627 }
00628
00629 cbpc = get_vlc2(&s->gb, ff_h263_inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
00630 if (cbpc < 0){
00631 av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
00632 return -1;
00633 }
00634 if(cbpc == 20)
00635 goto try_again;
00636
00637 s->cbp_table[xy]= cbpc&(8+3);
00638
00639 s->mb_intra = ((cbpc & 4) != 0);
00640
00641 if(s->mb_intra){
00642 s->current_picture.f.mb_type[xy] = MB_TYPE_INTRA;
00643 s->mbintra_table[xy]= 1;
00644 mot_val[0 ]= mot_val[2 ]=
00645 mot_val[0+stride]= mot_val[2+stride]= 0;
00646 mot_val[1 ]= mot_val[3 ]=
00647 mot_val[1+stride]= mot_val[3+stride]= 0;
00648 }else{
00649 if(s->mbintra_table[xy])
00650 ff_clean_intra_table_entries(s);
00651
00652 if(s->pict_type==AV_PICTURE_TYPE_S && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
00653 s->mcsel= get_bits1(&s->gb);
00654 else s->mcsel= 0;
00655
00656 if ((cbpc & 16) == 0) {
00657
00658
00659 ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
00660 if(!s->mcsel){
00661 mx = ff_h263_decode_motion(s, pred_x, s->f_code);
00662 if (mx >= 0xffff)
00663 return -1;
00664
00665 my = ff_h263_decode_motion(s, pred_y, s->f_code);
00666 if (my >= 0xffff)
00667 return -1;
00668 s->current_picture.f.mb_type[xy] = MB_TYPE_16x16 | MB_TYPE_L0;
00669 } else {
00670 mx = get_amv(s, 0);
00671 my = get_amv(s, 1);
00672 s->current_picture.f.mb_type[xy] = MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0;
00673 }
00674
00675 mot_val[0 ]= mot_val[2 ] =
00676 mot_val[0+stride]= mot_val[2+stride]= mx;
00677 mot_val[1 ]= mot_val[3 ]=
00678 mot_val[1+stride]= mot_val[3+stride]= my;
00679 } else {
00680 int i;
00681 s->current_picture.f.mb_type[xy] = MB_TYPE_8x8 | MB_TYPE_L0;
00682 for(i=0;i<4;i++) {
00683 int16_t *mot_val= ff_h263_pred_motion(s, i, 0, &pred_x, &pred_y);
00684 mx = ff_h263_decode_motion(s, pred_x, s->f_code);
00685 if (mx >= 0xffff)
00686 return -1;
00687
00688 my = ff_h263_decode_motion(s, pred_y, s->f_code);
00689 if (my >= 0xffff)
00690 return -1;
00691 mot_val[0] = mx;
00692 mot_val[1] = my;
00693 }
00694 }
00695 }
00696 }
00697 }
00698 s->mb_x= 0;
00699 }
00700
00701 return mb_num;
00702 }
00703
00708 static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count){
00709 int mb_num=0;
00710 static const int8_t quant_tab[4] = { -1, -2, 1, 2 };
00711
00712 s->mb_x= s->resync_mb_x;
00713 s->first_slice_line=1;
00714 for(s->mb_y= s->resync_mb_y; mb_num < mb_count; s->mb_y++){
00715 ff_init_block_index(s);
00716 for(; mb_num < mb_count && s->mb_x<s->mb_width; s->mb_x++){
00717 const int xy= s->mb_x + s->mb_y*s->mb_stride;
00718
00719 mb_num++;
00720 ff_update_block_index(s);
00721 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
00722 s->first_slice_line=0;
00723
00724 if(s->pict_type==AV_PICTURE_TYPE_I){
00725 int ac_pred= get_bits1(&s->gb);
00726 int cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
00727 if(cbpy<0){
00728 av_log(s->avctx, AV_LOG_ERROR, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
00729 return -1;
00730 }
00731
00732 s->cbp_table[xy]|= cbpy<<2;
00733 s->current_picture.f.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
00734 }else{
00735 if (IS_INTRA(s->current_picture.f.mb_type[xy])) {
00736 int dir=0,i;
00737 int ac_pred = get_bits1(&s->gb);
00738 int cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
00739
00740 if(cbpy<0){
00741 av_log(s->avctx, AV_LOG_ERROR, "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
00742 return -1;
00743 }
00744
00745 if(s->cbp_table[xy] & 8) {
00746 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
00747 }
00748 s->current_picture.f.qscale_table[xy] = s->qscale;
00749
00750 for(i=0; i<6; i++){
00751 int dc_pred_dir;
00752 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
00753 if(dc < 0){
00754 av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
00755 return -1;
00756 }
00757 dir<<=1;
00758 if(dc_pred_dir) dir|=1;
00759 }
00760 s->cbp_table[xy]&= 3;
00761 s->cbp_table[xy]|= cbpy<<2;
00762 s->current_picture.f.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED;
00763 s->pred_dir_table[xy]= dir;
00764 } else if (IS_SKIP(s->current_picture.f.mb_type[xy])) {
00765 s->current_picture.f.qscale_table[xy] = s->qscale;
00766 s->cbp_table[xy]= 0;
00767 }else{
00768 int cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
00769
00770 if(cbpy<0){
00771 av_log(s->avctx, AV_LOG_ERROR, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
00772 return -1;
00773 }
00774
00775 if(s->cbp_table[xy] & 8) {
00776 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
00777 }
00778 s->current_picture.f.qscale_table[xy] = s->qscale;
00779
00780 s->cbp_table[xy]&= 3;
00781 s->cbp_table[xy]|= (cbpy^0xf)<<2;
00782 }
00783 }
00784 }
00785 if(mb_num >= mb_count) return 0;
00786 s->mb_x= 0;
00787 }
00788 return 0;
00789 }
00790
00795 int ff_mpeg4_decode_partitions(MpegEncContext *s)
00796 {
00797 int mb_num;
00798 const int part_a_error= s->pict_type==AV_PICTURE_TYPE_I ? (ER_DC_ERROR|ER_MV_ERROR) : ER_MV_ERROR;
00799 const int part_a_end = s->pict_type==AV_PICTURE_TYPE_I ? (ER_DC_END |ER_MV_END) : ER_MV_END;
00800
00801 mb_num= mpeg4_decode_partition_a(s);
00802 if(mb_num<0){
00803 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
00804 return -1;
00805 }
00806
00807 if(s->resync_mb_x + s->resync_mb_y*s->mb_width + mb_num > s->mb_num){
00808 av_log(s->avctx, AV_LOG_ERROR, "slice below monitor ...\n");
00809 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error);
00810 return -1;
00811 }
00812
00813 s->mb_num_left= mb_num;
00814
00815 if(s->pict_type==AV_PICTURE_TYPE_I){
00816 while(show_bits(&s->gb, 9) == 1)
00817 skip_bits(&s->gb, 9);
00818 if(get_bits_long(&s->gb, 19)!=DC_MARKER){
00819 av_log(s->avctx, AV_LOG_ERROR, "marker missing after first I partition at %d %d\n", s->mb_x, s->mb_y);
00820 return -1;
00821 }
00822 }else{
00823 while(show_bits(&s->gb, 10) == 1)
00824 skip_bits(&s->gb, 10);
00825 if(get_bits(&s->gb, 17)!=MOTION_MARKER){
00826 av_log(s->avctx, AV_LOG_ERROR, "marker missing after first P partition at %d %d\n", s->mb_x, s->mb_y);
00827 return -1;
00828 }
00829 }
00830 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, part_a_end);
00831
00832 if( mpeg4_decode_partition_b(s, mb_num) < 0){
00833 if(s->pict_type==AV_PICTURE_TYPE_P)
00834 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, ER_DC_ERROR);
00835 return -1;
00836 }else{
00837 if(s->pict_type==AV_PICTURE_TYPE_P)
00838 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, ER_DC_END);
00839 }
00840
00841 return 0;
00842 }
00843
00848 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
00849 int n, int coded, int intra, int rvlc)
00850 {
00851 int level, i, last, run;
00852 int dc_pred_dir;
00853 RLTable * rl;
00854 RL_VLC_ELEM * rl_vlc;
00855 const uint8_t * scan_table;
00856 int qmul, qadd;
00857
00858
00859
00860 if(intra) {
00861 if(s->use_intra_dc_vlc){
00862
00863 if(s->partitioned_frame){
00864 level = s->dc_val[0][ s->block_index[n] ];
00865 if(n<4) level= FASTDIV((level + (s->y_dc_scale>>1)), s->y_dc_scale);
00866 else level= FASTDIV((level + (s->c_dc_scale>>1)), s->c_dc_scale);
00867 dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_stride]<<n)&32;
00868 }else{
00869 level = mpeg4_decode_dc(s, n, &dc_pred_dir);
00870 if (level < 0)
00871 return -1;
00872 }
00873 block[0] = level;
00874 i = 0;
00875 }else{
00876 i = -1;
00877 ff_mpeg4_pred_dc(s, n, 0, &dc_pred_dir, 0);
00878 }
00879 if (!coded)
00880 goto not_coded;
00881
00882 if(rvlc){
00883 rl = &rvlc_rl_intra;
00884 rl_vlc = rvlc_rl_intra.rl_vlc[0];
00885 }else{
00886 rl = &ff_mpeg4_rl_intra;
00887 rl_vlc = ff_mpeg4_rl_intra.rl_vlc[0];
00888 }
00889 if (s->ac_pred) {
00890 if (dc_pred_dir == 0)
00891 scan_table = s->intra_v_scantable.permutated;
00892 else
00893 scan_table = s->intra_h_scantable.permutated;
00894 } else {
00895 scan_table = s->intra_scantable.permutated;
00896 }
00897 qmul=1;
00898 qadd=0;
00899 } else {
00900 i = -1;
00901 if (!coded) {
00902 s->block_last_index[n] = i;
00903 return 0;
00904 }
00905 if(rvlc) rl = &rvlc_rl_inter;
00906 else rl = &ff_h263_rl_inter;
00907
00908 scan_table = s->intra_scantable.permutated;
00909
00910 if(s->mpeg_quant){
00911 qmul=1;
00912 qadd=0;
00913 if(rvlc){
00914 rl_vlc = rvlc_rl_inter.rl_vlc[0];
00915 }else{
00916 rl_vlc = ff_h263_rl_inter.rl_vlc[0];
00917 }
00918 }else{
00919 qmul = s->qscale << 1;
00920 qadd = (s->qscale - 1) | 1;
00921 if(rvlc){
00922 rl_vlc = rvlc_rl_inter.rl_vlc[s->qscale];
00923 }else{
00924 rl_vlc = ff_h263_rl_inter.rl_vlc[s->qscale];
00925 }
00926 }
00927 }
00928 {
00929 OPEN_READER(re, &s->gb);
00930 for(;;) {
00931 UPDATE_CACHE(re, &s->gb);
00932 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
00933 if (level==0) {
00934
00935 if(rvlc){
00936 if(SHOW_UBITS(re, &s->gb, 1)==0){
00937 av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in rvlc esc\n");
00938 return -1;
00939 }; SKIP_CACHE(re, &s->gb, 1);
00940
00941 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
00942 run= SHOW_UBITS(re, &s->gb, 6);
00943 SKIP_COUNTER(re, &s->gb, 1+1+6);
00944 UPDATE_CACHE(re, &s->gb);
00945
00946 if(SHOW_UBITS(re, &s->gb, 1)==0){
00947 av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in rvlc esc\n");
00948 return -1;
00949 }; SKIP_CACHE(re, &s->gb, 1);
00950
00951 level= SHOW_UBITS(re, &s->gb, 11); SKIP_CACHE(re, &s->gb, 11);
00952
00953 if(SHOW_UBITS(re, &s->gb, 5)!=0x10){
00954 av_log(s->avctx, AV_LOG_ERROR, "reverse esc missing\n");
00955 return -1;
00956 }; SKIP_CACHE(re, &s->gb, 5);
00957
00958 level= level * qmul + qadd;
00959 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
00960 SKIP_COUNTER(re, &s->gb, 1+11+5+1);
00961
00962 i+= run + 1;
00963 if(last) i+=192;
00964 }else{
00965 int cache;
00966 cache= GET_CACHE(re, &s->gb);
00967
00968 if(IS_3IV1)
00969 cache ^= 0xC0000000;
00970
00971 if (cache&0x80000000) {
00972 if (cache&0x40000000) {
00973
00974 SKIP_CACHE(re, &s->gb, 2);
00975 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
00976 run= SHOW_UBITS(re, &s->gb, 6);
00977 SKIP_COUNTER(re, &s->gb, 2+1+6);
00978 UPDATE_CACHE(re, &s->gb);
00979
00980 if(IS_3IV1){
00981 level= SHOW_SBITS(re, &s->gb, 12); LAST_SKIP_BITS(re, &s->gb, 12);
00982 }else{
00983 if(SHOW_UBITS(re, &s->gb, 1)==0){
00984 av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in 3. esc\n");
00985 return -1;
00986 }; SKIP_CACHE(re, &s->gb, 1);
00987
00988 level= SHOW_SBITS(re, &s->gb, 12); SKIP_CACHE(re, &s->gb, 12);
00989
00990 if(SHOW_UBITS(re, &s->gb, 1)==0){
00991 av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in 3. esc\n");
00992 return -1;
00993 }
00994
00995 SKIP_COUNTER(re, &s->gb, 1+12+1);
00996 }
00997
00998 if (level>0) level= level * qmul + qadd;
00999 else level= level * qmul - qadd;
01000
01001 if((unsigned)(level + 2048) > 4095){
01002 if(s->err_recognition & AV_EF_BITSTREAM){
01003 if(level > 2560 || level<-2560){
01004 av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc, qp=%d\n", s->qscale);
01005 return -1;
01006 }
01007 }
01008 level= level<0 ? -2048 : 2047;
01009 }
01010
01011 i+= run + 1;
01012 if(last) i+=192;
01013 } else {
01014
01015 SKIP_BITS(re, &s->gb, 2);
01016 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
01017 i+= run + rl->max_run[run>>7][level/qmul] +1;
01018 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
01019 LAST_SKIP_BITS(re, &s->gb, 1);
01020 }
01021 } else {
01022
01023 SKIP_BITS(re, &s->gb, 1);
01024 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
01025 i+= run;
01026 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;
01027 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
01028 LAST_SKIP_BITS(re, &s->gb, 1);
01029 }
01030 }
01031 } else {
01032 i+= run;
01033 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
01034 LAST_SKIP_BITS(re, &s->gb, 1);
01035 }
01036 if (i > 62){
01037 i-= 192;
01038 if(i&(~63)){
01039 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
01040 return -1;
01041 }
01042
01043 block[scan_table[i]] = level;
01044 break;
01045 }
01046
01047 block[scan_table[i]] = level;
01048 }
01049 CLOSE_READER(re, &s->gb);
01050 }
01051 not_coded:
01052 if (intra) {
01053 if(!s->use_intra_dc_vlc){
01054 block[0] = ff_mpeg4_pred_dc(s, n, block[0], &dc_pred_dir, 0);
01055
01056 i -= i>>31;
01057 }
01058
01059 mpeg4_pred_ac(s, block, n, dc_pred_dir);
01060 if (s->ac_pred) {
01061 i = 63;
01062 }
01063 }
01064 s->block_last_index[n] = i;
01065 return 0;
01066 }
01067
01072 static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64])
01073 {
01074 int cbp, mb_type;
01075 const int xy= s->mb_x + s->mb_y*s->mb_stride;
01076
01077 mb_type = s->current_picture.f.mb_type[xy];
01078 cbp = s->cbp_table[xy];
01079
01080 s->use_intra_dc_vlc= s->qscale < s->intra_dc_threshold;
01081
01082 if (s->current_picture.f.qscale_table[xy] != s->qscale) {
01083 ff_set_qscale(s, s->current_picture.f.qscale_table[xy]);
01084 }
01085
01086 if (s->pict_type == AV_PICTURE_TYPE_P || s->pict_type==AV_PICTURE_TYPE_S) {
01087 int i;
01088 for(i=0; i<4; i++){
01089 s->mv[0][i][0] = s->current_picture.f.motion_val[0][s->block_index[i]][0];
01090 s->mv[0][i][1] = s->current_picture.f.motion_val[0][s->block_index[i]][1];
01091 }
01092 s->mb_intra = IS_INTRA(mb_type);
01093
01094 if (IS_SKIP(mb_type)) {
01095
01096 for(i=0;i<6;i++)
01097 s->block_last_index[i] = -1;
01098 s->mv_dir = MV_DIR_FORWARD;
01099 s->mv_type = MV_TYPE_16X16;
01100 if(s->pict_type==AV_PICTURE_TYPE_S && s->vol_sprite_usage==GMC_SPRITE){
01101 s->mcsel=1;
01102 s->mb_skipped = 0;
01103 }else{
01104 s->mcsel=0;
01105 s->mb_skipped = 1;
01106 }
01107 }else if(s->mb_intra){
01108 s->ac_pred = IS_ACPRED(s->current_picture.f.mb_type[xy]);
01109 }else if(!s->mb_intra){
01110
01111
01112 s->mv_dir = MV_DIR_FORWARD;
01113 if (IS_8X8(mb_type)) {
01114 s->mv_type = MV_TYPE_8X8;
01115 } else {
01116 s->mv_type = MV_TYPE_16X16;
01117 }
01118 }
01119 } else {
01120 s->mb_intra = 1;
01121 s->ac_pred = IS_ACPRED(s->current_picture.f.mb_type[xy]);
01122 }
01123
01124 if (!IS_SKIP(mb_type)) {
01125 int i;
01126 s->dsp.clear_blocks(s->block[0]);
01127
01128 for (i = 0; i < 6; i++) {
01129 if(mpeg4_decode_block(s, block[i], i, cbp&32, s->mb_intra, s->rvlc) < 0){
01130 av_log(s->avctx, AV_LOG_ERROR, "texture corrupted at %d %d %d\n", s->mb_x, s->mb_y, s->mb_intra);
01131 return -1;
01132 }
01133 cbp+=cbp;
01134 }
01135 }
01136
01137
01138
01139 if(--s->mb_num_left <= 0){
01140 if(mpeg4_is_resync(s))
01141 return SLICE_END;
01142 else
01143 return SLICE_NOEND;
01144 }else{
01145 if(mpeg4_is_resync(s)){
01146 const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
01147 if(s->cbp_table[xy+delta])
01148 return SLICE_END;
01149 }
01150 return SLICE_OK;
01151 }
01152 }
01153
01154 static int mpeg4_decode_mb(MpegEncContext *s,
01155 DCTELEM block[6][64])
01156 {
01157 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
01158 int16_t *mot_val;
01159 static int8_t quant_tab[4] = { -1, -2, 1, 2 };
01160 const int xy= s->mb_x + s->mb_y * s->mb_stride;
01161
01162 assert(s->h263_pred);
01163
01164 if (s->pict_type == AV_PICTURE_TYPE_P || s->pict_type==AV_PICTURE_TYPE_S) {
01165 do{
01166 if (get_bits1(&s->gb)) {
01167
01168 s->mb_intra = 0;
01169 for(i=0;i<6;i++)
01170 s->block_last_index[i] = -1;
01171 s->mv_dir = MV_DIR_FORWARD;
01172 s->mv_type = MV_TYPE_16X16;
01173 if(s->pict_type==AV_PICTURE_TYPE_S && s->vol_sprite_usage==GMC_SPRITE){
01174 s->current_picture.f.mb_type[xy] = MB_TYPE_SKIP | MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
01175 s->mcsel=1;
01176 s->mv[0][0][0]= get_amv(s, 0);
01177 s->mv[0][0][1]= get_amv(s, 1);
01178
01179 s->mb_skipped = 0;
01180 }else{
01181 s->current_picture.f.mb_type[xy] = MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
01182 s->mcsel=0;
01183 s->mv[0][0][0] = 0;
01184 s->mv[0][0][1] = 0;
01185 s->mb_skipped = 1;
01186 }
01187 goto end;
01188 }
01189 cbpc = get_vlc2(&s->gb, ff_h263_inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
01190 if (cbpc < 0){
01191 av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
01192 return -1;
01193 }
01194 }while(cbpc == 20);
01195
01196 s->dsp.clear_blocks(s->block[0]);
01197 dquant = cbpc & 8;
01198 s->mb_intra = ((cbpc & 4) != 0);
01199 if (s->mb_intra) goto intra;
01200
01201 if(s->pict_type==AV_PICTURE_TYPE_S && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
01202 s->mcsel= get_bits1(&s->gb);
01203 else s->mcsel= 0;
01204 cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1) ^ 0x0F;
01205
01206 cbp = (cbpc & 3) | (cbpy << 2);
01207 if (dquant) {
01208 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
01209 }
01210 if((!s->progressive_sequence) && (cbp || (s->workaround_bugs&FF_BUG_XVID_ILACE)))
01211 s->interlaced_dct= get_bits1(&s->gb);
01212
01213 s->mv_dir = MV_DIR_FORWARD;
01214 if ((cbpc & 16) == 0) {
01215 if(s->mcsel){
01216 s->current_picture.f.mb_type[xy] = MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0;
01217
01218 s->mv_type = MV_TYPE_16X16;
01219 mx= get_amv(s, 0);
01220 my= get_amv(s, 1);
01221 s->mv[0][0][0] = mx;
01222 s->mv[0][0][1] = my;
01223 }else if((!s->progressive_sequence) && get_bits1(&s->gb)){
01224 s->current_picture.f.mb_type[xy] = MB_TYPE_16x8 | MB_TYPE_L0 | MB_TYPE_INTERLACED;
01225
01226 s->mv_type= MV_TYPE_FIELD;
01227
01228 s->field_select[0][0]= get_bits1(&s->gb);
01229 s->field_select[0][1]= get_bits1(&s->gb);
01230
01231 ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
01232
01233 for(i=0; i<2; i++){
01234 mx = ff_h263_decode_motion(s, pred_x, s->f_code);
01235 if (mx >= 0xffff)
01236 return -1;
01237
01238 my = ff_h263_decode_motion(s, pred_y/2, s->f_code);
01239 if (my >= 0xffff)
01240 return -1;
01241
01242 s->mv[0][i][0] = mx;
01243 s->mv[0][i][1] = my;
01244 }
01245 }else{
01246 s->current_picture.f.mb_type[xy] = MB_TYPE_16x16 | MB_TYPE_L0;
01247
01248 s->mv_type = MV_TYPE_16X16;
01249 ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
01250 mx = ff_h263_decode_motion(s, pred_x, s->f_code);
01251
01252 if (mx >= 0xffff)
01253 return -1;
01254
01255 my = ff_h263_decode_motion(s, pred_y, s->f_code);
01256
01257 if (my >= 0xffff)
01258 return -1;
01259 s->mv[0][0][0] = mx;
01260 s->mv[0][0][1] = my;
01261 }
01262 } else {
01263 s->current_picture.f.mb_type[xy] = MB_TYPE_8x8 | MB_TYPE_L0;
01264 s->mv_type = MV_TYPE_8X8;
01265 for(i=0;i<4;i++) {
01266 mot_val = ff_h263_pred_motion(s, i, 0, &pred_x, &pred_y);
01267 mx = ff_h263_decode_motion(s, pred_x, s->f_code);
01268 if (mx >= 0xffff)
01269 return -1;
01270
01271 my = ff_h263_decode_motion(s, pred_y, s->f_code);
01272 if (my >= 0xffff)
01273 return -1;
01274 s->mv[0][i][0] = mx;
01275 s->mv[0][i][1] = my;
01276 mot_val[0] = mx;
01277 mot_val[1] = my;
01278 }
01279 }
01280 } else if(s->pict_type==AV_PICTURE_TYPE_B) {
01281 int modb1;
01282 int modb2;
01283 int mb_type;
01284
01285 s->mb_intra = 0;
01286 s->mcsel=0;
01287
01288 if(s->mb_x==0){
01289 for(i=0; i<2; i++){
01290 s->last_mv[i][0][0]=
01291 s->last_mv[i][0][1]=
01292 s->last_mv[i][1][0]=
01293 s->last_mv[i][1][1]= 0;
01294 }
01295
01296 ff_thread_await_progress((AVFrame*)s->next_picture_ptr, s->mb_y, 0);
01297 }
01298
01299
01300 s->mb_skipped = s->next_picture.f.mbskip_table[s->mb_y * s->mb_stride + s->mb_x];
01301
01302 if(s->mb_skipped){
01303
01304 for(i=0;i<6;i++)
01305 s->block_last_index[i] = -1;
01306
01307 s->mv_dir = MV_DIR_FORWARD;
01308 s->mv_type = MV_TYPE_16X16;
01309 s->mv[0][0][0] = 0;
01310 s->mv[0][0][1] = 0;
01311 s->mv[1][0][0] = 0;
01312 s->mv[1][0][1] = 0;
01313 s->current_picture.f.mb_type[xy] = MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
01314 goto end;
01315 }
01316
01317 modb1= get_bits1(&s->gb);
01318 if(modb1){
01319 mb_type= MB_TYPE_DIRECT2 | MB_TYPE_SKIP | MB_TYPE_L0L1;
01320 cbp=0;
01321 }else{
01322 modb2= get_bits1(&s->gb);
01323 mb_type= get_vlc2(&s->gb, mb_type_b_vlc.table, MB_TYPE_B_VLC_BITS, 1);
01324 if(mb_type<0){
01325 av_log(s->avctx, AV_LOG_ERROR, "illegal MB_type\n");
01326 return -1;
01327 }
01328 mb_type= mb_type_b_map[ mb_type ];
01329 if(modb2) cbp= 0;
01330 else{
01331 s->dsp.clear_blocks(s->block[0]);
01332 cbp= get_bits(&s->gb, 6);
01333 }
01334
01335 if ((!IS_DIRECT(mb_type)) && cbp) {
01336 if(get_bits1(&s->gb)){
01337 ff_set_qscale(s, s->qscale + get_bits1(&s->gb)*4 - 2);
01338 }
01339 }
01340
01341 if(!s->progressive_sequence){
01342 if(cbp)
01343 s->interlaced_dct= get_bits1(&s->gb);
01344
01345 if(!IS_DIRECT(mb_type) && get_bits1(&s->gb)){
01346 mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
01347 mb_type &= ~MB_TYPE_16x16;
01348
01349 if(USES_LIST(mb_type, 0)){
01350 s->field_select[0][0]= get_bits1(&s->gb);
01351 s->field_select[0][1]= get_bits1(&s->gb);
01352 }
01353 if(USES_LIST(mb_type, 1)){
01354 s->field_select[1][0]= get_bits1(&s->gb);
01355 s->field_select[1][1]= get_bits1(&s->gb);
01356 }
01357 }
01358 }
01359
01360 s->mv_dir = 0;
01361 if((mb_type & (MB_TYPE_DIRECT2|MB_TYPE_INTERLACED)) == 0){
01362 s->mv_type= MV_TYPE_16X16;
01363
01364 if(USES_LIST(mb_type, 0)){
01365 s->mv_dir = MV_DIR_FORWARD;
01366
01367 mx = ff_h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
01368 my = ff_h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
01369 s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
01370 s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my;
01371 }
01372
01373 if(USES_LIST(mb_type, 1)){
01374 s->mv_dir |= MV_DIR_BACKWARD;
01375
01376 mx = ff_h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
01377 my = ff_h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
01378 s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
01379 s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my;
01380 }
01381 }else if(!IS_DIRECT(mb_type)){
01382 s->mv_type= MV_TYPE_FIELD;
01383
01384 if(USES_LIST(mb_type, 0)){
01385 s->mv_dir = MV_DIR_FORWARD;
01386
01387 for(i=0; i<2; i++){
01388 mx = ff_h263_decode_motion(s, s->last_mv[0][i][0] , s->f_code);
01389 my = ff_h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code);
01390 s->last_mv[0][i][0]= s->mv[0][i][0] = mx;
01391 s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2;
01392 }
01393 }
01394
01395 if(USES_LIST(mb_type, 1)){
01396 s->mv_dir |= MV_DIR_BACKWARD;
01397
01398 for(i=0; i<2; i++){
01399 mx = ff_h263_decode_motion(s, s->last_mv[1][i][0] , s->b_code);
01400 my = ff_h263_decode_motion(s, s->last_mv[1][i][1]/2, s->b_code);
01401 s->last_mv[1][i][0]= s->mv[1][i][0] = mx;
01402 s->last_mv[1][i][1]= (s->mv[1][i][1] = my)*2;
01403 }
01404 }
01405 }
01406 }
01407
01408 if(IS_DIRECT(mb_type)){
01409 if(IS_SKIP(mb_type))
01410 mx=my=0;
01411 else{
01412 mx = ff_h263_decode_motion(s, 0, 1);
01413 my = ff_h263_decode_motion(s, 0, 1);
01414 }
01415
01416 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
01417 mb_type |= ff_mpeg4_set_direct_mv(s, mx, my);
01418 }
01419 s->current_picture.f.mb_type[xy] = mb_type;
01420 } else {
01421 do{
01422 cbpc = get_vlc2(&s->gb, ff_h263_intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);
01423 if (cbpc < 0){
01424 av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);
01425 return -1;
01426 }
01427 }while(cbpc == 8);
01428
01429 dquant = cbpc & 4;
01430 s->mb_intra = 1;
01431 intra:
01432 s->ac_pred = get_bits1(&s->gb);
01433 if(s->ac_pred)
01434 s->current_picture.f.mb_type[xy] = MB_TYPE_INTRA | MB_TYPE_ACPRED;
01435 else
01436 s->current_picture.f.mb_type[xy] = MB_TYPE_INTRA;
01437
01438 cbpy = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
01439 if(cbpy<0){
01440 av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);
01441 return -1;
01442 }
01443 cbp = (cbpc & 3) | (cbpy << 2);
01444
01445 s->use_intra_dc_vlc= s->qscale < s->intra_dc_threshold;
01446
01447 if (dquant) {
01448 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]);
01449 }
01450
01451 if(!s->progressive_sequence)
01452 s->interlaced_dct= get_bits1(&s->gb);
01453
01454 s->dsp.clear_blocks(s->block[0]);
01455
01456 for (i = 0; i < 6; i++) {
01457 if (mpeg4_decode_block(s, block[i], i, cbp&32, 1, 0) < 0)
01458 return -1;
01459 cbp+=cbp;
01460 }
01461 goto end;
01462 }
01463
01464
01465 for (i = 0; i < 6; i++) {
01466 if (mpeg4_decode_block(s, block[i], i, cbp&32, 0, 0) < 0)
01467 return -1;
01468 cbp+=cbp;
01469 }
01470 end:
01471
01472
01473 if(s->codec_id==CODEC_ID_MPEG4){
01474 if(mpeg4_is_resync(s)){
01475 const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
01476
01477 if (s->pict_type == AV_PICTURE_TYPE_B && s->next_picture.f.mbskip_table[xy + delta]) {
01478 ff_thread_await_progress((AVFrame*)s->next_picture_ptr,
01479 (s->mb_x + delta >= s->mb_width) ? FFMIN(s->mb_y+1, s->mb_height-1) : s->mb_y, 0);
01480 }
01481
01482 if (s->pict_type == AV_PICTURE_TYPE_B && s->next_picture.f.mbskip_table[xy + delta])
01483 return SLICE_OK;
01484 return SLICE_END;
01485 }
01486 }
01487
01488 return SLICE_OK;
01489 }
01490
01491
01492 static int mpeg4_decode_gop_header(MpegEncContext * s, GetBitContext *gb){
01493 int hours, minutes, seconds;
01494 unsigned time_code = show_bits(gb, 18);
01495
01496 if (time_code & 0x40) {
01497 hours = time_code >> 13;
01498 minutes = time_code >> 7 & 0x3f;
01499 seconds = time_code & 0x3f;
01500 s->time_base = seconds + 60*(minutes + 60*hours);
01501 skip_bits(gb, 20);
01502 } else {
01503 av_log(s->avctx, AV_LOG_WARNING, "GOP header missing marker_bit\n");
01504 }
01505
01506 return 0;
01507 }
01508
01509 static int mpeg4_decode_profile_level(MpegEncContext * s, GetBitContext *gb){
01510 int profile_and_level_indication;
01511
01512 profile_and_level_indication = get_bits(gb, 8);
01513
01514 s->avctx->profile = (profile_and_level_indication & 0xf0) >> 4;
01515 s->avctx->level = (profile_and_level_indication & 0x0f);
01516
01517
01518 if (s->avctx->profile == 0 && s->avctx->level == 8) {
01519 s->avctx->level = 0;
01520 }
01521
01522 return 0;
01523 }
01524
01525 static int decode_vol_header(MpegEncContext *s, GetBitContext *gb){
01526 int width, height, vo_ver_id;
01527
01528
01529 skip_bits(gb, 1);
01530 s->vo_type= get_bits(gb, 8);
01531 if (get_bits1(gb) != 0) {
01532 vo_ver_id = get_bits(gb, 4);
01533 skip_bits(gb, 3);
01534 } else {
01535 vo_ver_id = 1;
01536 }
01537 s->aspect_ratio_info= get_bits(gb, 4);
01538 if(s->aspect_ratio_info == FF_ASPECT_EXTENDED){
01539 s->avctx->sample_aspect_ratio.num= get_bits(gb, 8);
01540 s->avctx->sample_aspect_ratio.den= get_bits(gb, 8);
01541 }else{
01542 s->avctx->sample_aspect_ratio= ff_h263_pixel_aspect[s->aspect_ratio_info];
01543 }
01544
01545 if ((s->vol_control_parameters=get_bits1(gb))) {
01546 int chroma_format= get_bits(gb, 2);
01547 if(chroma_format!=CHROMA_420){
01548 av_log(s->avctx, AV_LOG_ERROR, "illegal chroma format\n");
01549 }
01550 s->low_delay= get_bits1(gb);
01551 if(get_bits1(gb)){
01552 get_bits(gb, 15);
01553 skip_bits1(gb);
01554 get_bits(gb, 15);
01555 skip_bits1(gb);
01556 get_bits(gb, 15);
01557 skip_bits1(gb);
01558 get_bits(gb, 3);
01559 get_bits(gb, 11);
01560 skip_bits1(gb);
01561 get_bits(gb, 15);
01562 skip_bits1(gb);
01563 }
01564 }else{
01565
01566 if(s->picture_number==0)
01567 s->low_delay=0;
01568 }
01569
01570 s->shape = get_bits(gb, 2);
01571 if(s->shape != RECT_SHAPE) av_log(s->avctx, AV_LOG_ERROR, "only rectangular vol supported\n");
01572 if(s->shape == GRAY_SHAPE && vo_ver_id != 1){
01573 av_log(s->avctx, AV_LOG_ERROR, "Gray shape not supported\n");
01574 skip_bits(gb, 4);
01575 }
01576
01577 check_marker(gb, "before time_increment_resolution");
01578
01579 s->avctx->time_base.den = get_bits(gb, 16);
01580 if(!s->avctx->time_base.den){
01581 av_log(s->avctx, AV_LOG_ERROR, "time_base.den==0\n");
01582 s->avctx->time_base.num = 0;
01583 return -1;
01584 }
01585
01586 s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
01587 if (s->time_increment_bits < 1)
01588 s->time_increment_bits = 1;
01589
01590 check_marker(gb, "before fixed_vop_rate");
01591
01592 if (get_bits1(gb) != 0) {
01593 s->avctx->time_base.num = get_bits(gb, s->time_increment_bits);
01594 }else
01595 s->avctx->time_base.num = 1;
01596
01597 s->t_frame=0;
01598
01599 if (s->shape != BIN_ONLY_SHAPE) {
01600 if (s->shape == RECT_SHAPE) {
01601 skip_bits1(gb);
01602 width = get_bits(gb, 13);
01603 skip_bits1(gb);
01604 height = get_bits(gb, 13);
01605 skip_bits1(gb);
01606 if(width && height && !(s->width && s->codec_tag == AV_RL32("MP4S"))){
01607 s->width = width;
01608 s->height = height;
01609 }
01610 }
01611
01612 s->progressive_sequence=
01613 s->progressive_frame= get_bits1(gb)^1;
01614 s->interlaced_dct=0;
01615 if(!get_bits1(gb) && (s->avctx->debug & FF_DEBUG_PICT_INFO))
01616 av_log(s->avctx, AV_LOG_INFO, "MPEG4 OBMC not supported (very likely buggy encoder)\n");
01617 if (vo_ver_id == 1) {
01618 s->vol_sprite_usage = get_bits1(gb);
01619 } else {
01620 s->vol_sprite_usage = get_bits(gb, 2);
01621 }
01622 if(s->vol_sprite_usage==STATIC_SPRITE) av_log(s->avctx, AV_LOG_ERROR, "Static Sprites not supported\n");
01623 if(s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE){
01624 if(s->vol_sprite_usage==STATIC_SPRITE){
01625 s->sprite_width = get_bits(gb, 13);
01626 skip_bits1(gb);
01627 s->sprite_height= get_bits(gb, 13);
01628 skip_bits1(gb);
01629 s->sprite_left = get_bits(gb, 13);
01630 skip_bits1(gb);
01631 s->sprite_top = get_bits(gb, 13);
01632 skip_bits1(gb);
01633 }
01634 s->num_sprite_warping_points= get_bits(gb, 6);
01635 if(s->num_sprite_warping_points > 3){
01636 av_log(s->avctx, AV_LOG_ERROR, "%d sprite_warping_points\n", s->num_sprite_warping_points);
01637 s->num_sprite_warping_points= 0;
01638 return -1;
01639 }
01640 s->sprite_warping_accuracy = get_bits(gb, 2);
01641 s->sprite_brightness_change= get_bits1(gb);
01642 if(s->vol_sprite_usage==STATIC_SPRITE)
01643 s->low_latency_sprite= get_bits1(gb);
01644 }
01645
01646
01647 if (get_bits1(gb) == 1) {
01648 s->quant_precision = get_bits(gb, 4);
01649 if(get_bits(gb, 4)!=8) av_log(s->avctx, AV_LOG_ERROR, "N-bit not supported\n");
01650 if(s->quant_precision!=5) av_log(s->avctx, AV_LOG_ERROR, "quant precision %d\n", s->quant_precision);
01651 } else {
01652 s->quant_precision = 5;
01653 }
01654
01655
01656
01657 if((s->mpeg_quant=get_bits1(gb))){
01658 int i, v;
01659
01660
01661 for(i=0; i<64; i++){
01662 int j= s->dsp.idct_permutation[i];
01663 v= ff_mpeg4_default_intra_matrix[i];
01664 s->intra_matrix[j]= v;
01665 s->chroma_intra_matrix[j]= v;
01666
01667 v= ff_mpeg4_default_non_intra_matrix[i];
01668 s->inter_matrix[j]= v;
01669 s->chroma_inter_matrix[j]= v;
01670 }
01671
01672
01673 if(get_bits1(gb)){
01674 int last=0;
01675 for(i=0; i<64; i++){
01676 int j;
01677 v= get_bits(gb, 8);
01678 if(v==0) break;
01679
01680 last= v;
01681 j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
01682 s->intra_matrix[j]= v;
01683 s->chroma_intra_matrix[j]= v;
01684 }
01685
01686
01687 for(; i<64; i++){
01688 int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
01689 s->intra_matrix[j]= last;
01690 s->chroma_intra_matrix[j]= last;
01691 }
01692 }
01693
01694
01695 if(get_bits1(gb)){
01696 int last=0;
01697 for(i=0; i<64; i++){
01698 int j;
01699 v= get_bits(gb, 8);
01700 if(v==0) break;
01701
01702 last= v;
01703 j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
01704 s->inter_matrix[j]= v;
01705 s->chroma_inter_matrix[j]= v;
01706 }
01707
01708
01709 for(; i<64; i++){
01710 int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
01711 s->inter_matrix[j]= last;
01712 s->chroma_inter_matrix[j]= last;
01713 }
01714 }
01715
01716
01717 }
01718
01719 if(vo_ver_id != 1)
01720 s->quarter_sample= get_bits1(gb);
01721 else s->quarter_sample=0;
01722
01723 if(!get_bits1(gb)){
01724 int pos= get_bits_count(gb);
01725 int estimation_method= get_bits(gb, 2);
01726 if(estimation_method<2){
01727 if(!get_bits1(gb)){
01728 s->cplx_estimation_trash_i += 8*get_bits1(gb);
01729 s->cplx_estimation_trash_i += 8*get_bits1(gb);
01730 s->cplx_estimation_trash_i += 8*get_bits1(gb);
01731 s->cplx_estimation_trash_i += 8*get_bits1(gb);
01732 s->cplx_estimation_trash_i += 8*get_bits1(gb);
01733 s->cplx_estimation_trash_i += 8*get_bits1(gb);
01734 }
01735 if(!get_bits1(gb)){
01736 s->cplx_estimation_trash_i += 8*get_bits1(gb);
01737 s->cplx_estimation_trash_p += 8*get_bits1(gb);
01738 s->cplx_estimation_trash_p += 8*get_bits1(gb);
01739 s->cplx_estimation_trash_i += 8*get_bits1(gb);
01740 }
01741 if(!check_marker(gb, "in complexity estimation part 1")){
01742 skip_bits_long(gb, pos - get_bits_count(gb));
01743 goto no_cplx_est;
01744 }
01745 if(!get_bits1(gb)){
01746 s->cplx_estimation_trash_i += 8*get_bits1(gb);
01747 s->cplx_estimation_trash_i += 8*get_bits1(gb);
01748 s->cplx_estimation_trash_i += 8*get_bits1(gb);
01749 s->cplx_estimation_trash_i += 4*get_bits1(gb);
01750 }
01751 if(!get_bits1(gb)){
01752 s->cplx_estimation_trash_p += 8*get_bits1(gb);
01753 s->cplx_estimation_trash_p += 8*get_bits1(gb);
01754 s->cplx_estimation_trash_b += 8*get_bits1(gb);
01755 s->cplx_estimation_trash_p += 8*get_bits1(gb);
01756 s->cplx_estimation_trash_p += 8*get_bits1(gb);
01757 s->cplx_estimation_trash_p += 8*get_bits1(gb);
01758 }
01759 if(!check_marker(gb, "in complexity estimation part 2")){
01760 skip_bits_long(gb, pos - get_bits_count(gb));
01761 goto no_cplx_est;
01762 }
01763 if(estimation_method==1){
01764 s->cplx_estimation_trash_i += 8*get_bits1(gb);
01765 s->cplx_estimation_trash_p += 8*get_bits1(gb);
01766 }
01767 }else
01768 av_log(s->avctx, AV_LOG_ERROR, "Invalid Complexity estimation method %d\n", estimation_method);
01769 }else{
01770 no_cplx_est:
01771 s->cplx_estimation_trash_i=
01772 s->cplx_estimation_trash_p=
01773 s->cplx_estimation_trash_b= 0;
01774 }
01775
01776 s->resync_marker= !get_bits1(gb);
01777
01778 s->data_partitioning= get_bits1(gb);
01779 if(s->data_partitioning){
01780 s->rvlc= get_bits1(gb);
01781 }
01782
01783 if(vo_ver_id != 1) {
01784 s->new_pred= get_bits1(gb);
01785 if(s->new_pred){
01786 av_log(s->avctx, AV_LOG_ERROR, "new pred not supported\n");
01787 skip_bits(gb, 2);
01788 skip_bits1(gb);
01789 }
01790 s->reduced_res_vop= get_bits1(gb);
01791 if(s->reduced_res_vop) av_log(s->avctx, AV_LOG_ERROR, "reduced resolution VOP not supported\n");
01792 }
01793 else{
01794 s->new_pred=0;
01795 s->reduced_res_vop= 0;
01796 }
01797
01798 s->scalability= get_bits1(gb);
01799
01800 if (s->scalability) {
01801 GetBitContext bak= *gb;
01802 int h_sampling_factor_n;
01803 int h_sampling_factor_m;
01804 int v_sampling_factor_n;
01805 int v_sampling_factor_m;
01806
01807 s->hierachy_type= get_bits1(gb);
01808 skip_bits(gb, 4);
01809 skip_bits1(gb);
01810 h_sampling_factor_n= get_bits(gb, 5);
01811 h_sampling_factor_m= get_bits(gb, 5);
01812 v_sampling_factor_n= get_bits(gb, 5);
01813 v_sampling_factor_m= get_bits(gb, 5);
01814 s->enhancement_type= get_bits1(gb);
01815
01816 if( h_sampling_factor_n==0 || h_sampling_factor_m==0
01817 || v_sampling_factor_n==0 || v_sampling_factor_m==0){
01818
01819
01820 s->scalability=0;
01821 *gb= bak;
01822 }else
01823 av_log(s->avctx, AV_LOG_ERROR, "scalability not supported\n");
01824
01825
01826 }
01827 }
01828 return 0;
01829 }
01830
01835 static int decode_user_data(MpegEncContext *s, GetBitContext *gb){
01836 char buf[256];
01837 int i;
01838 int e;
01839 int ver = 0, build = 0, ver2 = 0, ver3 = 0;
01840 char last;
01841
01842 for(i=0; i<255 && get_bits_count(gb) < gb->size_in_bits; i++){
01843 if(show_bits(gb, 23) == 0) break;
01844 buf[i]= get_bits(gb, 8);
01845 }
01846 buf[i]=0;
01847
01848
01849 e=sscanf(buf, "DivX%dBuild%d%c", &ver, &build, &last);
01850 if(e<2)
01851 e=sscanf(buf, "DivX%db%d%c", &ver, &build, &last);
01852 if(e>=2){
01853 s->divx_version= ver;
01854 s->divx_build= build;
01855 s->divx_packed= e==3 && last=='p';
01856 if(s->divx_packed && !s->showed_packed_warning) {
01857 av_log(s->avctx, AV_LOG_WARNING, "Invalid and inefficient vfw-avi packed B frames detected\n");
01858 s->showed_packed_warning=1;
01859 }
01860 }
01861
01862
01863 e=sscanf(buf, "FFmpe%*[^b]b%d", &build)+3;
01864 if(e!=4)
01865 e=sscanf(buf, "FFmpeg v%d.%d.%d / libavcodec build: %d", &ver, &ver2, &ver3, &build);
01866 if(e!=4){
01867 e=sscanf(buf, "Lavc%d.%d.%d", &ver, &ver2, &ver3)+1;
01868 if (e>1)
01869 build= (ver<<16) + (ver2<<8) + ver3;
01870 }
01871 if(e!=4){
01872 if(strcmp(buf, "ffmpeg")==0){
01873 s->lavc_build= 4600;
01874 }
01875 }
01876 if(e==4){
01877 s->lavc_build= build;
01878 }
01879
01880
01881 e=sscanf(buf, "XviD%d", &build);
01882 if(e==1){
01883 s->xvid_build= build;
01884 }
01885
01886 return 0;
01887 }
01888
01889 static int decode_vop_header(MpegEncContext *s, GetBitContext *gb){
01890 int time_incr, time_increment;
01891
01892 s->pict_type = get_bits(gb, 2) + AV_PICTURE_TYPE_I;
01893 if(s->pict_type==AV_PICTURE_TYPE_B && s->low_delay && s->vol_control_parameters==0 && !(s->flags & CODEC_FLAG_LOW_DELAY)){
01894 av_log(s->avctx, AV_LOG_ERROR, "low_delay flag incorrectly, clearing it\n");
01895 s->low_delay=0;
01896 }
01897
01898 s->partitioned_frame= s->data_partitioning && s->pict_type!=AV_PICTURE_TYPE_B;
01899 if(s->partitioned_frame)
01900 s->decode_mb= mpeg4_decode_partitioned_mb;
01901 else
01902 s->decode_mb= mpeg4_decode_mb;
01903
01904 time_incr=0;
01905 while (get_bits1(gb) != 0)
01906 time_incr++;
01907
01908 check_marker(gb, "before time_increment");
01909
01910 if(s->time_increment_bits==0 || !(show_bits(gb, s->time_increment_bits+1)&1)){
01911 av_log(s->avctx, AV_LOG_ERROR, "hmm, seems the headers are not complete, trying to guess time_increment_bits\n");
01912
01913 for(s->time_increment_bits=1 ;s->time_increment_bits<16; s->time_increment_bits++){
01914 if ( s->pict_type == AV_PICTURE_TYPE_P
01915 || (s->pict_type == AV_PICTURE_TYPE_S && s->vol_sprite_usage==GMC_SPRITE)) {
01916 if((show_bits(gb, s->time_increment_bits+6)&0x37) == 0x30) break;
01917 }else
01918 if((show_bits(gb, s->time_increment_bits+5)&0x1F) == 0x18) break;
01919 }
01920
01921 av_log(s->avctx, AV_LOG_ERROR, "my guess is %d bits ;)\n",s->time_increment_bits);
01922 }
01923
01924 if(IS_3IV1) time_increment= get_bits1(gb);
01925 else time_increment= get_bits(gb, s->time_increment_bits);
01926
01927 if(s->pict_type!=AV_PICTURE_TYPE_B){
01928 s->last_time_base= s->time_base;
01929 s->time_base+= time_incr;
01930 s->time= s->time_base*s->avctx->time_base.den + time_increment;
01931 if(s->workaround_bugs&FF_BUG_UMP4){
01932 if(s->time < s->last_non_b_time){
01933
01934
01935 s->time_base++;
01936 s->time+= s->avctx->time_base.den;
01937 }
01938 }
01939 s->pp_time= s->time - s->last_non_b_time;
01940 s->last_non_b_time= s->time;
01941 }else{
01942 s->time= (s->last_time_base + time_incr)*s->avctx->time_base.den + time_increment;
01943 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
01944 if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
01945
01946 return FRAME_SKIPPED;
01947 }
01948 ff_mpeg4_init_direct_mv(s);
01949
01950 if(s->t_frame==0) s->t_frame= s->pb_time;
01951 if(s->t_frame==0) s->t_frame=1;
01952 s->pp_field_time= ( ROUNDED_DIV(s->last_non_b_time, s->t_frame)
01953 - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
01954 s->pb_field_time= ( ROUNDED_DIV(s->time, s->t_frame)
01955 - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2;
01956 if(!s->progressive_sequence){
01957 if(s->pp_field_time <= s->pb_field_time || s->pb_field_time <= 1)
01958 return FRAME_SKIPPED;
01959 }
01960 }
01961
01962 if(s->avctx->time_base.num)
01963 s->current_picture_ptr->f.pts = (s->time + s->avctx->time_base.num / 2) / s->avctx->time_base.num;
01964 else
01965 s->current_picture_ptr->f.pts = AV_NOPTS_VALUE;
01966 if(s->avctx->debug&FF_DEBUG_PTS)
01967 av_log(s->avctx, AV_LOG_DEBUG, "MPEG4 PTS: %"PRId64"\n",
01968 s->current_picture_ptr->f.pts);
01969
01970 check_marker(gb, "before vop_coded");
01971
01972
01973 if (get_bits1(gb) != 1){
01974 if(s->avctx->debug&FF_DEBUG_PICT_INFO)
01975 av_log(s->avctx, AV_LOG_ERROR, "vop not coded\n");
01976 return FRAME_SKIPPED;
01977 }
01978 if (s->shape != BIN_ONLY_SHAPE && ( s->pict_type == AV_PICTURE_TYPE_P
01979 || (s->pict_type == AV_PICTURE_TYPE_S && s->vol_sprite_usage==GMC_SPRITE))) {
01980
01981 s->no_rounding = get_bits1(gb);
01982 } else {
01983 s->no_rounding = 0;
01984 }
01985
01986
01987 if (s->shape != RECT_SHAPE) {
01988 if (s->vol_sprite_usage != 1 || s->pict_type != AV_PICTURE_TYPE_I) {
01989 skip_bits(gb, 13);
01990 skip_bits1(gb);
01991 skip_bits(gb, 13);
01992 skip_bits1(gb);
01993 skip_bits(gb, 13);
01994 skip_bits1(gb);
01995 skip_bits(gb, 13);
01996 }
01997 skip_bits1(gb);
01998
01999 if (get_bits1(gb) != 0) {
02000 skip_bits(gb, 8);
02001 }
02002 }
02003
02004
02005 if (s->shape != BIN_ONLY_SHAPE) {
02006 skip_bits_long(gb, s->cplx_estimation_trash_i);
02007 if(s->pict_type != AV_PICTURE_TYPE_I)
02008 skip_bits_long(gb, s->cplx_estimation_trash_p);
02009 if(s->pict_type == AV_PICTURE_TYPE_B)
02010 skip_bits_long(gb, s->cplx_estimation_trash_b);
02011
02012 s->intra_dc_threshold= mpeg4_dc_threshold[ get_bits(gb, 3) ];
02013 if(!s->progressive_sequence){
02014 s->top_field_first= get_bits1(gb);
02015 s->alternate_scan= get_bits1(gb);
02016 }else
02017 s->alternate_scan= 0;
02018 }
02019
02020 if(s->alternate_scan){
02021 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan);
02022 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan);
02023 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_vertical_scan);
02024 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
02025 } else{
02026 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct);
02027 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct);
02028 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
02029 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
02030 }
02031
02032 if(s->pict_type == AV_PICTURE_TYPE_S && (s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE)){
02033 if (mpeg4_decode_sprite_trajectory(s, gb) < 0)
02034 return AVERROR_INVALIDDATA;
02035 if(s->sprite_brightness_change) av_log(s->avctx, AV_LOG_ERROR, "sprite_brightness_change not supported\n");
02036 if(s->vol_sprite_usage==STATIC_SPRITE) av_log(s->avctx, AV_LOG_ERROR, "static sprite not supported\n");
02037 }
02038
02039 if (s->shape != BIN_ONLY_SHAPE) {
02040 s->chroma_qscale= s->qscale = get_bits(gb, s->quant_precision);
02041 if(s->qscale==0){
02042 av_log(s->avctx, AV_LOG_ERROR, "Error, header damaged or not MPEG4 header (qscale=0)\n");
02043 return -1;
02044 }
02045
02046 if (s->pict_type != AV_PICTURE_TYPE_I) {
02047 s->f_code = get_bits(gb, 3);
02048 if(s->f_code==0){
02049 av_log(s->avctx, AV_LOG_ERROR, "Error, header damaged or not MPEG4 header (f_code=0)\n");
02050 return -1;
02051 }
02052 }else
02053 s->f_code=1;
02054
02055 if (s->pict_type == AV_PICTURE_TYPE_B) {
02056 s->b_code = get_bits(gb, 3);
02057 }else
02058 s->b_code=1;
02059
02060 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
02061 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",
02062 s->qscale, s->f_code, s->b_code,
02063 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")),
02064 gb->size_in_bits,s->progressive_sequence, s->alternate_scan, s->top_field_first,
02065 s->quarter_sample ? "q" : "h", s->data_partitioning, s->resync_marker, s->num_sprite_warping_points,
02066 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);
02067 }
02068
02069 if(!s->scalability){
02070 if (s->shape!=RECT_SHAPE && s->pict_type!=AV_PICTURE_TYPE_I) {
02071 skip_bits1(gb);
02072 }
02073 }else{
02074 if(s->enhancement_type){
02075 int load_backward_shape= get_bits1(gb);
02076 if(load_backward_shape){
02077 av_log(s->avctx, AV_LOG_ERROR, "load backward shape isn't supported\n");
02078 }
02079 }
02080 skip_bits(gb, 2);
02081 }
02082 }
02083
02084
02085 if(s->vo_type==0 && s->vol_control_parameters==0 && s->divx_version==-1 && s->picture_number==0){
02086 av_log(s->avctx, AV_LOG_WARNING, "looks like this file was encoded with (divx4/(old)xvid/opendivx) -> forcing low_delay flag\n");
02087 s->low_delay=1;
02088 }
02089
02090 s->picture_number++;
02091
02092 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;
02093 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
02094
02095 if(s->workaround_bugs&FF_BUG_EDGE){
02096 s->h_edge_pos= s->width;
02097 s->v_edge_pos= s->height;
02098 }
02099 return 0;
02100 }
02101
02108 int ff_mpeg4_decode_picture_header(MpegEncContext * s, GetBitContext *gb)
02109 {
02110 unsigned startcode, v;
02111
02112
02113 align_get_bits(gb);
02114
02115 if(s->codec_tag == AV_RL32("WV1F") && show_bits(gb, 24) == 0x575630){
02116 skip_bits(gb, 24);
02117 if(get_bits(gb, 8) == 0xF0)
02118 goto end;
02119 }
02120
02121 startcode = 0xff;
02122 for(;;) {
02123 if(get_bits_count(gb) >= gb->size_in_bits){
02124 if(gb->size_in_bits==8 && (s->divx_version>=0 || s->xvid_build>=0)){
02125 av_log(s->avctx, AV_LOG_WARNING, "frame skip %d\n", gb->size_in_bits);
02126 return FRAME_SKIPPED;
02127 }else
02128 return -1;
02129 }
02130
02131
02132 v = get_bits(gb, 8);
02133 startcode = ((startcode << 8) | v) & 0xffffffff;
02134
02135 if((startcode&0xFFFFFF00) != 0x100)
02136 continue;
02137
02138 if(s->avctx->debug&FF_DEBUG_STARTCODE){
02139 av_log(s->avctx, AV_LOG_DEBUG, "startcode: %3X ", startcode);
02140 if (startcode<=0x11F) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Start");
02141 else if(startcode<=0x12F) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Layer Start");
02142 else if(startcode<=0x13F) av_log(s->avctx, AV_LOG_DEBUG, "Reserved");
02143 else if(startcode<=0x15F) av_log(s->avctx, AV_LOG_DEBUG, "FGS bp start");
02144 else if(startcode<=0x1AF) av_log(s->avctx, AV_LOG_DEBUG, "Reserved");
02145 else if(startcode==0x1B0) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Seq Start");
02146 else if(startcode==0x1B1) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Seq End");
02147 else if(startcode==0x1B2) av_log(s->avctx, AV_LOG_DEBUG, "User Data");
02148 else if(startcode==0x1B3) av_log(s->avctx, AV_LOG_DEBUG, "Group of VOP start");
02149 else if(startcode==0x1B4) av_log(s->avctx, AV_LOG_DEBUG, "Video Session Error");
02150 else if(startcode==0x1B5) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Start");
02151 else if(startcode==0x1B6) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Plane start");
02152 else if(startcode==0x1B7) av_log(s->avctx, AV_LOG_DEBUG, "slice start");
02153 else if(startcode==0x1B8) av_log(s->avctx, AV_LOG_DEBUG, "extension start");
02154 else if(startcode==0x1B9) av_log(s->avctx, AV_LOG_DEBUG, "fgs start");
02155 else if(startcode==0x1BA) av_log(s->avctx, AV_LOG_DEBUG, "FBA Object start");
02156 else if(startcode==0x1BB) av_log(s->avctx, AV_LOG_DEBUG, "FBA Object Plane start");
02157 else if(startcode==0x1BC) av_log(s->avctx, AV_LOG_DEBUG, "Mesh Object start");
02158 else if(startcode==0x1BD) av_log(s->avctx, AV_LOG_DEBUG, "Mesh Object Plane start");
02159 else if(startcode==0x1BE) av_log(s->avctx, AV_LOG_DEBUG, "Still Texture Object start");
02160 else if(startcode==0x1BF) av_log(s->avctx, AV_LOG_DEBUG, "Texture Spatial Layer start");
02161 else if(startcode==0x1C0) av_log(s->avctx, AV_LOG_DEBUG, "Texture SNR Layer start");
02162 else if(startcode==0x1C1) av_log(s->avctx, AV_LOG_DEBUG, "Texture Tile start");
02163 else if(startcode==0x1C2) av_log(s->avctx, AV_LOG_DEBUG, "Texture Shape Layer start");
02164 else if(startcode==0x1C3) av_log(s->avctx, AV_LOG_DEBUG, "stuffing start");
02165 else if(startcode<=0x1C5) av_log(s->avctx, AV_LOG_DEBUG, "reserved");
02166 else if(startcode<=0x1FF) av_log(s->avctx, AV_LOG_DEBUG, "System start");
02167 av_log(s->avctx, AV_LOG_DEBUG, " at %d\n", get_bits_count(gb));
02168 }
02169
02170 if(startcode >= 0x120 && startcode <= 0x12F){
02171 if(decode_vol_header(s, gb) < 0)
02172 return -1;
02173 }
02174 else if(startcode == USER_DATA_STARTCODE){
02175 decode_user_data(s, gb);
02176 }
02177 else if(startcode == GOP_STARTCODE){
02178 mpeg4_decode_gop_header(s, gb);
02179 }
02180 else if(startcode == VOS_STARTCODE){
02181 mpeg4_decode_profile_level(s, gb);
02182 }
02183 else if(startcode == VOP_STARTCODE){
02184 break;
02185 }
02186
02187 align_get_bits(gb);
02188 startcode = 0xff;
02189 }
02190 end:
02191 if(s->flags& CODEC_FLAG_LOW_DELAY)
02192 s->low_delay=1;
02193 s->avctx->has_b_frames= !s->low_delay;
02194 return decode_vop_header(s, gb);
02195 }
02196
02197 static av_cold int decode_init(AVCodecContext *avctx)
02198 {
02199 MpegEncContext *s = avctx->priv_data;
02200 int ret;
02201 static int done = 0;
02202
02203 s->divx_version=
02204 s->divx_build=
02205 s->xvid_build=
02206 s->lavc_build= -1;
02207
02208 if((ret=ff_h263_decode_init(avctx)) < 0)
02209 return ret;
02210
02211 if (!done) {
02212 done = 1;
02213
02214 ff_init_rl(&ff_mpeg4_rl_intra, ff_mpeg4_static_rl_table_store[0]);
02215 ff_init_rl(&rvlc_rl_inter, ff_mpeg4_static_rl_table_store[1]);
02216 ff_init_rl(&rvlc_rl_intra, ff_mpeg4_static_rl_table_store[2]);
02217 INIT_VLC_RL(ff_mpeg4_rl_intra, 554);
02218 INIT_VLC_RL(rvlc_rl_inter, 1072);
02219 INIT_VLC_RL(rvlc_rl_intra, 1072);
02220 INIT_VLC_STATIC(&dc_lum, DC_VLC_BITS, 10 ,
02221 &ff_mpeg4_DCtab_lum[0][1], 2, 1,
02222 &ff_mpeg4_DCtab_lum[0][0], 2, 1, 512);
02223 INIT_VLC_STATIC(&dc_chrom, DC_VLC_BITS, 10 ,
02224 &ff_mpeg4_DCtab_chrom[0][1], 2, 1,
02225 &ff_mpeg4_DCtab_chrom[0][0], 2, 1, 512);
02226 INIT_VLC_STATIC(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15,
02227 &sprite_trajectory_tab[0][1], 4, 2,
02228 &sprite_trajectory_tab[0][0], 4, 2, 128);
02229 INIT_VLC_STATIC(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4,
02230 &mb_type_b_tab[0][1], 2, 1,
02231 &mb_type_b_tab[0][0], 2, 1, 16);
02232 }
02233
02234 s->h263_pred = 1;
02235 s->low_delay = 0;
02236 s->decode_mb= mpeg4_decode_mb;
02237 s->time_increment_bits = 4;
02238 avctx->chroma_sample_location = AVCHROMA_LOC_LEFT;
02239
02240 return 0;
02241 }
02242
02243 static const AVProfile mpeg4_video_profiles[] = {
02244 { FF_PROFILE_MPEG4_SIMPLE, "Simple Profile" },
02245 { FF_PROFILE_MPEG4_SIMPLE_SCALABLE, "Simple Scalable Profile" },
02246 { FF_PROFILE_MPEG4_CORE, "Core Profile" },
02247 { FF_PROFILE_MPEG4_MAIN, "Main Profile" },
02248 { FF_PROFILE_MPEG4_N_BIT, "N-bit Profile" },
02249 { FF_PROFILE_MPEG4_SCALABLE_TEXTURE, "Scalable Texture Profile" },
02250 { FF_PROFILE_MPEG4_SIMPLE_FACE_ANIMATION, "Simple Face Animation Profile" },
02251 { FF_PROFILE_MPEG4_BASIC_ANIMATED_TEXTURE, "Basic Animated Texture Profile" },
02252 { FF_PROFILE_MPEG4_HYBRID, "Hybrid Profile" },
02253 { FF_PROFILE_MPEG4_ADVANCED_REAL_TIME, "Advanced Real Time Simple Profile" },
02254 { FF_PROFILE_MPEG4_CORE_SCALABLE, "Code Scalable Profile" },
02255 { FF_PROFILE_MPEG4_ADVANCED_CODING, "Advanced Coding Profile" },
02256 { FF_PROFILE_MPEG4_ADVANCED_CORE, "Advanced Core Profile" },
02257 { FF_PROFILE_MPEG4_ADVANCED_SCALABLE_TEXTURE, "Advanced Scalable Texture Profile" },
02258 { FF_PROFILE_MPEG4_SIMPLE_STUDIO, "Simple Studio Profile" },
02259 { FF_PROFILE_MPEG4_ADVANCED_SIMPLE, "Advanced Simple Profile" },
02260 };
02261
02262 AVCodec ff_mpeg4_decoder = {
02263 .name = "mpeg4",
02264 .type = AVMEDIA_TYPE_VIDEO,
02265 .id = CODEC_ID_MPEG4,
02266 .priv_data_size = sizeof(MpegEncContext),
02267 .init = decode_init,
02268 .close = ff_h263_decode_end,
02269 .decode = ff_h263_decode_frame,
02270 .capabilities = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY | CODEC_CAP_FRAME_THREADS,
02271 .flush= ff_mpeg_flush,
02272 .max_lowres= 3,
02273 .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2"),
02274 .pix_fmts= ff_hwaccel_pixfmt_list_420,
02275 .profiles = NULL_IF_CONFIG_SMALL(mpeg4_video_profiles),
02276 .update_thread_context= ONLY_IF_THREADS_ENABLED(ff_mpeg_update_thread_context)
02277 };
02278
02279
02280 #if CONFIG_MPEG4_VDPAU_DECODER
02281 AVCodec ff_mpeg4_vdpau_decoder = {
02282 .name = "mpeg4_vdpau",
02283 .type = AVMEDIA_TYPE_VIDEO,
02284 .id = CODEC_ID_MPEG4,
02285 .priv_data_size = sizeof(MpegEncContext),
02286 .init = decode_init,
02287 .close = ff_h263_decode_end,
02288 .decode = ff_h263_decode_frame,
02289 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
02290 .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 (VDPAU)"),
02291 .pix_fmts= (const enum PixelFormat[]){PIX_FMT_VDPAU_MPEG4, PIX_FMT_NONE},
02292 };
02293 #endif