1/* 2 * H263/MPEG4 backend for ffmpeg encoder and decoder 3 * Copyright (c) 2000,2001 Fabrice Bellard 4 * H263+ support. 5 * Copyright (c) 2001 Juan J. Sierralta P 6 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at> 7 * 8 * ac prediction encoding, B-frame support, error resilience, optimizations, 9 * qpel decoding, gmc decoding, interlaced decoding 10 * by Michael Niedermayer <michaelni@gmx.at> 11 * 12 * This file is part of FFmpeg. 13 * 14 * FFmpeg is free software; you can redistribute it and/or 15 * modify it under the terms of the GNU Lesser General Public 16 * License as published by the Free Software Foundation; either 17 * version 2.1 of the License, or (at your option) any later version. 18 * 19 * FFmpeg is distributed in the hope that it will be useful, 20 * but WITHOUT ANY WARRANTY; without even the implied warranty of 21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 22 * Lesser General Public License for more details. 23 * 24 * You should have received a copy of the GNU Lesser General Public 25 * License along with FFmpeg; if not, write to the Free Software 26 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 27 */ 28 29/** 30 * @file libavcodec/h263.c 31 * h263/mpeg4 codec. 32 */ 33 34//#define DEBUG 35#include <limits.h> 36 37#include "dsputil.h" 38#include "avcodec.h" 39#include "mpegvideo.h" 40#include "h263data.h" 41#include "mpeg4data.h" 42#include "mathops.h" 43 44//#undef NDEBUG 45//#include <assert.h> 46 47#define INTRA_MCBPC_VLC_BITS 6 48#define INTER_MCBPC_VLC_BITS 7 49#define CBPY_VLC_BITS 6 50#define MV_VLC_BITS 9 51#define DC_VLC_BITS 9 52#define SPRITE_TRAJ_VLC_BITS 6 53#define MB_TYPE_B_VLC_BITS 4 54#define TEX_VLC_BITS 9 55#define H263_MBTYPE_B_VLC_BITS 6 56#define CBPC_B_VLC_BITS 3 57 58static void h263_encode_block(MpegEncContext * s, DCTELEM * block, 59 int n); 60static void h263p_encode_umotion(MpegEncContext * s, int val); 61static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, 62 int n, int dc, uint8_t *scan_table, 63 PutBitContext *dc_pb, PutBitContext *ac_pb); 64static int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, 65 uint8_t *scan_table); 66 67static int h263_decode_motion(MpegEncContext * s, int pred, int fcode); 68static int h263p_decode_umotion(MpegEncContext * s, int pred); 69static int h263_decode_block(MpegEncContext * s, DCTELEM * block, 70 int n, int coded); 71static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr); 72static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block, 73 int n, int coded, int intra, int rvlc); 74 75static int h263_pred_dc(MpegEncContext * s, int n, int16_t **dc_val_ptr); 76static void mpeg4_encode_visual_object_header(MpegEncContext * s); 77static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number); 78 79static void mpeg4_decode_sprite_trajectory(MpegEncContext * s, GetBitContext *gb); 80static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding); 81 82#if CONFIG_ENCODERS 83static uint8_t uni_DCtab_lum_len[512]; 84static uint8_t uni_DCtab_chrom_len[512]; 85static uint16_t uni_DCtab_lum_bits[512]; 86static uint16_t uni_DCtab_chrom_bits[512]; 87 88static uint8_t mv_penalty[MAX_FCODE+1][MAX_MV*2+1]; 89static uint8_t fcode_tab[MAX_MV*2+1]; 90static uint8_t umv_fcode_tab[MAX_MV*2+1]; 91 92static uint32_t uni_mpeg4_intra_rl_bits[64*64*2*2]; 93static uint8_t uni_mpeg4_intra_rl_len [64*64*2*2]; 94static uint32_t uni_mpeg4_inter_rl_bits[64*64*2*2]; 95static uint8_t uni_mpeg4_inter_rl_len [64*64*2*2]; 96static uint8_t uni_h263_intra_aic_rl_len [64*64*2*2]; 97static uint8_t uni_h263_inter_rl_len [64*64*2*2]; 98//#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128 + (run)*256 + (level)) 99//#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run) + (level)*64) 100#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level)) 101 102/* mpeg4 103inter 104max level: 24/6 105max run: 53/63 106 107intra 108max level: 53/16 109max run: 29/41 110*/ 111#endif 112 113static uint8_t static_rl_table_store[5][2][2*MAX_RUN + MAX_LEVEL + 3]; 114 115#if 0 //3IV1 is quite rare and it slows things down a tiny bit 116#define IS_3IV1 s->codec_tag == AV_RL32("3IV1") 117#else 118#define IS_3IV1 0 119#endif 120 121int h263_get_picture_format(int width, int height) 122{ 123 int format; 124 125 if (width == 128 && height == 96) 126 format = 1; 127 else if (width == 176 && height == 144) 128 format = 2; 129 else if (width == 352 && height == 288) 130 format = 3; 131 else if (width == 704 && height == 576) 132 format = 4; 133 else if (width == 1408 && height == 1152) 134 format = 5; 135 else 136 format = 7; 137 return format; 138} 139 140static void show_pict_info(MpegEncContext *s){ 141 av_log(s->avctx, AV_LOG_DEBUG, "qp:%d %c size:%d rnd:%d%s%s%s%s%s%s%s%s%s %d/%d\n", 142 s->qscale, av_get_pict_type_char(s->pict_type), 143 s->gb.size_in_bits, 1-s->no_rounding, 144 s->obmc ? " AP" : "", 145 s->umvplus ? " UMV" : "", 146 s->h263_long_vectors ? " LONG" : "", 147 s->h263_plus ? " +" : "", 148 s->h263_aic ? " AIC" : "", 149 s->alt_inter_vlc ? " AIV" : "", 150 s->modified_quant ? " MQ" : "", 151 s->loop_filter ? " LOOP" : "", 152 s->h263_slice_structured ? " SS" : "", 153 s->avctx->time_base.den, s->avctx->time_base.num 154 ); 155} 156 157#if CONFIG_ENCODERS 158 159static void aspect_to_info(MpegEncContext * s, AVRational aspect){ 160 int i; 161 162 if(aspect.num==0) aspect= (AVRational){1,1}; 163 164 for(i=1; i<6; i++){ 165 if(av_cmp_q(pixel_aspect[i], aspect) == 0){ 166 s->aspect_ratio_info=i; 167 return; 168 } 169 } 170 171 s->aspect_ratio_info= FF_ASPECT_EXTENDED; 172} 173 174void ff_flv_encode_picture_header(MpegEncContext * s, int picture_number) 175{ 176 int format; 177 178 align_put_bits(&s->pb); 179 180 put_bits(&s->pb, 17, 1); 181 put_bits(&s->pb, 5, (s->h263_flv-1)); /* 0: h263 escape codes 1: 11-bit escape codes */ 182 put_bits(&s->pb, 8, (((int64_t)s->picture_number * 30 * s->avctx->time_base.num) / //FIXME use timestamp 183 s->avctx->time_base.den) & 0xff); /* TemporalReference */ 184 if (s->width == 352 && s->height == 288) 185 format = 2; 186 else if (s->width == 176 && s->height == 144) 187 format = 3; 188 else if (s->width == 128 && s->height == 96) 189 format = 4; 190 else if (s->width == 320 && s->height == 240) 191 format = 5; 192 else if (s->width == 160 && s->height == 120) 193 format = 6; 194 else if (s->width <= 255 && s->height <= 255) 195 format = 0; /* use 1 byte width & height */ 196 else 197 format = 1; /* use 2 bytes width & height */ 198 put_bits(&s->pb, 3, format); /* PictureSize */ 199 if (format == 0) { 200 put_bits(&s->pb, 8, s->width); 201 put_bits(&s->pb, 8, s->height); 202 } else if (format == 1) { 203 put_bits(&s->pb, 16, s->width); 204 put_bits(&s->pb, 16, s->height); 205 } 206 put_bits(&s->pb, 2, s->pict_type == FF_P_TYPE); /* PictureType */ 207 put_bits(&s->pb, 1, 1); /* DeblockingFlag: on */ 208 put_bits(&s->pb, 5, s->qscale); /* Quantizer */ 209 put_bits(&s->pb, 1, 0); /* ExtraInformation */ 210 211 if(s->h263_aic){ 212 s->y_dc_scale_table= 213 s->c_dc_scale_table= ff_aic_dc_scale_table; 214 }else{ 215 s->y_dc_scale_table= 216 s->c_dc_scale_table= ff_mpeg1_dc_scale_table; 217 } 218} 219 220void h263_encode_picture_header(MpegEncContext * s, int picture_number) 221{ 222 int format, coded_frame_rate, coded_frame_rate_base, i, temp_ref; 223 int best_clock_code=1; 224 int best_divisor=60; 225 int best_error= INT_MAX; 226 227 if(s->h263_plus){ 228 for(i=0; i<2; i++){ 229 int div, error; 230 div= (s->avctx->time_base.num*1800000LL + 500LL*s->avctx->time_base.den) / ((1000LL+i)*s->avctx->time_base.den); 231 div= av_clip(div, 1, 127); 232 error= FFABS(s->avctx->time_base.num*1800000LL - (1000LL+i)*s->avctx->time_base.den*div); 233 if(error < best_error){ 234 best_error= error; 235 best_divisor= div; 236 best_clock_code= i; 237 } 238 } 239 } 240 s->custom_pcf= best_clock_code!=1 || best_divisor!=60; 241 coded_frame_rate= 1800000; 242 coded_frame_rate_base= (1000+best_clock_code)*best_divisor; 243 244 align_put_bits(&s->pb); 245 246 /* Update the pointer to last GOB */ 247 s->ptr_lastgob = pbBufPtr(&s->pb); 248 put_bits(&s->pb, 22, 0x20); /* PSC */ 249 temp_ref= s->picture_number * (int64_t)coded_frame_rate * s->avctx->time_base.num / //FIXME use timestamp 250 (coded_frame_rate_base * (int64_t)s->avctx->time_base.den); 251 put_sbits(&s->pb, 8, temp_ref); /* TemporalReference */ 252 253 put_bits(&s->pb, 1, 1); /* marker */ 254 put_bits(&s->pb, 1, 0); /* h263 id */ 255 put_bits(&s->pb, 1, 0); /* split screen off */ 256 put_bits(&s->pb, 1, 0); /* camera off */ 257 put_bits(&s->pb, 1, 0); /* freeze picture release off */ 258 259 format = h263_get_picture_format(s->width, s->height); 260 if (!s->h263_plus) { 261 /* H.263v1 */ 262 put_bits(&s->pb, 3, format); 263 put_bits(&s->pb, 1, (s->pict_type == FF_P_TYPE)); 264 /* By now UMV IS DISABLED ON H.263v1, since the restrictions 265 of H.263v1 UMV implies to check the predicted MV after 266 calculation of the current MB to see if we're on the limits */ 267 put_bits(&s->pb, 1, 0); /* Unrestricted Motion Vector: off */ 268 put_bits(&s->pb, 1, 0); /* SAC: off */ 269 put_bits(&s->pb, 1, s->obmc); /* Advanced Prediction */ 270 put_bits(&s->pb, 1, 0); /* only I/P frames, no PB frame */ 271 put_bits(&s->pb, 5, s->qscale); 272 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */ 273 } else { 274 int ufep=1; 275 /* H.263v2 */ 276 /* H.263 Plus PTYPE */ 277 278 put_bits(&s->pb, 3, 7); 279 put_bits(&s->pb,3,ufep); /* Update Full Extended PTYPE */ 280 if (format == 7) 281 put_bits(&s->pb,3,6); /* Custom Source Format */ 282 else 283 put_bits(&s->pb, 3, format); 284 285 put_bits(&s->pb,1, s->custom_pcf); 286 put_bits(&s->pb,1, s->umvplus); /* Unrestricted Motion Vector */ 287 put_bits(&s->pb,1,0); /* SAC: off */ 288 put_bits(&s->pb,1,s->obmc); /* Advanced Prediction Mode */ 289 put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */ 290 put_bits(&s->pb,1,s->loop_filter); /* Deblocking Filter */ 291 put_bits(&s->pb,1,s->h263_slice_structured); /* Slice Structured */ 292 put_bits(&s->pb,1,0); /* Reference Picture Selection: off */ 293 put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */ 294 put_bits(&s->pb,1,s->alt_inter_vlc); /* Alternative Inter VLC */ 295 put_bits(&s->pb,1,s->modified_quant); /* Modified Quantization: */ 296 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */ 297 put_bits(&s->pb,3,0); /* Reserved */ 298 299 put_bits(&s->pb, 3, s->pict_type == FF_P_TYPE); 300 301 put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */ 302 put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */ 303 put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */ 304 put_bits(&s->pb,2,0); /* Reserved */ 305 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */ 306 307 /* This should be here if PLUSPTYPE */ 308 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */ 309 310 if (format == 7) { 311 /* Custom Picture Format (CPFMT) */ 312 aspect_to_info(s, s->avctx->sample_aspect_ratio); 313 314 put_bits(&s->pb,4,s->aspect_ratio_info); 315 put_bits(&s->pb,9,(s->width >> 2) - 1); 316 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */ 317 put_bits(&s->pb,9,(s->height >> 2)); 318 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){ 319 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num); 320 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den); 321 } 322 } 323 if(s->custom_pcf){ 324 if(ufep){ 325 put_bits(&s->pb, 1, best_clock_code); 326 put_bits(&s->pb, 7, best_divisor); 327 } 328 put_sbits(&s->pb, 2, temp_ref>>8); 329 } 330 331 /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */ 332 if (s->umvplus) 333// put_bits(&s->pb,1,1); /* Limited according tables of Annex D */ 334//FIXME check actual requested range 335 put_bits(&s->pb,2,1); /* unlimited */ 336 if(s->h263_slice_structured) 337 put_bits(&s->pb,2,0); /* no weird submodes */ 338 339 put_bits(&s->pb, 5, s->qscale); 340 } 341 342 put_bits(&s->pb, 1, 0); /* no PEI */ 343 344 if(s->h263_slice_structured){ 345 put_bits(&s->pb, 1, 1); 346 347 assert(s->mb_x == 0 && s->mb_y == 0); 348 ff_h263_encode_mba(s); 349 350 put_bits(&s->pb, 1, 1); 351 } 352 353 if(s->h263_aic){ 354 s->y_dc_scale_table= 355 s->c_dc_scale_table= ff_aic_dc_scale_table; 356 }else{ 357 s->y_dc_scale_table= 358 s->c_dc_scale_table= ff_mpeg1_dc_scale_table; 359 } 360} 361 362/** 363 * Encodes a group of blocks header. 364 */ 365void h263_encode_gob_header(MpegEncContext * s, int mb_line) 366{ 367 put_bits(&s->pb, 17, 1); /* GBSC */ 368 369 if(s->h263_slice_structured){ 370 put_bits(&s->pb, 1, 1); 371 372 ff_h263_encode_mba(s); 373 374 if(s->mb_num > 1583) 375 put_bits(&s->pb, 1, 1); 376 put_bits(&s->pb, 5, s->qscale); /* GQUANT */ 377 put_bits(&s->pb, 1, 1); 378 put_bits(&s->pb, 2, s->pict_type == FF_I_TYPE); /* GFID */ 379 }else{ 380 int gob_number= mb_line / s->gob_index; 381 382 put_bits(&s->pb, 5, gob_number); /* GN */ 383 put_bits(&s->pb, 2, s->pict_type == FF_I_TYPE); /* GFID */ 384 put_bits(&s->pb, 5, s->qscale); /* GQUANT */ 385 } 386} 387 388static inline int get_block_rate(MpegEncContext * s, DCTELEM block[64], int block_last_index, uint8_t scantable[64]){ 389 int last=0; 390 int j; 391 int rate=0; 392 393 for(j=1; j<=block_last_index; j++){ 394 const int index= scantable[j]; 395 int level= block[index]; 396 if(level){ 397 level+= 64; 398 if((level&(~127)) == 0){ 399 if(j<block_last_index) rate+= s->intra_ac_vlc_length [UNI_AC_ENC_INDEX(j-last-1, level)]; 400 else rate+= s->intra_ac_vlc_last_length[UNI_AC_ENC_INDEX(j-last-1, level)]; 401 }else 402 rate += s->ac_esc_length; 403 level-= 64; 404 405 last= j; 406 } 407 } 408 409 return rate; 410} 411 412static inline int decide_ac_pred(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6]) 413{ 414 int score= 0; 415 int i, n; 416 int8_t * const qscale_table= s->current_picture.qscale_table; 417 418 memcpy(zigzag_last_index, s->block_last_index, sizeof(int)*6); 419 420 for(n=0; n<6; n++){ 421 int16_t *ac_val, *ac_val1; 422 423 score -= get_block_rate(s, block[n], s->block_last_index[n], s->intra_scantable.permutated); 424 425 ac_val = s->ac_val[0][0] + s->block_index[n] * 16; 426 ac_val1= ac_val; 427 if(dir[n]){ 428 const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride; 429 /* top prediction */ 430 ac_val-= s->block_wrap[n]*16; 431 if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){ 432 /* same qscale */ 433 for(i=1; i<8; i++){ 434 const int level= block[n][s->dsp.idct_permutation[i ]]; 435 block[n][s->dsp.idct_permutation[i ]] = level - ac_val[i+8]; 436 ac_val1[i ]= block[n][s->dsp.idct_permutation[i<<3]]; 437 ac_val1[i+8]= level; 438 } 439 }else{ 440 /* different qscale, we must rescale */ 441 for(i=1; i<8; i++){ 442 const int level= block[n][s->dsp.idct_permutation[i ]]; 443 block[n][s->dsp.idct_permutation[i ]] = level - ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale); 444 ac_val1[i ]= block[n][s->dsp.idct_permutation[i<<3]]; 445 ac_val1[i+8]= level; 446 } 447 } 448 st[n]= s->intra_h_scantable.permutated; 449 }else{ 450 const int xy= s->mb_x-1 + s->mb_y*s->mb_stride; 451 /* left prediction */ 452 ac_val-= 16; 453 if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){ 454 /* same qscale */ 455 for(i=1; i<8; i++){ 456 const int level= block[n][s->dsp.idct_permutation[i<<3]]; 457 block[n][s->dsp.idct_permutation[i<<3]]= level - ac_val[i]; 458 ac_val1[i ]= level; 459 ac_val1[i+8]= block[n][s->dsp.idct_permutation[i ]]; 460 } 461 }else{ 462 /* different qscale, we must rescale */ 463 for(i=1; i<8; i++){ 464 const int level= block[n][s->dsp.idct_permutation[i<<3]]; 465 block[n][s->dsp.idct_permutation[i<<3]]= level - ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale); 466 ac_val1[i ]= level; 467 ac_val1[i+8]= block[n][s->dsp.idct_permutation[i ]]; 468 } 469 } 470 st[n]= s->intra_v_scantable.permutated; 471 } 472 473 for(i=63; i>0; i--) //FIXME optimize 474 if(block[n][ st[n][i] ]) break; 475 s->block_last_index[n]= i; 476 477 score += get_block_rate(s, block[n], s->block_last_index[n], st[n]); 478 } 479 480 return score < 0; 481} 482 483static inline void restore_ac_coeffs(MpegEncContext * s, DCTELEM block[6][64], int dir[6], uint8_t *st[6], int zigzag_last_index[6]) 484{ 485 int i, n; 486 memcpy(s->block_last_index, zigzag_last_index, sizeof(int)*6); 487 488 for(n=0; n<6; n++){ 489 int16_t *ac_val = s->ac_val[0][0] + s->block_index[n] * 16; 490 491 st[n]= s->intra_scantable.permutated; 492 if(dir[n]){ 493 /* top prediction */ 494 for(i=1; i<8; i++){ 495 block[n][s->dsp.idct_permutation[i ]] = ac_val[i+8]; 496 } 497 }else{ 498 /* left prediction */ 499 for(i=1; i<8; i++){ 500 block[n][s->dsp.idct_permutation[i<<3]]= ac_val[i ]; 501 } 502 } 503 } 504} 505 506/** 507 * init s->current_picture.qscale_table from s->lambda_table 508 */ 509static void ff_init_qscale_tab(MpegEncContext *s){ 510 int8_t * const qscale_table= s->current_picture.qscale_table; 511 int i; 512 513 for(i=0; i<s->mb_num; i++){ 514 unsigned int lam= s->lambda_table[ s->mb_index2xy[i] ]; 515 int qp= (lam*139 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7); 516 qscale_table[ s->mb_index2xy[i] ]= av_clip(qp, s->avctx->qmin, s->avctx->qmax); 517 } 518} 519 520/** 521 * modify qscale so that encoding is acually possible in h263 (limit difference to -2..2) 522 */ 523void ff_clean_h263_qscales(MpegEncContext *s){ 524 int i; 525 int8_t * const qscale_table= s->current_picture.qscale_table; 526 527 ff_init_qscale_tab(s); 528 529 for(i=1; i<s->mb_num; i++){ 530 if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i-1] ] >2) 531 qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i-1] ]+2; 532 } 533 for(i=s->mb_num-2; i>=0; i--){ 534 if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i+1] ] >2) 535 qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i+1] ]+2; 536 } 537 538 if(s->codec_id != CODEC_ID_H263P){ 539 for(i=1; i<s->mb_num; i++){ 540 int mb_xy= s->mb_index2xy[i]; 541 542 if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_INTER4V)){ 543 s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_INTER; 544 } 545 } 546 } 547} 548 549/** 550 * modify mb_type & qscale so that encoding is acually possible in mpeg4 551 */ 552void ff_clean_mpeg4_qscales(MpegEncContext *s){ 553 int i; 554 int8_t * const qscale_table= s->current_picture.qscale_table; 555 556 ff_clean_h263_qscales(s); 557 558 if(s->pict_type== FF_B_TYPE){ 559 int odd=0; 560 /* ok, come on, this isn't funny anymore, there's more code for handling this mpeg4 mess than for the actual adaptive quantization */ 561 562 for(i=0; i<s->mb_num; i++){ 563 int mb_xy= s->mb_index2xy[i]; 564 odd += qscale_table[mb_xy]&1; 565 } 566 567 if(2*odd > s->mb_num) odd=1; 568 else odd=0; 569 570 for(i=0; i<s->mb_num; i++){ 571 int mb_xy= s->mb_index2xy[i]; 572 if((qscale_table[mb_xy]&1) != odd) 573 qscale_table[mb_xy]++; 574 if(qscale_table[mb_xy] > 31) 575 qscale_table[mb_xy]= 31; 576 } 577 578 for(i=1; i<s->mb_num; i++){ 579 int mb_xy= s->mb_index2xy[i]; 580 if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_DIRECT)){ 581 s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_BIDIR; 582 } 583 } 584 } 585} 586 587#endif //CONFIG_ENCODERS 588 589#define tab_size ((signed)FF_ARRAY_ELEMS(s->direct_scale_mv[0])) 590#define tab_bias (tab_size/2) 591 592void ff_mpeg4_init_direct_mv(MpegEncContext *s){ 593 int i; 594 for(i=0; i<tab_size; i++){ 595 s->direct_scale_mv[0][i] = (i-tab_bias)*s->pb_time/s->pp_time; 596 s->direct_scale_mv[1][i] = (i-tab_bias)*(s->pb_time-s->pp_time)/s->pp_time; 597 } 598} 599 600static inline void ff_mpeg4_set_one_direct_mv(MpegEncContext *s, int mx, int my, int i){ 601 int xy= s->block_index[i]; 602 uint16_t time_pp= s->pp_time; 603 uint16_t time_pb= s->pb_time; 604 int p_mx, p_my; 605 606 p_mx= s->next_picture.motion_val[0][xy][0]; 607 if((unsigned)(p_mx + tab_bias) < tab_size){ 608 s->mv[0][i][0] = s->direct_scale_mv[0][p_mx + tab_bias] + mx; 609 s->mv[1][i][0] = mx ? s->mv[0][i][0] - p_mx 610 : s->direct_scale_mv[1][p_mx + tab_bias]; 611 }else{ 612 s->mv[0][i][0] = p_mx*time_pb/time_pp + mx; 613 s->mv[1][i][0] = mx ? s->mv[0][i][0] - p_mx 614 : p_mx*(time_pb - time_pp)/time_pp; 615 } 616 p_my= s->next_picture.motion_val[0][xy][1]; 617 if((unsigned)(p_my + tab_bias) < tab_size){ 618 s->mv[0][i][1] = s->direct_scale_mv[0][p_my + tab_bias] + my; 619 s->mv[1][i][1] = my ? s->mv[0][i][1] - p_my 620 : s->direct_scale_mv[1][p_my + tab_bias]; 621 }else{ 622 s->mv[0][i][1] = p_my*time_pb/time_pp + my; 623 s->mv[1][i][1] = my ? s->mv[0][i][1] - p_my 624 : p_my*(time_pb - time_pp)/time_pp; 625 } 626} 627 628#undef tab_size 629#undef tab_bias 630 631/** 632 * 633 * @return the mb_type 634 */ 635int ff_mpeg4_set_direct_mv(MpegEncContext *s, int mx, int my){ 636 const int mb_index= s->mb_x + s->mb_y*s->mb_stride; 637 const int colocated_mb_type= s->next_picture.mb_type[mb_index]; 638 uint16_t time_pp= s->pp_time; 639 uint16_t time_pb= s->pb_time; 640 int i; 641 642 //FIXME avoid divides 643 // try special case with shifts for 1 and 3 B-frames? 644 645 if(IS_8X8(colocated_mb_type)){ 646 s->mv_type = MV_TYPE_8X8; 647 for(i=0; i<4; i++){ 648 ff_mpeg4_set_one_direct_mv(s, mx, my, i); 649 } 650 return MB_TYPE_DIRECT2 | MB_TYPE_8x8 | MB_TYPE_L0L1; 651 } else if(IS_INTERLACED(colocated_mb_type)){ 652 s->mv_type = MV_TYPE_FIELD; 653 for(i=0; i<2; i++){ 654 int field_select= s->next_picture.ref_index[0][s->block_index[2*i]]; 655 s->field_select[0][i]= field_select; 656 s->field_select[1][i]= i; 657 if(s->top_field_first){ 658 time_pp= s->pp_field_time - field_select + i; 659 time_pb= s->pb_field_time - field_select + i; 660 }else{ 661 time_pp= s->pp_field_time + field_select - i; 662 time_pb= s->pb_field_time + field_select - i; 663 } 664 s->mv[0][i][0] = s->p_field_mv_table[i][0][mb_index][0]*time_pb/time_pp + mx; 665 s->mv[0][i][1] = s->p_field_mv_table[i][0][mb_index][1]*time_pb/time_pp + my; 666 s->mv[1][i][0] = mx ? s->mv[0][i][0] - s->p_field_mv_table[i][0][mb_index][0] 667 : s->p_field_mv_table[i][0][mb_index][0]*(time_pb - time_pp)/time_pp; 668 s->mv[1][i][1] = my ? s->mv[0][i][1] - s->p_field_mv_table[i][0][mb_index][1] 669 : s->p_field_mv_table[i][0][mb_index][1]*(time_pb - time_pp)/time_pp; 670 } 671 return MB_TYPE_DIRECT2 | MB_TYPE_16x8 | MB_TYPE_L0L1 | MB_TYPE_INTERLACED; 672 }else{ 673 ff_mpeg4_set_one_direct_mv(s, mx, my, 0); 674 s->mv[0][1][0] = s->mv[0][2][0] = s->mv[0][3][0] = s->mv[0][0][0]; 675 s->mv[0][1][1] = s->mv[0][2][1] = s->mv[0][3][1] = s->mv[0][0][1]; 676 s->mv[1][1][0] = s->mv[1][2][0] = s->mv[1][3][0] = s->mv[1][0][0]; 677 s->mv[1][1][1] = s->mv[1][2][1] = s->mv[1][3][1] = s->mv[1][0][1]; 678 if((s->avctx->workaround_bugs & FF_BUG_DIRECT_BLOCKSIZE) || !s->quarter_sample) 679 s->mv_type= MV_TYPE_16X16; 680 else 681 s->mv_type= MV_TYPE_8X8; 682 return MB_TYPE_DIRECT2 | MB_TYPE_16x16 | MB_TYPE_L0L1; //Note see prev line 683 } 684} 685 686void ff_h263_update_motion_val(MpegEncContext * s){ 687 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x; 688 //FIXME a lot of that is only needed for !low_delay 689 const int wrap = s->b8_stride; 690 const int xy = s->block_index[0]; 691 692 s->current_picture.mbskip_table[mb_xy]= s->mb_skipped; 693 694 if(s->mv_type != MV_TYPE_8X8){ 695 int motion_x, motion_y; 696 if (s->mb_intra) { 697 motion_x = 0; 698 motion_y = 0; 699 } else if (s->mv_type == MV_TYPE_16X16) { 700 motion_x = s->mv[0][0][0]; 701 motion_y = s->mv[0][0][1]; 702 } else /*if (s->mv_type == MV_TYPE_FIELD)*/ { 703 int i; 704 motion_x = s->mv[0][0][0] + s->mv[0][1][0]; 705 motion_y = s->mv[0][0][1] + s->mv[0][1][1]; 706 motion_x = (motion_x>>1) | (motion_x&1); 707 for(i=0; i<2; i++){ 708 s->p_field_mv_table[i][0][mb_xy][0]= s->mv[0][i][0]; 709 s->p_field_mv_table[i][0][mb_xy][1]= s->mv[0][i][1]; 710 } 711 s->current_picture.ref_index[0][xy ]= 712 s->current_picture.ref_index[0][xy + 1]= s->field_select[0][0]; 713 s->current_picture.ref_index[0][xy + wrap ]= 714 s->current_picture.ref_index[0][xy + wrap + 1]= s->field_select[0][1]; 715 } 716 717 /* no update if 8X8 because it has been done during parsing */ 718 s->current_picture.motion_val[0][xy][0] = motion_x; 719 s->current_picture.motion_val[0][xy][1] = motion_y; 720 s->current_picture.motion_val[0][xy + 1][0] = motion_x; 721 s->current_picture.motion_val[0][xy + 1][1] = motion_y; 722 s->current_picture.motion_val[0][xy + wrap][0] = motion_x; 723 s->current_picture.motion_val[0][xy + wrap][1] = motion_y; 724 s->current_picture.motion_val[0][xy + 1 + wrap][0] = motion_x; 725 s->current_picture.motion_val[0][xy + 1 + wrap][1] = motion_y; 726 } 727 728 if(s->encoding){ //FIXME encoding MUST be cleaned up 729 if (s->mv_type == MV_TYPE_8X8) 730 s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_8x8; 731 else if(s->mb_intra) 732 s->current_picture.mb_type[mb_xy]= MB_TYPE_INTRA; 733 else 734 s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_16x16; 735 } 736} 737 738#if CONFIG_ENCODERS 739 740static inline int h263_get_motion_length(MpegEncContext * s, int val, int f_code){ 741 int l, bit_size, code; 742 743 if (val == 0) { 744 return mvtab[0][1]; 745 } else { 746 bit_size = f_code - 1; 747 /* modulo encoding */ 748 l= INT_BIT - 6 - bit_size; 749 val = (val<<l)>>l; 750 val--; 751 code = (val >> bit_size) + 1; 752 753 return mvtab[code][1] + 1 + bit_size; 754 } 755} 756 757static inline void ff_h263_encode_motion_vector(MpegEncContext * s, int x, int y, int f_code){ 758 if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){ 759 skip_put_bits(&s->pb, 760 h263_get_motion_length(s, x, f_code) 761 +h263_get_motion_length(s, y, f_code)); 762 }else{ 763 ff_h263_encode_motion(s, x, f_code); 764 ff_h263_encode_motion(s, y, f_code); 765 } 766} 767 768static inline int get_p_cbp(MpegEncContext * s, 769 DCTELEM block[6][64], 770 int motion_x, int motion_y){ 771 int cbp, i; 772 773 if(s->flags & CODEC_FLAG_CBP_RD){ 774 int best_cbpy_score= INT_MAX; 775 int best_cbpc_score= INT_MAX; 776 int cbpc = (-1), cbpy= (-1); 777 const int offset= (s->mv_type==MV_TYPE_16X16 ? 0 : 16) + (s->dquant ? 8 : 0); 778 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6); 779 780 for(i=0; i<4; i++){ 781 int score= inter_MCBPC_bits[i + offset] * lambda; 782 if(i&1) score += s->coded_score[5]; 783 if(i&2) score += s->coded_score[4]; 784 785 if(score < best_cbpc_score){ 786 best_cbpc_score= score; 787 cbpc= i; 788 } 789 } 790 791 for(i=0; i<16; i++){ 792 int score= cbpy_tab[i ^ 0xF][1] * lambda; 793 if(i&1) score += s->coded_score[3]; 794 if(i&2) score += s->coded_score[2]; 795 if(i&4) score += s->coded_score[1]; 796 if(i&8) score += s->coded_score[0]; 797 798 if(score < best_cbpy_score){ 799 best_cbpy_score= score; 800 cbpy= i; 801 } 802 } 803 cbp= cbpc + 4*cbpy; 804 if ((motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16){ 805 if(best_cbpy_score + best_cbpc_score + 2*lambda >= 0) 806 cbp= 0; 807 } 808 809 for (i = 0; i < 6; i++) { 810 if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){ 811 s->block_last_index[i]= -1; 812 s->dsp.clear_block(s->block[i]); 813 } 814 } 815 }else{ 816 cbp= 0; 817 for (i = 0; i < 6; i++) { 818 if (s->block_last_index[i] >= 0) 819 cbp |= 1 << (5 - i); 820 } 821 } 822 return cbp; 823} 824 825static inline int get_b_cbp(MpegEncContext * s, DCTELEM block[6][64], 826 int motion_x, int motion_y, int mb_type){ 827 int cbp=0, i; 828 829 if(s->flags & CODEC_FLAG_CBP_RD){ 830 int score=0; 831 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6); 832 833 for(i=0; i<6; i++){ 834 if(s->coded_score[i] < 0){ 835 score += s->coded_score[i]; 836 cbp |= 1 << (5 - i); 837 } 838 } 839 840 if(cbp){ 841 int zero_score= -6; 842 if ((motion_x | motion_y | s->dquant | mb_type) == 0){ 843 zero_score-= 4; //2*MV + mb_type + cbp bit 844 } 845 846 zero_score*= lambda; 847 if(zero_score <= score){ 848 cbp=0; 849 } 850 } 851 852 for (i = 0; i < 6; i++) { 853 if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i))&1)==0 ){ 854 s->block_last_index[i]= -1; 855 s->dsp.clear_block(s->block[i]); 856 } 857 } 858 }else{ 859 for (i = 0; i < 6; i++) { 860 if (s->block_last_index[i] >= 0) 861 cbp |= 1 << (5 - i); 862 } 863 } 864 return cbp; 865} 866 867static inline void mpeg4_encode_blocks(MpegEncContext * s, DCTELEM block[6][64], int intra_dc[6], 868 uint8_t **scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb){ 869 int i; 870 871 if(scan_table){ 872 if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){ 873 for (i = 0; i < 6; i++) { 874 skip_put_bits(&s->pb, mpeg4_get_block_length(s, block[i], i, intra_dc[i], scan_table[i])); 875 } 876 }else{ 877 /* encode each block */ 878 for (i = 0; i < 6; i++) { 879 mpeg4_encode_block(s, block[i], i, intra_dc[i], scan_table[i], dc_pb, ac_pb); 880 } 881 } 882 }else{ 883 if(s->flags2 & CODEC_FLAG2_NO_OUTPUT){ 884 for (i = 0; i < 6; i++) { 885 skip_put_bits(&s->pb, mpeg4_get_block_length(s, block[i], i, 0, s->intra_scantable.permutated)); 886 } 887 }else{ 888 /* encode each block */ 889 for (i = 0; i < 6; i++) { 890 mpeg4_encode_block(s, block[i], i, 0, s->intra_scantable.permutated, dc_pb, ac_pb); 891 } 892 } 893 } 894} 895 896static const int dquant_code[5]= {1,0,9,2,3}; 897 898void mpeg4_encode_mb(MpegEncContext * s, 899 DCTELEM block[6][64], 900 int motion_x, int motion_y) 901{ 902 int cbpc, cbpy, pred_x, pred_y; 903 PutBitContext * const pb2 = s->data_partitioning ? &s->pb2 : &s->pb; 904 PutBitContext * const tex_pb = s->data_partitioning && s->pict_type!=FF_B_TYPE ? &s->tex_pb : &s->pb; 905 PutBitContext * const dc_pb = s->data_partitioning && s->pict_type!=FF_I_TYPE ? &s->pb2 : &s->pb; 906 const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1) && !s->data_partitioning ? 1 : 0; 907 908 // printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y); 909 if (!s->mb_intra) { 910 int i, cbp; 911 912 if(s->pict_type==FF_B_TYPE){ 913 static const int mb_type_table[8]= {-1, 3, 2, 1,-1,-1,-1, 0}; /* convert from mv_dir to type */ 914 int mb_type= mb_type_table[s->mv_dir]; 915 916 if(s->mb_x==0){ 917 for(i=0; i<2; i++){ 918 s->last_mv[i][0][0]= 919 s->last_mv[i][0][1]= 920 s->last_mv[i][1][0]= 921 s->last_mv[i][1][1]= 0; 922 } 923 } 924 925 assert(s->dquant>=-2 && s->dquant<=2); 926 assert((s->dquant&1)==0); 927 assert(mb_type>=0); 928 929 /* nothing to do if this MB was skipped in the next P Frame */ 930 if(s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]){ //FIXME avoid DCT & ... 931 s->skip_count++; 932 s->mv[0][0][0]= 933 s->mv[0][0][1]= 934 s->mv[1][0][0]= 935 s->mv[1][0][1]= 0; 936 s->mv_dir= MV_DIR_FORWARD; //doesn't matter 937 s->qscale -= s->dquant; 938// s->mb_skipped=1; 939 940 return; 941 } 942 943 cbp= get_b_cbp(s, block, motion_x, motion_y, mb_type); 944 945 if ((cbp | motion_x | motion_y | mb_type) ==0) { 946 /* direct MB with MV={0,0} */ 947 assert(s->dquant==0); 948 949 put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */ 950 951 if(interleaved_stats){ 952 s->misc_bits++; 953 s->last_bits++; 954 } 955 s->skip_count++; 956 return; 957 } 958 959 put_bits(&s->pb, 1, 0); /* mb coded modb1=0 */ 960 put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge 961 put_bits(&s->pb, mb_type+1, 1); // this table is so simple that we don't need it :) 962 if(cbp) put_bits(&s->pb, 6, cbp); 963 964 if(cbp && mb_type){ 965 if(s->dquant) 966 put_bits(&s->pb, 2, (s->dquant>>2)+3); 967 else 968 put_bits(&s->pb, 1, 0); 969 }else 970 s->qscale -= s->dquant; 971 972 if(!s->progressive_sequence){ 973 if(cbp) 974 put_bits(&s->pb, 1, s->interlaced_dct); 975 if(mb_type) // not direct mode 976 put_bits(&s->pb, 1, s->mv_type == MV_TYPE_FIELD); 977 } 978 979 if(interleaved_stats){ 980 s->misc_bits+= get_bits_diff(s); 981 } 982 983 if(mb_type == 0){ 984 assert(s->mv_dir & MV_DIRECT); 985 ff_h263_encode_motion_vector(s, motion_x, motion_y, 1); 986 s->b_count++; 987 s->f_count++; 988 }else{ 989 assert(mb_type > 0 && mb_type < 4); 990 if(s->mv_type != MV_TYPE_FIELD){ 991 if(s->mv_dir & MV_DIR_FORWARD){ 992 ff_h263_encode_motion_vector(s, s->mv[0][0][0] - s->last_mv[0][0][0], 993 s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code); 994 s->last_mv[0][0][0]= s->last_mv[0][1][0]= s->mv[0][0][0]; 995 s->last_mv[0][0][1]= s->last_mv[0][1][1]= s->mv[0][0][1]; 996 s->f_count++; 997 } 998 if(s->mv_dir & MV_DIR_BACKWARD){ 999 ff_h263_encode_motion_vector(s, s->mv[1][0][0] - s->last_mv[1][0][0], 1000 s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code); 1001 s->last_mv[1][0][0]= s->last_mv[1][1][0]= s->mv[1][0][0]; 1002 s->last_mv[1][0][1]= s->last_mv[1][1][1]= s->mv[1][0][1]; 1003 s->b_count++; 1004 } 1005 }else{ 1006 if(s->mv_dir & MV_DIR_FORWARD){ 1007 put_bits(&s->pb, 1, s->field_select[0][0]); 1008 put_bits(&s->pb, 1, s->field_select[0][1]); 1009 } 1010 if(s->mv_dir & MV_DIR_BACKWARD){ 1011 put_bits(&s->pb, 1, s->field_select[1][0]); 1012 put_bits(&s->pb, 1, s->field_select[1][1]); 1013 } 1014 if(s->mv_dir & MV_DIR_FORWARD){ 1015 for(i=0; i<2; i++){ 1016 ff_h263_encode_motion_vector(s, s->mv[0][i][0] - s->last_mv[0][i][0] , 1017 s->mv[0][i][1] - s->last_mv[0][i][1]/2, s->f_code); 1018 s->last_mv[0][i][0]= s->mv[0][i][0]; 1019 s->last_mv[0][i][1]= s->mv[0][i][1]*2; 1020 } 1021 s->f_count++; 1022 } 1023 if(s->mv_dir & MV_DIR_BACKWARD){ 1024 for(i=0; i<2; i++){ 1025 ff_h263_encode_motion_vector(s, s->mv[1][i][0] - s->last_mv[1][i][0] , 1026 s->mv[1][i][1] - s->last_mv[1][i][1]/2, s->b_code); 1027 s->last_mv[1][i][0]= s->mv[1][i][0]; 1028 s->last_mv[1][i][1]= s->mv[1][i][1]*2; 1029 } 1030 s->b_count++; 1031 } 1032 } 1033 } 1034 1035 if(interleaved_stats){ 1036 s->mv_bits+= get_bits_diff(s); 1037 } 1038 1039 mpeg4_encode_blocks(s, block, NULL, NULL, NULL, &s->pb); 1040 1041 if(interleaved_stats){ 1042 s->p_tex_bits+= get_bits_diff(s); 1043 } 1044 1045 }else{ /* s->pict_type==FF_B_TYPE */ 1046 cbp= get_p_cbp(s, block, motion_x, motion_y); 1047 1048 if ((cbp | motion_x | motion_y | s->dquant) == 0 && s->mv_type==MV_TYPE_16X16) { 1049 /* check if the B frames can skip it too, as we must skip it if we skip here 1050 why didn't they just compress the skip-mb bits instead of reusing them ?! */ 1051 if(s->max_b_frames>0){ 1052 int i; 1053 int x,y, offset; 1054 uint8_t *p_pic; 1055 1056 x= s->mb_x*16; 1057 y= s->mb_y*16; 1058 if(x+16 > s->width) x= s->width-16; 1059 if(y+16 > s->height) y= s->height-16; 1060 1061 offset= x + y*s->linesize; 1062 p_pic= s->new_picture.data[0] + offset; 1063 1064 s->mb_skipped=1; 1065 for(i=0; i<s->max_b_frames; i++){ 1066 uint8_t *b_pic; 1067 int diff; 1068 Picture *pic= s->reordered_input_picture[i+1]; 1069 1070 if(pic==NULL || pic->pict_type!=FF_B_TYPE) break; 1071 1072 b_pic= pic->data[0] + offset; 1073 if(pic->type != FF_BUFFER_TYPE_SHARED) 1074 b_pic+= INPLACE_OFFSET; 1075 diff= s->dsp.sad[0](NULL, p_pic, b_pic, s->linesize, 16); 1076 if(diff>s->qscale*70){ //FIXME check that 70 is optimal 1077 s->mb_skipped=0; 1078 break; 1079 } 1080 } 1081 }else 1082 s->mb_skipped=1; 1083 1084 if(s->mb_skipped==1){ 1085 /* skip macroblock */ 1086 put_bits(&s->pb, 1, 1); 1087 1088 if(interleaved_stats){ 1089 s->misc_bits++; 1090 s->last_bits++; 1091 } 1092 s->skip_count++; 1093 1094 return; 1095 } 1096 } 1097 1098 put_bits(&s->pb, 1, 0); /* mb coded */ 1099 cbpc = cbp & 3; 1100 cbpy = cbp >> 2; 1101 cbpy ^= 0xf; 1102 if(s->mv_type==MV_TYPE_16X16){ 1103 if(s->dquant) cbpc+= 8; 1104 put_bits(&s->pb, 1105 inter_MCBPC_bits[cbpc], 1106 inter_MCBPC_code[cbpc]); 1107 1108 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); 1109 if(s->dquant) 1110 put_bits(pb2, 2, dquant_code[s->dquant+2]); 1111 1112 if(!s->progressive_sequence){ 1113 if(cbp) 1114 put_bits(pb2, 1, s->interlaced_dct); 1115 put_bits(pb2, 1, 0); 1116 } 1117 1118 if(interleaved_stats){ 1119 s->misc_bits+= get_bits_diff(s); 1120 } 1121 1122 /* motion vectors: 16x16 mode */ 1123 h263_pred_motion(s, 0, 0, &pred_x, &pred_y); 1124 1125 ff_h263_encode_motion_vector(s, motion_x - pred_x, 1126 motion_y - pred_y, s->f_code); 1127 }else if(s->mv_type==MV_TYPE_FIELD){ 1128 if(s->dquant) cbpc+= 8; 1129 put_bits(&s->pb, 1130 inter_MCBPC_bits[cbpc], 1131 inter_MCBPC_code[cbpc]); 1132 1133 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); 1134 if(s->dquant) 1135 put_bits(pb2, 2, dquant_code[s->dquant+2]); 1136 1137 assert(!s->progressive_sequence); 1138 if(cbp) 1139 put_bits(pb2, 1, s->interlaced_dct); 1140 put_bits(pb2, 1, 1); 1141 1142 if(interleaved_stats){ 1143 s->misc_bits+= get_bits_diff(s); 1144 } 1145 1146 /* motion vectors: 16x8 interlaced mode */ 1147 h263_pred_motion(s, 0, 0, &pred_x, &pred_y); 1148 pred_y /=2; 1149 1150 put_bits(&s->pb, 1, s->field_select[0][0]); 1151 put_bits(&s->pb, 1, s->field_select[0][1]); 1152 1153 ff_h263_encode_motion_vector(s, s->mv[0][0][0] - pred_x, 1154 s->mv[0][0][1] - pred_y, s->f_code); 1155 ff_h263_encode_motion_vector(s, s->mv[0][1][0] - pred_x, 1156 s->mv[0][1][1] - pred_y, s->f_code); 1157 }else{ 1158 assert(s->mv_type==MV_TYPE_8X8); 1159 put_bits(&s->pb, 1160 inter_MCBPC_bits[cbpc+16], 1161 inter_MCBPC_code[cbpc+16]); 1162 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); 1163 1164 if(!s->progressive_sequence){ 1165 if(cbp) 1166 put_bits(pb2, 1, s->interlaced_dct); 1167 } 1168 1169 if(interleaved_stats){ 1170 s->misc_bits+= get_bits_diff(s); 1171 } 1172 1173 for(i=0; i<4; i++){ 1174 /* motion vectors: 8x8 mode*/ 1175 h263_pred_motion(s, i, 0, &pred_x, &pred_y); 1176 1177 ff_h263_encode_motion_vector(s, s->current_picture.motion_val[0][ s->block_index[i] ][0] - pred_x, 1178 s->current_picture.motion_val[0][ s->block_index[i] ][1] - pred_y, s->f_code); 1179 } 1180 } 1181 1182 if(interleaved_stats){ 1183 s->mv_bits+= get_bits_diff(s); 1184 } 1185 1186 mpeg4_encode_blocks(s, block, NULL, NULL, NULL, tex_pb); 1187 1188 if(interleaved_stats){ 1189 s->p_tex_bits+= get_bits_diff(s); 1190 } 1191 s->f_count++; 1192 } 1193 } else { 1194 int cbp; 1195 int dc_diff[6]; //dc values with the dc prediction subtracted 1196 int dir[6]; //prediction direction 1197 int zigzag_last_index[6]; 1198 uint8_t *scan_table[6]; 1199 int i; 1200 1201 for(i=0; i<6; i++){ 1202 dc_diff[i]= ff_mpeg4_pred_dc(s, i, block[i][0], &dir[i], 1); 1203 } 1204 1205 if(s->flags & CODEC_FLAG_AC_PRED){ 1206 s->ac_pred= decide_ac_pred(s, block, dir, scan_table, zigzag_last_index); 1207 if(!s->ac_pred) 1208 restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index); 1209 }else{ 1210 for(i=0; i<6; i++) 1211 scan_table[i]= s->intra_scantable.permutated; 1212 } 1213 1214 /* compute cbp */ 1215 cbp = 0; 1216 for (i = 0; i < 6; i++) { 1217 if (s->block_last_index[i] >= 1) 1218 cbp |= 1 << (5 - i); 1219 } 1220 1221 cbpc = cbp & 3; 1222 if (s->pict_type == FF_I_TYPE) { 1223 if(s->dquant) cbpc+=4; 1224 put_bits(&s->pb, 1225 intra_MCBPC_bits[cbpc], 1226 intra_MCBPC_code[cbpc]); 1227 } else { 1228 if(s->dquant) cbpc+=8; 1229 put_bits(&s->pb, 1, 0); /* mb coded */ 1230 put_bits(&s->pb, 1231 inter_MCBPC_bits[cbpc + 4], 1232 inter_MCBPC_code[cbpc + 4]); 1233 } 1234 put_bits(pb2, 1, s->ac_pred); 1235 cbpy = cbp >> 2; 1236 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); 1237 if(s->dquant) 1238 put_bits(dc_pb, 2, dquant_code[s->dquant+2]); 1239 1240 if(!s->progressive_sequence){ 1241 put_bits(dc_pb, 1, s->interlaced_dct); 1242 } 1243 1244 if(interleaved_stats){ 1245 s->misc_bits+= get_bits_diff(s); 1246 } 1247 1248 mpeg4_encode_blocks(s, block, dc_diff, scan_table, dc_pb, tex_pb); 1249 1250 if(interleaved_stats){ 1251 s->i_tex_bits+= get_bits_diff(s); 1252 } 1253 s->i_count++; 1254 1255 /* restore ac coeffs & last_index stuff if we messed them up with the prediction */ 1256 if(s->ac_pred) 1257 restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index); 1258 } 1259} 1260 1261void h263_encode_mb(MpegEncContext * s, 1262 DCTELEM block[6][64], 1263 int motion_x, int motion_y) 1264{ 1265 int cbpc, cbpy, i, cbp, pred_x, pred_y; 1266 int16_t pred_dc; 1267 int16_t rec_intradc[6]; 1268 int16_t *dc_ptr[6]; 1269 const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1); 1270 1271 //printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y); 1272 if (!s->mb_intra) { 1273 /* compute cbp */ 1274 cbp= get_p_cbp(s, block, motion_x, motion_y); 1275 1276 if ((cbp | motion_x | motion_y | s->dquant | (s->mv_type - MV_TYPE_16X16)) == 0) { 1277 /* skip macroblock */ 1278 put_bits(&s->pb, 1, 1); 1279 if(interleaved_stats){ 1280 s->misc_bits++; 1281 s->last_bits++; 1282 } 1283 s->skip_count++; 1284 1285 return; 1286 } 1287 put_bits(&s->pb, 1, 0); /* mb coded */ 1288 1289 cbpc = cbp & 3; 1290 cbpy = cbp >> 2; 1291 if(s->alt_inter_vlc==0 || cbpc!=3) 1292 cbpy ^= 0xF; 1293 if(s->dquant) cbpc+= 8; 1294 if(s->mv_type==MV_TYPE_16X16){ 1295 put_bits(&s->pb, 1296 inter_MCBPC_bits[cbpc], 1297 inter_MCBPC_code[cbpc]); 1298 1299 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); 1300 if(s->dquant) 1301 put_bits(&s->pb, 2, dquant_code[s->dquant+2]); 1302 1303 if(interleaved_stats){ 1304 s->misc_bits+= get_bits_diff(s); 1305 } 1306 1307 /* motion vectors: 16x16 mode */ 1308 h263_pred_motion(s, 0, 0, &pred_x, &pred_y); 1309 1310 if (!s->umvplus) { 1311 ff_h263_encode_motion_vector(s, motion_x - pred_x, 1312 motion_y - pred_y, 1); 1313 } 1314 else { 1315 h263p_encode_umotion(s, motion_x - pred_x); 1316 h263p_encode_umotion(s, motion_y - pred_y); 1317 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1)) 1318 /* To prevent Start Code emulation */ 1319 put_bits(&s->pb,1,1); 1320 } 1321 }else{ 1322 put_bits(&s->pb, 1323 inter_MCBPC_bits[cbpc+16], 1324 inter_MCBPC_code[cbpc+16]); 1325 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); 1326 if(s->dquant) 1327 put_bits(&s->pb, 2, dquant_code[s->dquant+2]); 1328 1329 if(interleaved_stats){ 1330 s->misc_bits+= get_bits_diff(s); 1331 } 1332 1333 for(i=0; i<4; i++){ 1334 /* motion vectors: 8x8 mode*/ 1335 h263_pred_motion(s, i, 0, &pred_x, &pred_y); 1336 1337 motion_x= s->current_picture.motion_val[0][ s->block_index[i] ][0]; 1338 motion_y= s->current_picture.motion_val[0][ s->block_index[i] ][1]; 1339 if (!s->umvplus) { 1340 ff_h263_encode_motion_vector(s, motion_x - pred_x, 1341 motion_y - pred_y, 1); 1342 } 1343 else { 1344 h263p_encode_umotion(s, motion_x - pred_x); 1345 h263p_encode_umotion(s, motion_y - pred_y); 1346 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1)) 1347 /* To prevent Start Code emulation */ 1348 put_bits(&s->pb,1,1); 1349 } 1350 } 1351 } 1352 1353 if(interleaved_stats){ 1354 s->mv_bits+= get_bits_diff(s); 1355 } 1356 } else { 1357 assert(s->mb_intra); 1358 1359 cbp = 0; 1360 if (s->h263_aic) { 1361 /* Predict DC */ 1362 for(i=0; i<6; i++) { 1363 int16_t level = block[i][0]; 1364 int scale; 1365 1366 if(i<4) scale= s->y_dc_scale; 1367 else scale= s->c_dc_scale; 1368 1369 pred_dc = h263_pred_dc(s, i, &dc_ptr[i]); 1370 level -= pred_dc; 1371 /* Quant */ 1372 if (level >= 0) 1373 level = (level + (scale>>1))/scale; 1374 else 1375 level = (level - (scale>>1))/scale; 1376 1377 /* AIC can change CBP */ 1378 if (level == 0 && s->block_last_index[i] == 0) 1379 s->block_last_index[i] = -1; 1380 1381 if(!s->modified_quant){ 1382 if (level < -127) 1383 level = -127; 1384 else if (level > 127) 1385 level = 127; 1386 } 1387 1388 block[i][0] = level; 1389 /* Reconstruction */ 1390 rec_intradc[i] = scale*level + pred_dc; 1391 /* Oddify */ 1392 rec_intradc[i] |= 1; 1393 //if ((rec_intradc[i] % 2) == 0) 1394 // rec_intradc[i]++; 1395 /* Clipping */ 1396 if (rec_intradc[i] < 0) 1397 rec_intradc[i] = 0; 1398 else if (rec_intradc[i] > 2047) 1399 rec_intradc[i] = 2047; 1400 1401 /* Update AC/DC tables */ 1402 *dc_ptr[i] = rec_intradc[i]; 1403 if (s->block_last_index[i] >= 0) 1404 cbp |= 1 << (5 - i); 1405 } 1406 }else{ 1407 for(i=0; i<6; i++) { 1408 /* compute cbp */ 1409 if (s->block_last_index[i] >= 1) 1410 cbp |= 1 << (5 - i); 1411 } 1412 } 1413 1414 cbpc = cbp & 3; 1415 if (s->pict_type == FF_I_TYPE) { 1416 if(s->dquant) cbpc+=4; 1417 put_bits(&s->pb, 1418 intra_MCBPC_bits[cbpc], 1419 intra_MCBPC_code[cbpc]); 1420 } else { 1421 if(s->dquant) cbpc+=8; 1422 put_bits(&s->pb, 1, 0); /* mb coded */ 1423 put_bits(&s->pb, 1424 inter_MCBPC_bits[cbpc + 4], 1425 inter_MCBPC_code[cbpc + 4]); 1426 } 1427 if (s->h263_aic) { 1428 /* XXX: currently, we do not try to use ac prediction */ 1429 put_bits(&s->pb, 1, 0); /* no AC prediction */ 1430 } 1431 cbpy = cbp >> 2; 1432 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]); 1433 if(s->dquant) 1434 put_bits(&s->pb, 2, dquant_code[s->dquant+2]); 1435 1436 if(interleaved_stats){ 1437 s->misc_bits+= get_bits_diff(s); 1438 } 1439 } 1440 1441 for(i=0; i<6; i++) { 1442 /* encode each block */ 1443 h263_encode_block(s, block[i], i); 1444 1445 /* Update INTRADC for decoding */ 1446 if (s->h263_aic && s->mb_intra) { 1447 block[i][0] = rec_intradc[i]; 1448 1449 } 1450 } 1451 1452 if(interleaved_stats){ 1453 if (!s->mb_intra) { 1454 s->p_tex_bits+= get_bits_diff(s); 1455 s->f_count++; 1456 }else{ 1457 s->i_tex_bits+= get_bits_diff(s); 1458 s->i_count++; 1459 } 1460 } 1461} 1462#endif 1463 1464void ff_h263_loop_filter(MpegEncContext * s){ 1465 int qp_c; 1466 const int linesize = s->linesize; 1467 const int uvlinesize= s->uvlinesize; 1468 const int xy = s->mb_y * s->mb_stride + s->mb_x; 1469 uint8_t *dest_y = s->dest[0]; 1470 uint8_t *dest_cb= s->dest[1]; 1471 uint8_t *dest_cr= s->dest[2]; 1472 1473// if(s->pict_type==FF_B_TYPE && !s->readable) return; 1474 1475 /* 1476 Diag Top 1477 Left Center 1478 */ 1479 if(!IS_SKIP(s->current_picture.mb_type[xy])){ 1480 qp_c= s->qscale; 1481 s->dsp.h263_v_loop_filter(dest_y+8*linesize , linesize, qp_c); 1482 s->dsp.h263_v_loop_filter(dest_y+8*linesize+8, linesize, qp_c); 1483 }else 1484 qp_c= 0; 1485 1486 if(s->mb_y){ 1487 int qp_dt, qp_tt, qp_tc; 1488 1489 if(IS_SKIP(s->current_picture.mb_type[xy-s->mb_stride])) 1490 qp_tt=0; 1491 else 1492 qp_tt= s->current_picture.qscale_table[xy-s->mb_stride]; 1493 1494 if(qp_c) 1495 qp_tc= qp_c; 1496 else 1497 qp_tc= qp_tt; 1498 1499 if(qp_tc){ 1500 const int chroma_qp= s->chroma_qscale_table[qp_tc]; 1501 s->dsp.h263_v_loop_filter(dest_y , linesize, qp_tc); 1502 s->dsp.h263_v_loop_filter(dest_y+8, linesize, qp_tc); 1503 1504 s->dsp.h263_v_loop_filter(dest_cb , uvlinesize, chroma_qp); 1505 s->dsp.h263_v_loop_filter(dest_cr , uvlinesize, chroma_qp); 1506 } 1507 1508 if(qp_tt) 1509 s->dsp.h263_h_loop_filter(dest_y-8*linesize+8 , linesize, qp_tt); 1510 1511 if(s->mb_x){ 1512 if(qp_tt || IS_SKIP(s->current_picture.mb_type[xy-1-s->mb_stride])) 1513 qp_dt= qp_tt; 1514 else 1515 qp_dt= s->current_picture.qscale_table[xy-1-s->mb_stride]; 1516 1517 if(qp_dt){ 1518 const int chroma_qp= s->chroma_qscale_table[qp_dt]; 1519 s->dsp.h263_h_loop_filter(dest_y -8*linesize , linesize, qp_dt); 1520 s->dsp.h263_h_loop_filter(dest_cb-8*uvlinesize, uvlinesize, chroma_qp); 1521 s->dsp.h263_h_loop_filter(dest_cr-8*uvlinesize, uvlinesize, chroma_qp); 1522 } 1523 } 1524 } 1525 1526 if(qp_c){ 1527 s->dsp.h263_h_loop_filter(dest_y +8, linesize, qp_c); 1528 if(s->mb_y + 1 == s->mb_height) 1529 s->dsp.h263_h_loop_filter(dest_y+8*linesize+8, linesize, qp_c); 1530 } 1531 1532 if(s->mb_x){ 1533 int qp_lc; 1534 if(qp_c || IS_SKIP(s->current_picture.mb_type[xy-1])) 1535 qp_lc= qp_c; 1536 else 1537 qp_lc= s->current_picture.qscale_table[xy-1]; 1538 1539 if(qp_lc){ 1540 s->dsp.h263_h_loop_filter(dest_y, linesize, qp_lc); 1541 if(s->mb_y + 1 == s->mb_height){ 1542 const int chroma_qp= s->chroma_qscale_table[qp_lc]; 1543 s->dsp.h263_h_loop_filter(dest_y +8* linesize, linesize, qp_lc); 1544 s->dsp.h263_h_loop_filter(dest_cb , uvlinesize, chroma_qp); 1545 s->dsp.h263_h_loop_filter(dest_cr , uvlinesize, chroma_qp); 1546 } 1547 } 1548 } 1549} 1550 1551#if CONFIG_ENCODERS 1552static int h263_pred_dc(MpegEncContext * s, int n, int16_t **dc_val_ptr) 1553{ 1554 int x, y, wrap, a, c, pred_dc, scale; 1555 int16_t *dc_val; 1556 1557 /* find prediction */ 1558 if (n < 4) { 1559 x = 2 * s->mb_x + (n & 1); 1560 y = 2 * s->mb_y + ((n & 2) >> 1); 1561 wrap = s->b8_stride; 1562 dc_val = s->dc_val[0]; 1563 scale = s->y_dc_scale; 1564 } else { 1565 x = s->mb_x; 1566 y = s->mb_y; 1567 wrap = s->mb_stride; 1568 dc_val = s->dc_val[n - 4 + 1]; 1569 scale = s->c_dc_scale; 1570 } 1571 /* B C 1572 * A X 1573 */ 1574 a = dc_val[(x - 1) + (y) * wrap]; 1575 c = dc_val[(x) + (y - 1) * wrap]; 1576 1577 /* No prediction outside GOB boundary */ 1578 if(s->first_slice_line && n!=3){ 1579 if(n!=2) c= 1024; 1580 if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024; 1581 } 1582 pred_dc = 1024; 1583 /* just DC prediction */ 1584 if (a != 1024 && c != 1024) 1585 pred_dc = (a + c) >> 1; 1586 else if (a != 1024) 1587 pred_dc = a; 1588 else 1589 pred_dc = c; 1590 1591 /* we assume pred is positive */ 1592 //pred_dc = (pred_dc + (scale >> 1)) / scale; 1593 *dc_val_ptr = &dc_val[x + y * wrap]; 1594 return pred_dc; 1595} 1596#endif /* CONFIG_ENCODERS */ 1597 1598static void h263_pred_acdc(MpegEncContext * s, DCTELEM *block, int n) 1599{ 1600 int x, y, wrap, a, c, pred_dc, scale, i; 1601 int16_t *dc_val, *ac_val, *ac_val1; 1602 1603 /* find prediction */ 1604 if (n < 4) { 1605 x = 2 * s->mb_x + (n & 1); 1606 y = 2 * s->mb_y + (n>> 1); 1607 wrap = s->b8_stride; 1608 dc_val = s->dc_val[0]; 1609 ac_val = s->ac_val[0][0]; 1610 scale = s->y_dc_scale; 1611 } else { 1612 x = s->mb_x; 1613 y = s->mb_y; 1614 wrap = s->mb_stride; 1615 dc_val = s->dc_val[n - 4 + 1]; 1616 ac_val = s->ac_val[n - 4 + 1][0]; 1617 scale = s->c_dc_scale; 1618 } 1619 1620 ac_val += ((y) * wrap + (x)) * 16; 1621 ac_val1 = ac_val; 1622 1623 /* B C 1624 * A X 1625 */ 1626 a = dc_val[(x - 1) + (y) * wrap]; 1627 c = dc_val[(x) + (y - 1) * wrap]; 1628 1629 /* No prediction outside GOB boundary */ 1630 if(s->first_slice_line && n!=3){ 1631 if(n!=2) c= 1024; 1632 if(n!=1 && s->mb_x == s->resync_mb_x) a= 1024; 1633 } 1634 1635 if (s->ac_pred) { 1636 pred_dc = 1024; 1637 if (s->h263_aic_dir) { 1638 /* left prediction */ 1639 if (a != 1024) { 1640 ac_val -= 16; 1641 for(i=1;i<8;i++) { 1642 block[s->dsp.idct_permutation[i<<3]] += ac_val[i]; 1643 } 1644 pred_dc = a; 1645 } 1646 } else { 1647 /* top prediction */ 1648 if (c != 1024) { 1649 ac_val -= 16 * wrap; 1650 for(i=1;i<8;i++) { 1651 block[s->dsp.idct_permutation[i ]] += ac_val[i + 8]; 1652 } 1653 pred_dc = c; 1654 } 1655 } 1656 } else { 1657 /* just DC prediction */ 1658 if (a != 1024 && c != 1024) 1659 pred_dc = (a + c) >> 1; 1660 else if (a != 1024) 1661 pred_dc = a; 1662 else 1663 pred_dc = c; 1664 } 1665 1666 /* we assume pred is positive */ 1667 block[0]=block[0]*scale + pred_dc; 1668 1669 if (block[0] < 0) 1670 block[0] = 0; 1671 else 1672 block[0] |= 1; 1673 1674 /* Update AC/DC tables */ 1675 dc_val[(x) + (y) * wrap] = block[0]; 1676 1677 /* left copy */ 1678 for(i=1;i<8;i++) 1679 ac_val1[i ] = block[s->dsp.idct_permutation[i<<3]]; 1680 /* top copy */ 1681 for(i=1;i<8;i++) 1682 ac_val1[8 + i] = block[s->dsp.idct_permutation[i ]]; 1683} 1684 1685int16_t *h263_pred_motion(MpegEncContext * s, int block, int dir, 1686 int *px, int *py) 1687{ 1688 int wrap; 1689 int16_t *A, *B, *C, (*mot_val)[2]; 1690 static const int off[4]= {2, 1, 1, -1}; 1691 1692 wrap = s->b8_stride; 1693 mot_val = s->current_picture.motion_val[dir] + s->block_index[block]; 1694 1695 A = mot_val[ - 1]; 1696 /* special case for first (slice) line */ 1697 if (s->first_slice_line && block<3) { 1698 // we can't just change some MVs to simulate that as we need them for the B frames (and ME) 1699 // and if we ever support non rectangular objects than we need to do a few ifs here anyway :( 1700 if(block==0){ //most common case 1701 if(s->mb_x == s->resync_mb_x){ //rare 1702 *px= *py = 0; 1703 }else if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare 1704 C = mot_val[off[block] - wrap]; 1705 if(s->mb_x==0){ 1706 *px = C[0]; 1707 *py = C[1]; 1708 }else{ 1709 *px = mid_pred(A[0], 0, C[0]); 1710 *py = mid_pred(A[1], 0, C[1]); 1711 } 1712 }else{ 1713 *px = A[0]; 1714 *py = A[1]; 1715 } 1716 }else if(block==1){ 1717 if(s->mb_x + 1 == s->resync_mb_x && s->h263_pred){ //rare 1718 C = mot_val[off[block] - wrap]; 1719 *px = mid_pred(A[0], 0, C[0]); 1720 *py = mid_pred(A[1], 0, C[1]); 1721 }else{ 1722 *px = A[0]; 1723 *py = A[1]; 1724 } 1725 }else{ /* block==2*/ 1726 B = mot_val[ - wrap]; 1727 C = mot_val[off[block] - wrap]; 1728 if(s->mb_x == s->resync_mb_x) //rare 1729 A[0]=A[1]=0; 1730 1731 *px = mid_pred(A[0], B[0], C[0]); 1732 *py = mid_pred(A[1], B[1], C[1]); 1733 } 1734 } else { 1735 B = mot_val[ - wrap]; 1736 C = mot_val[off[block] - wrap]; 1737 *px = mid_pred(A[0], B[0], C[0]); 1738 *py = mid_pred(A[1], B[1], C[1]); 1739 } 1740 return *mot_val; 1741} 1742 1743#if CONFIG_ENCODERS 1744void ff_h263_encode_motion(MpegEncContext * s, int val, int f_code) 1745{ 1746 int range, l, bit_size, sign, code, bits; 1747 1748 if (val == 0) { 1749 /* zero vector */ 1750 code = 0; 1751 put_bits(&s->pb, mvtab[code][1], mvtab[code][0]); 1752 } else { 1753 bit_size = f_code - 1; 1754 range = 1 << bit_size; 1755 /* modulo encoding */ 1756 l= INT_BIT - 6 - bit_size; 1757 val = (val<<l)>>l; 1758 sign = val>>31; 1759 val= (val^sign)-sign; 1760 sign&=1; 1761 1762 val--; 1763 code = (val >> bit_size) + 1; 1764 bits = val & (range - 1); 1765 1766 put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign); 1767 if (bit_size > 0) { 1768 put_bits(&s->pb, bit_size, bits); 1769 } 1770 } 1771} 1772 1773/* Encode MV differences on H.263+ with Unrestricted MV mode */ 1774static void h263p_encode_umotion(MpegEncContext * s, int val) 1775{ 1776 short sval = 0; 1777 short i = 0; 1778 short n_bits = 0; 1779 short temp_val; 1780 int code = 0; 1781 int tcode; 1782 1783 if ( val == 0) 1784 put_bits(&s->pb, 1, 1); 1785 else if (val == 1) 1786 put_bits(&s->pb, 3, 0); 1787 else if (val == -1) 1788 put_bits(&s->pb, 3, 2); 1789 else { 1790 1791 sval = ((val < 0) ? (short)(-val):(short)val); 1792 temp_val = sval; 1793 1794 while (temp_val != 0) { 1795 temp_val = temp_val >> 1; 1796 n_bits++; 1797 } 1798 1799 i = n_bits - 1; 1800 while (i > 0) { 1801 tcode = (sval & (1 << (i-1))) >> (i-1); 1802 tcode = (tcode << 1) | 1; 1803 code = (code << 2) | tcode; 1804 i--; 1805 } 1806 code = ((code << 1) | (val < 0)) << 1; 1807 put_bits(&s->pb, (2*n_bits)+1, code); 1808 //printf("\nVal = %d\tCode = %d", sval, code); 1809 } 1810} 1811 1812static void init_mv_penalty_and_fcode(MpegEncContext *s) 1813{ 1814 int f_code; 1815 int mv; 1816 1817 for(f_code=1; f_code<=MAX_FCODE; f_code++){ 1818 for(mv=-MAX_MV; mv<=MAX_MV; mv++){ 1819 int len; 1820 1821 if(mv==0) len= mvtab[0][1]; 1822 else{ 1823 int val, bit_size, range, code; 1824 1825 bit_size = f_code - 1; 1826 range = 1 << bit_size; 1827 1828 val=mv; 1829 if (val < 0) 1830 val = -val; 1831 val--; 1832 code = (val >> bit_size) + 1; 1833 if(code<33){ 1834 len= mvtab[code][1] + 1 + bit_size; 1835 }else{ 1836 len= mvtab[32][1] + av_log2(code>>5) + 2 + bit_size; 1837 } 1838 } 1839 1840 mv_penalty[f_code][mv+MAX_MV]= len; 1841 } 1842 } 1843 1844 for(f_code=MAX_FCODE; f_code>0; f_code--){ 1845 for(mv=-(16<<f_code); mv<(16<<f_code); mv++){ 1846 fcode_tab[mv+MAX_MV]= f_code; 1847 } 1848 } 1849 1850 for(mv=0; mv<MAX_MV*2+1; mv++){ 1851 umv_fcode_tab[mv]= 1; 1852 } 1853} 1854 1855static void init_uni_dc_tab(void) 1856{ 1857 int level, uni_code, uni_len; 1858 1859 for(level=-256; level<256; level++){ 1860 int size, v, l; 1861 /* find number of bits */ 1862 size = 0; 1863 v = abs(level); 1864 while (v) { 1865 v >>= 1; 1866 size++; 1867 } 1868 1869 if (level < 0) 1870 l= (-level) ^ ((1 << size) - 1); 1871 else 1872 l= level; 1873 1874 /* luminance */ 1875 uni_code= DCtab_lum[size][0]; 1876 uni_len = DCtab_lum[size][1]; 1877 1878 if (size > 0) { 1879 uni_code<<=size; uni_code|=l; 1880 uni_len+=size; 1881 if (size > 8){ 1882 uni_code<<=1; uni_code|=1; 1883 uni_len++; 1884 } 1885 } 1886 uni_DCtab_lum_bits[level+256]= uni_code; 1887 uni_DCtab_lum_len [level+256]= uni_len; 1888 1889 /* chrominance */ 1890 uni_code= DCtab_chrom[size][0]; 1891 uni_len = DCtab_chrom[size][1]; 1892 1893 if (size > 0) { 1894 uni_code<<=size; uni_code|=l; 1895 uni_len+=size; 1896 if (size > 8){ 1897 uni_code<<=1; uni_code|=1; 1898 uni_len++; 1899 } 1900 } 1901 uni_DCtab_chrom_bits[level+256]= uni_code; 1902 uni_DCtab_chrom_len [level+256]= uni_len; 1903 1904 } 1905} 1906 1907static void init_uni_mpeg4_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){ 1908 int slevel, run, last; 1909 1910 assert(MAX_LEVEL >= 64); 1911 assert(MAX_RUN >= 63); 1912 1913 for(slevel=-64; slevel<64; slevel++){ 1914 if(slevel==0) continue; 1915 for(run=0; run<64; run++){ 1916 for(last=0; last<=1; last++){ 1917 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64); 1918 int level= slevel < 0 ? -slevel : slevel; 1919 int sign= slevel < 0 ? 1 : 0; 1920 int bits, len, code; 1921 int level1, run1; 1922 1923 len_tab[index]= 100; 1924 1925 /* ESC0 */ 1926 code= get_rl_index(rl, last, run, level); 1927 bits= rl->table_vlc[code][0]; 1928 len= rl->table_vlc[code][1]; 1929 bits=bits*2+sign; len++; 1930 1931 if(code!=rl->n && len < len_tab[index]){ 1932 bits_tab[index]= bits; 1933 len_tab [index]= len; 1934 } 1935#if 1 1936 /* ESC1 */ 1937 bits= rl->table_vlc[rl->n][0]; 1938 len= rl->table_vlc[rl->n][1]; 1939 bits=bits*2; len++; //esc1 1940 level1= level - rl->max_level[last][run]; 1941 if(level1>0){ 1942 code= get_rl_index(rl, last, run, level1); 1943 bits<<= rl->table_vlc[code][1]; 1944 len += rl->table_vlc[code][1]; 1945 bits += rl->table_vlc[code][0]; 1946 bits=bits*2+sign; len++; 1947 1948 if(code!=rl->n && len < len_tab[index]){ 1949 bits_tab[index]= bits; 1950 len_tab [index]= len; 1951 } 1952 } 1953#endif 1954#if 1 1955 /* ESC2 */ 1956 bits= rl->table_vlc[rl->n][0]; 1957 len= rl->table_vlc[rl->n][1]; 1958 bits=bits*4+2; len+=2; //esc2 1959 run1 = run - rl->max_run[last][level] - 1; 1960 if(run1>=0){ 1961 code= get_rl_index(rl, last, run1, level); 1962 bits<<= rl->table_vlc[code][1]; 1963 len += rl->table_vlc[code][1]; 1964 bits += rl->table_vlc[code][0]; 1965 bits=bits*2+sign; len++; 1966 1967 if(code!=rl->n && len < len_tab[index]){ 1968 bits_tab[index]= bits; 1969 len_tab [index]= len; 1970 } 1971 } 1972#endif 1973 /* ESC3 */ 1974 bits= rl->table_vlc[rl->n][0]; 1975 len = rl->table_vlc[rl->n][1]; 1976 bits=bits*4+3; len+=2; //esc3 1977 bits=bits*2+last; len++; 1978 bits=bits*64+run; len+=6; 1979 bits=bits*2+1; len++; //marker 1980 bits=bits*4096+(slevel&0xfff); len+=12; 1981 bits=bits*2+1; len++; //marker 1982 1983 if(len < len_tab[index]){ 1984 bits_tab[index]= bits; 1985 len_tab [index]= len; 1986 } 1987 } 1988 } 1989 } 1990} 1991 1992static void init_uni_h263_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){ 1993 int slevel, run, last; 1994 1995 assert(MAX_LEVEL >= 64); 1996 assert(MAX_RUN >= 63); 1997 1998 for(slevel=-64; slevel<64; slevel++){ 1999 if(slevel==0) continue; 2000 for(run=0; run<64; run++){ 2001 for(last=0; last<=1; last++){ 2002 const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64); 2003 int level= slevel < 0 ? -slevel : slevel; 2004 int sign= slevel < 0 ? 1 : 0; 2005 int bits, len, code; 2006 2007 len_tab[index]= 100; 2008 2009 /* ESC0 */ 2010 code= get_rl_index(rl, last, run, level); 2011 bits= rl->table_vlc[code][0]; 2012 len= rl->table_vlc[code][1]; 2013 bits=bits*2+sign; len++; 2014 2015 if(code!=rl->n && len < len_tab[index]){ 2016 if(bits_tab) bits_tab[index]= bits; 2017 len_tab [index]= len; 2018 } 2019 /* ESC */ 2020 bits= rl->table_vlc[rl->n][0]; 2021 len = rl->table_vlc[rl->n][1]; 2022 bits=bits*2+last; len++; 2023 bits=bits*64+run; len+=6; 2024 bits=bits*256+(level&0xff); len+=8; 2025 2026 if(len < len_tab[index]){ 2027 if(bits_tab) bits_tab[index]= bits; 2028 len_tab [index]= len; 2029 } 2030 } 2031 } 2032 } 2033} 2034 2035void h263_encode_init(MpegEncContext *s) 2036{ 2037 static int done = 0; 2038 2039 if (!done) { 2040 done = 1; 2041 2042 init_uni_dc_tab(); 2043 2044 init_rl(&rl_inter, static_rl_table_store[0]); 2045 init_rl(&rl_intra, static_rl_table_store[1]); 2046 init_rl(&rl_intra_aic, static_rl_table_store[2]); 2047 2048 init_uni_mpeg4_rl_tab(&rl_intra, uni_mpeg4_intra_rl_bits, uni_mpeg4_intra_rl_len); 2049 init_uni_mpeg4_rl_tab(&rl_inter, uni_mpeg4_inter_rl_bits, uni_mpeg4_inter_rl_len); 2050 2051 init_uni_h263_rl_tab(&rl_intra_aic, NULL, uni_h263_intra_aic_rl_len); 2052 init_uni_h263_rl_tab(&rl_inter , NULL, uni_h263_inter_rl_len); 2053 2054 init_mv_penalty_and_fcode(s); 2055 } 2056 s->me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p 2057 2058 s->intra_ac_vlc_length =s->inter_ac_vlc_length = uni_h263_inter_rl_len; 2059 s->intra_ac_vlc_last_length=s->inter_ac_vlc_last_length= uni_h263_inter_rl_len + 128*64; 2060 if(s->h263_aic){ 2061 s->intra_ac_vlc_length = uni_h263_intra_aic_rl_len; 2062 s->intra_ac_vlc_last_length= uni_h263_intra_aic_rl_len + 128*64; 2063 } 2064 s->ac_esc_length= 7+1+6+8; 2065 2066 // use fcodes >1 only for mpeg4 & h263 & h263p FIXME 2067 switch(s->codec_id){ 2068 case CODEC_ID_MPEG4: 2069 s->fcode_tab= fcode_tab; 2070 s->min_qcoeff= -2048; 2071 s->max_qcoeff= 2047; 2072 s->intra_ac_vlc_length = uni_mpeg4_intra_rl_len; 2073 s->intra_ac_vlc_last_length= uni_mpeg4_intra_rl_len + 128*64; 2074 s->inter_ac_vlc_length = uni_mpeg4_inter_rl_len; 2075 s->inter_ac_vlc_last_length= uni_mpeg4_inter_rl_len + 128*64; 2076 s->luma_dc_vlc_length= uni_DCtab_lum_len; 2077 s->chroma_dc_vlc_length= uni_DCtab_chrom_len; 2078 s->ac_esc_length= 7+2+1+6+1+12+1; 2079 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; 2080 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table; 2081 2082 if(s->flags & CODEC_FLAG_GLOBAL_HEADER){ 2083 2084 s->avctx->extradata= av_malloc(1024); 2085 init_put_bits(&s->pb, s->avctx->extradata, 1024); 2086 2087 if(!(s->workaround_bugs & FF_BUG_MS)) 2088 mpeg4_encode_visual_object_header(s); 2089 mpeg4_encode_vol_header(s, 0, 0); 2090 2091// ff_mpeg4_stuffing(&s->pb); ? 2092 flush_put_bits(&s->pb); 2093 s->avctx->extradata_size= (put_bits_count(&s->pb)+7)>>3; 2094 } 2095 2096 break; 2097 case CODEC_ID_H263P: 2098 if(s->umvplus) 2099 s->fcode_tab= umv_fcode_tab; 2100 if(s->modified_quant){ 2101 s->min_qcoeff= -2047; 2102 s->max_qcoeff= 2047; 2103 }else{ 2104 s->min_qcoeff= -127; 2105 s->max_qcoeff= 127; 2106 } 2107 break; 2108 //Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later 2109 case CODEC_ID_FLV1: 2110 if (s->h263_flv > 1) { 2111 s->min_qcoeff= -1023; 2112 s->max_qcoeff= 1023; 2113 } else { 2114 s->min_qcoeff= -127; 2115 s->max_qcoeff= 127; 2116 } 2117 s->y_dc_scale_table= 2118 s->c_dc_scale_table= ff_mpeg1_dc_scale_table; 2119 break; 2120 default: //nothing needed - default table already set in mpegvideo.c 2121 s->min_qcoeff= -127; 2122 s->max_qcoeff= 127; 2123 s->y_dc_scale_table= 2124 s->c_dc_scale_table= ff_mpeg1_dc_scale_table; 2125 } 2126} 2127 2128/** 2129 * encodes a 8x8 block. 2130 * @param block the 8x8 block 2131 * @param n block index (0-3 are luma, 4-5 are chroma) 2132 */ 2133static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n) 2134{ 2135 int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code; 2136 RLTable *rl; 2137 2138 rl = &rl_inter; 2139 if (s->mb_intra && !s->h263_aic) { 2140 /* DC coef */ 2141 level = block[0]; 2142 /* 255 cannot be represented, so we clamp */ 2143 if (level > 254) { 2144 level = 254; 2145 block[0] = 254; 2146 } 2147 /* 0 cannot be represented also */ 2148 else if (level < 1) { 2149 level = 1; 2150 block[0] = 1; 2151 } 2152 if (level == 128) //FIXME check rv10 2153 put_bits(&s->pb, 8, 0xff); 2154 else 2155 put_bits(&s->pb, 8, level); 2156 i = 1; 2157 } else { 2158 i = 0; 2159 if (s->h263_aic && s->mb_intra) 2160 rl = &rl_intra_aic; 2161 2162 if(s->alt_inter_vlc && !s->mb_intra){ 2163 int aic_vlc_bits=0; 2164 int inter_vlc_bits=0; 2165 int wrong_pos=-1; 2166 int aic_code; 2167 2168 last_index = s->block_last_index[n]; 2169 last_non_zero = i - 1; 2170 for (; i <= last_index; i++) { 2171 j = s->intra_scantable.permutated[i]; 2172 level = block[j]; 2173 if (level) { 2174 run = i - last_non_zero - 1; 2175 last = (i == last_index); 2176 2177 if(level<0) level= -level; 2178 2179 code = get_rl_index(rl, last, run, level); 2180 aic_code = get_rl_index(&rl_intra_aic, last, run, level); 2181 inter_vlc_bits += rl->table_vlc[code][1]+1; 2182 aic_vlc_bits += rl_intra_aic.table_vlc[aic_code][1]+1; 2183 2184 if (code == rl->n) { 2185 inter_vlc_bits += 1+6+8-1; 2186 } 2187 if (aic_code == rl_intra_aic.n) { 2188 aic_vlc_bits += 1+6+8-1; 2189 wrong_pos += run + 1; 2190 }else 2191 wrong_pos += wrong_run[aic_code]; 2192 last_non_zero = i; 2193 } 2194 } 2195 i = 0; 2196 if(aic_vlc_bits < inter_vlc_bits && wrong_pos > 63) 2197 rl = &rl_intra_aic; 2198 } 2199 } 2200 2201 /* AC coefs */ 2202 last_index = s->block_last_index[n]; 2203 last_non_zero = i - 1; 2204 for (; i <= last_index; i++) { 2205 j = s->intra_scantable.permutated[i]; 2206 level = block[j]; 2207 if (level) { 2208 run = i - last_non_zero - 1; 2209 last = (i == last_index); 2210 sign = 0; 2211 slevel = level; 2212 if (level < 0) { 2213 sign = 1; 2214 level = -level; 2215 } 2216 code = get_rl_index(rl, last, run, level); 2217 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); 2218 if (code == rl->n) { 2219 if(s->h263_flv <= 1){ 2220 put_bits(&s->pb, 1, last); 2221 put_bits(&s->pb, 6, run); 2222 2223 assert(slevel != 0); 2224 2225 if(level < 128) 2226 put_sbits(&s->pb, 8, slevel); 2227 else{ 2228 put_bits(&s->pb, 8, 128); 2229 put_sbits(&s->pb, 5, slevel); 2230 put_sbits(&s->pb, 6, slevel>>5); 2231 } 2232 }else{ 2233 if(level < 64) { // 7-bit level 2234 put_bits(&s->pb, 1, 0); 2235 put_bits(&s->pb, 1, last); 2236 put_bits(&s->pb, 6, run); 2237 2238 put_sbits(&s->pb, 7, slevel); 2239 } else { 2240 /* 11-bit level */ 2241 put_bits(&s->pb, 1, 1); 2242 put_bits(&s->pb, 1, last); 2243 put_bits(&s->pb, 6, run); 2244 2245 put_sbits(&s->pb, 11, slevel); 2246 } 2247 } 2248 } else { 2249 put_bits(&s->pb, 1, sign); 2250 } 2251 last_non_zero = i; 2252 } 2253 } 2254} 2255 2256/***************************************************/ 2257/** 2258 * add mpeg4 stuffing bits (01...1) 2259 */ 2260void ff_mpeg4_stuffing(PutBitContext * pbc) 2261{ 2262 int length; 2263 put_bits(pbc, 1, 0); 2264 length= (-put_bits_count(pbc))&7; 2265 if(length) put_bits(pbc, length, (1<<length)-1); 2266} 2267 2268/* must be called before writing the header */ 2269void ff_set_mpeg4_time(MpegEncContext * s){ 2270 if(s->pict_type==FF_B_TYPE){ 2271 ff_mpeg4_init_direct_mv(s); 2272 }else{ 2273 s->last_time_base= s->time_base; 2274 s->time_base= s->time/s->avctx->time_base.den; 2275 } 2276} 2277 2278static void mpeg4_encode_gop_header(MpegEncContext * s){ 2279 int hours, minutes, seconds; 2280 int64_t time; 2281 2282 put_bits(&s->pb, 16, 0); 2283 put_bits(&s->pb, 16, GOP_STARTCODE); 2284 2285 time= s->current_picture_ptr->pts; 2286 if(s->reordered_input_picture[1]) 2287 time= FFMIN(time, s->reordered_input_picture[1]->pts); 2288 time= time*s->avctx->time_base.num; 2289 2290 seconds= time/s->avctx->time_base.den; 2291 minutes= seconds/60; seconds %= 60; 2292 hours= minutes/60; minutes %= 60; 2293 hours%=24; 2294 2295 put_bits(&s->pb, 5, hours); 2296 put_bits(&s->pb, 6, minutes); 2297 put_bits(&s->pb, 1, 1); 2298 put_bits(&s->pb, 6, seconds); 2299 2300 put_bits(&s->pb, 1, !!(s->flags&CODEC_FLAG_CLOSED_GOP)); 2301 put_bits(&s->pb, 1, 0); //broken link == NO 2302 2303 s->last_time_base= time / s->avctx->time_base.den; 2304 2305 ff_mpeg4_stuffing(&s->pb); 2306} 2307 2308static void mpeg4_encode_visual_object_header(MpegEncContext * s){ 2309 int profile_and_level_indication; 2310 int vo_ver_id; 2311 2312 if(s->avctx->profile != FF_PROFILE_UNKNOWN){ 2313 profile_and_level_indication = s->avctx->profile << 4; 2314 }else if(s->max_b_frames || s->quarter_sample){ 2315 profile_and_level_indication= 0xF0; // adv simple 2316 }else{ 2317 profile_and_level_indication= 0x00; // simple 2318 } 2319 2320 if(s->avctx->level != FF_LEVEL_UNKNOWN){ 2321 profile_and_level_indication |= s->avctx->level; 2322 }else{ 2323 profile_and_level_indication |= 1; //level 1 2324 } 2325 2326 if(profile_and_level_indication>>4 == 0xF){ 2327 vo_ver_id= 5; 2328 }else{ 2329 vo_ver_id= 1; 2330 } 2331 2332 //FIXME levels 2333 2334 put_bits(&s->pb, 16, 0); 2335 put_bits(&s->pb, 16, VOS_STARTCODE); 2336 2337 put_bits(&s->pb, 8, profile_and_level_indication); 2338 2339 put_bits(&s->pb, 16, 0); 2340 put_bits(&s->pb, 16, VISUAL_OBJ_STARTCODE); 2341 2342 put_bits(&s->pb, 1, 1); 2343 put_bits(&s->pb, 4, vo_ver_id); 2344 put_bits(&s->pb, 3, 1); //priority 2345 2346 put_bits(&s->pb, 4, 1); //visual obj type== video obj 2347 2348 put_bits(&s->pb, 1, 0); //video signal type == no clue //FIXME 2349 2350 ff_mpeg4_stuffing(&s->pb); 2351} 2352 2353static void mpeg4_encode_vol_header(MpegEncContext * s, int vo_number, int vol_number) 2354{ 2355 int vo_ver_id; 2356 2357 if (!CONFIG_MPEG4_ENCODER) return; 2358 2359 if(s->max_b_frames || s->quarter_sample){ 2360 vo_ver_id= 5; 2361 s->vo_type= ADV_SIMPLE_VO_TYPE; 2362 }else{ 2363 vo_ver_id= 1; 2364 s->vo_type= SIMPLE_VO_TYPE; 2365 } 2366 2367 put_bits(&s->pb, 16, 0); 2368 put_bits(&s->pb, 16, 0x100 + vo_number); /* video obj */ 2369 put_bits(&s->pb, 16, 0); 2370 put_bits(&s->pb, 16, 0x120 + vol_number); /* video obj layer */ 2371 2372 put_bits(&s->pb, 1, 0); /* random access vol */ 2373 put_bits(&s->pb, 8, s->vo_type); /* video obj type indication */ 2374 if(s->workaround_bugs & FF_BUG_MS) { 2375 put_bits(&s->pb, 1, 0); /* is obj layer id= no */ 2376 } else { 2377 put_bits(&s->pb, 1, 1); /* is obj layer id= yes */ 2378 put_bits(&s->pb, 4, vo_ver_id); /* is obj layer ver id */ 2379 put_bits(&s->pb, 3, 1); /* is obj layer priority */ 2380 } 2381 2382 aspect_to_info(s, s->avctx->sample_aspect_ratio); 2383 2384 put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */ 2385 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED){ 2386 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num); 2387 put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den); 2388 } 2389 2390 if(s->workaround_bugs & FF_BUG_MS) { // 2391 put_bits(&s->pb, 1, 0); /* vol control parameters= no @@@ */ 2392 } else { 2393 put_bits(&s->pb, 1, 1); /* vol control parameters= yes */ 2394 put_bits(&s->pb, 2, 1); /* chroma format YUV 420/YV12 */ 2395 put_bits(&s->pb, 1, s->low_delay); 2396 put_bits(&s->pb, 1, 0); /* vbv parameters= no */ 2397 } 2398 2399 put_bits(&s->pb, 2, RECT_SHAPE); /* vol shape= rectangle */ 2400 put_bits(&s->pb, 1, 1); /* marker bit */ 2401 2402 put_bits(&s->pb, 16, s->avctx->time_base.den); 2403 if (s->time_increment_bits < 1) 2404 s->time_increment_bits = 1; 2405 put_bits(&s->pb, 1, 1); /* marker bit */ 2406 put_bits(&s->pb, 1, 0); /* fixed vop rate=no */ 2407 put_bits(&s->pb, 1, 1); /* marker bit */ 2408 put_bits(&s->pb, 13, s->width); /* vol width */ 2409 put_bits(&s->pb, 1, 1); /* marker bit */ 2410 put_bits(&s->pb, 13, s->height); /* vol height */ 2411 put_bits(&s->pb, 1, 1); /* marker bit */ 2412 put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1); 2413 put_bits(&s->pb, 1, 1); /* obmc disable */ 2414 if (vo_ver_id == 1) { 2415 put_bits(&s->pb, 1, s->vol_sprite_usage); /* sprite enable */ 2416 }else{ 2417 put_bits(&s->pb, 2, s->vol_sprite_usage); /* sprite enable */ 2418 } 2419 2420 put_bits(&s->pb, 1, 0); /* not 8 bit == false */ 2421 put_bits(&s->pb, 1, s->mpeg_quant); /* quant type= (0=h263 style)*/ 2422 2423 if(s->mpeg_quant){ 2424 ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix); 2425 ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix); 2426 } 2427 2428 if (vo_ver_id != 1) 2429 put_bits(&s->pb, 1, s->quarter_sample); 2430 put_bits(&s->pb, 1, 1); /* complexity estimation disable */ 2431 s->resync_marker= s->rtp_mode; 2432 put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */ 2433 put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0); 2434 if(s->data_partitioning){ 2435 put_bits(&s->pb, 1, 0); /* no rvlc */ 2436 } 2437 2438 if (vo_ver_id != 1){ 2439 put_bits(&s->pb, 1, 0); /* newpred */ 2440 put_bits(&s->pb, 1, 0); /* reduced res vop */ 2441 } 2442 put_bits(&s->pb, 1, 0); /* scalability */ 2443 2444 ff_mpeg4_stuffing(&s->pb); 2445 2446 /* user data */ 2447 if(!(s->flags & CODEC_FLAG_BITEXACT)){ 2448 put_bits(&s->pb, 16, 0); 2449 put_bits(&s->pb, 16, 0x1B2); /* user_data */ 2450 ff_put_string(&s->pb, LIBAVCODEC_IDENT, 0); 2451 } 2452} 2453 2454/* write mpeg4 VOP header */ 2455void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number) 2456{ 2457 int time_incr; 2458 int time_div, time_mod; 2459 2460 if(s->pict_type==FF_I_TYPE){ 2461 if(!(s->flags&CODEC_FLAG_GLOBAL_HEADER)){ 2462 if(s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT) //HACK, the reference sw is buggy 2463 mpeg4_encode_visual_object_header(s); 2464 if(s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT || picture_number==0) //HACK, the reference sw is buggy 2465 mpeg4_encode_vol_header(s, 0, 0); 2466 } 2467 if(!(s->workaround_bugs & FF_BUG_MS)) 2468 mpeg4_encode_gop_header(s); 2469 } 2470 2471 s->partitioned_frame= s->data_partitioning && s->pict_type!=FF_B_TYPE; 2472 2473//printf("num:%d rate:%d base:%d\n", s->picture_number, s->time_base.den, FRAME_RATE_BASE); 2474 2475 put_bits(&s->pb, 16, 0); /* vop header */ 2476 put_bits(&s->pb, 16, VOP_STARTCODE); /* vop header */ 2477 put_bits(&s->pb, 2, s->pict_type - 1); /* pict type: I = 0 , P = 1 */ 2478 2479 assert(s->time>=0); 2480 time_div= s->time/s->avctx->time_base.den; 2481 time_mod= s->time%s->avctx->time_base.den; 2482 time_incr= time_div - s->last_time_base; 2483 assert(time_incr >= 0); 2484 while(time_incr--) 2485 put_bits(&s->pb, 1, 1); 2486 2487 put_bits(&s->pb, 1, 0); 2488 2489 put_bits(&s->pb, 1, 1); /* marker */ 2490 put_bits(&s->pb, s->time_increment_bits, time_mod); /* time increment */ 2491 put_bits(&s->pb, 1, 1); /* marker */ 2492 put_bits(&s->pb, 1, 1); /* vop coded */ 2493 if ( s->pict_type == FF_P_TYPE 2494 || (s->pict_type == FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) { 2495 put_bits(&s->pb, 1, s->no_rounding); /* rounding type */ 2496 } 2497 put_bits(&s->pb, 3, 0); /* intra dc VLC threshold */ 2498 if(!s->progressive_sequence){ 2499 put_bits(&s->pb, 1, s->current_picture_ptr->top_field_first); 2500 put_bits(&s->pb, 1, s->alternate_scan); 2501 } 2502 //FIXME sprite stuff 2503 2504 put_bits(&s->pb, 5, s->qscale); 2505 2506 if (s->pict_type != FF_I_TYPE) 2507 put_bits(&s->pb, 3, s->f_code); /* fcode_for */ 2508 if (s->pict_type == FF_B_TYPE) 2509 put_bits(&s->pb, 3, s->b_code); /* fcode_back */ 2510 // printf("****frame %d\n", picture_number); 2511} 2512 2513#endif //CONFIG_ENCODERS 2514 2515/** 2516 * predicts the dc. 2517 * encoding quantized level -> quantized diff 2518 * decoding quantized diff -> quantized level 2519 * @param n block index (0-3 are luma, 4-5 are chroma) 2520 * @param dir_ptr pointer to an integer where the prediction direction will be stored 2521 */ 2522static inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, int level, int *dir_ptr, int encoding) 2523{ 2524 int a, b, c, wrap, pred, scale, ret; 2525 int16_t *dc_val; 2526 2527 /* find prediction */ 2528 if (n < 4) { 2529 scale = s->y_dc_scale; 2530 } else { 2531 scale = s->c_dc_scale; 2532 } 2533 if(IS_3IV1) 2534 scale= 8; 2535 2536 wrap= s->block_wrap[n]; 2537 dc_val = s->dc_val[0] + s->block_index[n]; 2538 2539 /* B C 2540 * A X 2541 */ 2542 a = dc_val[ - 1]; 2543 b = dc_val[ - 1 - wrap]; 2544 c = dc_val[ - wrap]; 2545 2546 /* outside slice handling (we can't do that by memset as we need the dc for error resilience) */ 2547 if(s->first_slice_line && n!=3){ 2548 if(n!=2) b=c= 1024; 2549 if(n!=1 && s->mb_x == s->resync_mb_x) b=a= 1024; 2550 } 2551 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1){ 2552 if(n==0 || n==4 || n==5) 2553 b=1024; 2554 } 2555 2556 if (abs(a - b) < abs(b - c)) { 2557 pred = c; 2558 *dir_ptr = 1; /* top */ 2559 } else { 2560 pred = a; 2561 *dir_ptr = 0; /* left */ 2562 } 2563 /* we assume pred is positive */ 2564 pred = FASTDIV((pred + (scale >> 1)), scale); 2565 2566 if(encoding){ 2567 ret = level - pred; 2568 }else{ 2569 level += pred; 2570 ret= level; 2571 if(s->error_recognition>=3){ 2572 if(level<0){ 2573 av_log(s->avctx, AV_LOG_ERROR, "dc<0 at %dx%d\n", s->mb_x, s->mb_y); 2574 return -1; 2575 } 2576 if(level*scale > 2048 + scale){ 2577 av_log(s->avctx, AV_LOG_ERROR, "dc overflow at %dx%d\n", s->mb_x, s->mb_y); 2578 return -1; 2579 } 2580 } 2581 } 2582 level *=scale; 2583 if(level&(~2047)){ 2584 if(level<0) 2585 level=0; 2586 else if(!(s->workaround_bugs&FF_BUG_DC_CLIP)) 2587 level=2047; 2588 } 2589 dc_val[0]= level; 2590 2591 return ret; 2592} 2593 2594/** 2595 * predicts the ac. 2596 * @param n block index (0-3 are luma, 4-5 are chroma) 2597 * @param dir the ac prediction direction 2598 */ 2599void mpeg4_pred_ac(MpegEncContext * s, DCTELEM *block, int n, 2600 int dir) 2601{ 2602 int i; 2603 int16_t *ac_val, *ac_val1; 2604 int8_t * const qscale_table= s->current_picture.qscale_table; 2605 2606 /* find prediction */ 2607 ac_val = s->ac_val[0][0] + s->block_index[n] * 16; 2608 ac_val1 = ac_val; 2609 if (s->ac_pred) { 2610 if (dir == 0) { 2611 const int xy= s->mb_x-1 + s->mb_y*s->mb_stride; 2612 /* left prediction */ 2613 ac_val -= 16; 2614 2615 if(s->mb_x==0 || s->qscale == qscale_table[xy] || n==1 || n==3){ 2616 /* same qscale */ 2617 for(i=1;i<8;i++) { 2618 block[s->dsp.idct_permutation[i<<3]] += ac_val[i]; 2619 } 2620 }else{ 2621 /* different qscale, we must rescale */ 2622 for(i=1;i<8;i++) { 2623 block[s->dsp.idct_permutation[i<<3]] += ROUNDED_DIV(ac_val[i]*qscale_table[xy], s->qscale); 2624 } 2625 } 2626 } else { 2627 const int xy= s->mb_x + s->mb_y*s->mb_stride - s->mb_stride; 2628 /* top prediction */ 2629 ac_val -= 16 * s->block_wrap[n]; 2630 2631 if(s->mb_y==0 || s->qscale == qscale_table[xy] || n==2 || n==3){ 2632 /* same qscale */ 2633 for(i=1;i<8;i++) { 2634 block[s->dsp.idct_permutation[i]] += ac_val[i + 8]; 2635 } 2636 }else{ 2637 /* different qscale, we must rescale */ 2638 for(i=1;i<8;i++) { 2639 block[s->dsp.idct_permutation[i]] += ROUNDED_DIV(ac_val[i + 8]*qscale_table[xy], s->qscale); 2640 } 2641 } 2642 } 2643 } 2644 /* left copy */ 2645 for(i=1;i<8;i++) 2646 ac_val1[i ] = block[s->dsp.idct_permutation[i<<3]]; 2647 2648 /* top copy */ 2649 for(i=1;i<8;i++) 2650 ac_val1[8 + i] = block[s->dsp.idct_permutation[i ]]; 2651 2652} 2653 2654#if CONFIG_ENCODERS 2655 2656/** 2657 * encodes the dc value. 2658 * @param n block index (0-3 are luma, 4-5 are chroma) 2659 */ 2660static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n) 2661{ 2662#if 1 2663// if(level<-255 || level>255) printf("dc overflow\n"); 2664 level+=256; 2665 if (n < 4) { 2666 /* luminance */ 2667 put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]); 2668 } else { 2669 /* chrominance */ 2670 put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]); 2671 } 2672#else 2673 int size, v; 2674 /* find number of bits */ 2675 size = 0; 2676 v = abs(level); 2677 while (v) { 2678 v >>= 1; 2679 size++; 2680 } 2681 2682 if (n < 4) { 2683 /* luminance */ 2684 put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]); 2685 } else { 2686 /* chrominance */ 2687 put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]); 2688 } 2689 2690 /* encode remaining bits */ 2691 if (size > 0) { 2692 if (level < 0) 2693 level = (-level) ^ ((1 << size) - 1); 2694 put_bits(&s->pb, size, level); 2695 if (size > 8) 2696 put_bits(&s->pb, 1, 1); 2697 } 2698#endif 2699} 2700 2701static inline int mpeg4_get_dc_length(int level, int n){ 2702 if (n < 4) { 2703 return uni_DCtab_lum_len[level + 256]; 2704 } else { 2705 return uni_DCtab_chrom_len[level + 256]; 2706 } 2707} 2708 2709/** 2710 * encodes a 8x8 block 2711 * @param n block index (0-3 are luma, 4-5 are chroma) 2712 */ 2713static inline void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, 2714 uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb) 2715{ 2716 int i, last_non_zero; 2717#if 0 //variables for the outcommented version 2718 int code, sign, last; 2719#endif 2720 const RLTable *rl; 2721 uint32_t *bits_tab; 2722 uint8_t *len_tab; 2723 const int last_index = s->block_last_index[n]; 2724 2725 if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away 2726 /* mpeg4 based DC predictor */ 2727 mpeg4_encode_dc(dc_pb, intra_dc, n); 2728 if(last_index<1) return; 2729 i = 1; 2730 rl = &rl_intra; 2731 bits_tab= uni_mpeg4_intra_rl_bits; 2732 len_tab = uni_mpeg4_intra_rl_len; 2733 } else { 2734 if(last_index<0) return; 2735 i = 0; 2736 rl = &rl_inter; 2737 bits_tab= uni_mpeg4_inter_rl_bits; 2738 len_tab = uni_mpeg4_inter_rl_len; 2739 } 2740 2741 /* AC coefs */ 2742 last_non_zero = i - 1; 2743#if 1 2744 for (; i < last_index; i++) { 2745 int level = block[ scan_table[i] ]; 2746 if (level) { 2747 int run = i - last_non_zero - 1; 2748 level+=64; 2749 if((level&(~127)) == 0){ 2750 const int index= UNI_MPEG4_ENC_INDEX(0, run, level); 2751 put_bits(ac_pb, len_tab[index], bits_tab[index]); 2752 }else{ //ESC3 2753 put_bits(ac_pb, 7+2+1+6+1+12+1, (3<<23)+(3<<21)+(0<<20)+(run<<14)+(1<<13)+(((level-64)&0xfff)<<1)+1); 2754 } 2755 last_non_zero = i; 2756 } 2757 } 2758 /*if(i<=last_index)*/{ 2759 int level = block[ scan_table[i] ]; 2760 int run = i - last_non_zero - 1; 2761 level+=64; 2762 if((level&(~127)) == 0){ 2763 const int index= UNI_MPEG4_ENC_INDEX(1, run, level); 2764 put_bits(ac_pb, len_tab[index], bits_tab[index]); 2765 }else{ //ESC3 2766 put_bits(ac_pb, 7+2+1+6+1+12+1, (3<<23)+(3<<21)+(1<<20)+(run<<14)+(1<<13)+(((level-64)&0xfff)<<1)+1); 2767 } 2768 } 2769#else 2770 for (; i <= last_index; i++) { 2771 const int slevel = block[ scan_table[i] ]; 2772 if (slevel) { 2773 int level; 2774 int run = i - last_non_zero - 1; 2775 last = (i == last_index); 2776 sign = 0; 2777 level = slevel; 2778 if (level < 0) { 2779 sign = 1; 2780 level = -level; 2781 } 2782 code = get_rl_index(rl, last, run, level); 2783 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); 2784 if (code == rl->n) { 2785 int level1, run1; 2786 level1 = level - rl->max_level[last][run]; 2787 if (level1 < 1) 2788 goto esc2; 2789 code = get_rl_index(rl, last, run, level1); 2790 if (code == rl->n) { 2791 esc2: 2792 put_bits(ac_pb, 1, 1); 2793 if (level > MAX_LEVEL) 2794 goto esc3; 2795 run1 = run - rl->max_run[last][level] - 1; 2796 if (run1 < 0) 2797 goto esc3; 2798 code = get_rl_index(rl, last, run1, level); 2799 if (code == rl->n) { 2800 esc3: 2801 /* third escape */ 2802 put_bits(ac_pb, 1, 1); 2803 put_bits(ac_pb, 1, last); 2804 put_bits(ac_pb, 6, run); 2805 put_bits(ac_pb, 1, 1); 2806 put_sbits(ac_pb, 12, slevel); 2807 put_bits(ac_pb, 1, 1); 2808 } else { 2809 /* second escape */ 2810 put_bits(ac_pb, 1, 0); 2811 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); 2812 put_bits(ac_pb, 1, sign); 2813 } 2814 } else { 2815 /* first escape */ 2816 put_bits(ac_pb, 1, 0); 2817 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); 2818 put_bits(ac_pb, 1, sign); 2819 } 2820 } else { 2821 put_bits(ac_pb, 1, sign); 2822 } 2823 last_non_zero = i; 2824 } 2825 } 2826#endif 2827} 2828 2829static int mpeg4_get_block_length(MpegEncContext * s, DCTELEM * block, int n, int intra_dc, 2830 uint8_t *scan_table) 2831{ 2832 int i, last_non_zero; 2833 const RLTable *rl; 2834 uint8_t *len_tab; 2835 const int last_index = s->block_last_index[n]; 2836 int len=0; 2837 2838 if (s->mb_intra) { //Note gcc (3.2.1 at least) will optimize this away 2839 /* mpeg4 based DC predictor */ 2840 len += mpeg4_get_dc_length(intra_dc, n); 2841 if(last_index<1) return len; 2842 i = 1; 2843 rl = &rl_intra; 2844 len_tab = uni_mpeg4_intra_rl_len; 2845 } else { 2846 if(last_index<0) return 0; 2847 i = 0; 2848 rl = &rl_inter; 2849 len_tab = uni_mpeg4_inter_rl_len; 2850 } 2851 2852 /* AC coefs */ 2853 last_non_zero = i - 1; 2854 for (; i < last_index; i++) { 2855 int level = block[ scan_table[i] ]; 2856 if (level) { 2857 int run = i - last_non_zero - 1; 2858 level+=64; 2859 if((level&(~127)) == 0){ 2860 const int index= UNI_MPEG4_ENC_INDEX(0, run, level); 2861 len += len_tab[index]; 2862 }else{ //ESC3 2863 len += 7+2+1+6+1+12+1; 2864 } 2865 last_non_zero = i; 2866 } 2867 } 2868 /*if(i<=last_index)*/{ 2869 int level = block[ scan_table[i] ]; 2870 int run = i - last_non_zero - 1; 2871 level+=64; 2872 if((level&(~127)) == 0){ 2873 const int index= UNI_MPEG4_ENC_INDEX(1, run, level); 2874 len += len_tab[index]; 2875 }else{ //ESC3 2876 len += 7+2+1+6+1+12+1; 2877 } 2878 } 2879 2880 return len; 2881} 2882 2883#endif 2884 2885 2886/***********************************************/ 2887/* decoding */ 2888 2889static VLC intra_MCBPC_vlc; 2890static VLC inter_MCBPC_vlc; 2891static VLC cbpy_vlc; 2892static VLC mv_vlc; 2893static VLC dc_lum, dc_chrom; 2894static VLC sprite_trajectory; 2895static VLC mb_type_b_vlc; 2896static VLC h263_mbtype_b_vlc; 2897static VLC cbpc_b_vlc; 2898 2899/* init vlcs */ 2900 2901/* XXX: find a better solution to handle static init */ 2902void h263_decode_init_vlc(MpegEncContext *s) 2903{ 2904 static int done = 0; 2905 2906 if (!done) { 2907 done = 1; 2908 2909 INIT_VLC_STATIC(&intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 9, 2910 intra_MCBPC_bits, 1, 1, 2911 intra_MCBPC_code, 1, 1, 72); 2912 INIT_VLC_STATIC(&inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 28, 2913 inter_MCBPC_bits, 1, 1, 2914 inter_MCBPC_code, 1, 1, 198); 2915 INIT_VLC_STATIC(&cbpy_vlc, CBPY_VLC_BITS, 16, 2916 &cbpy_tab[0][1], 2, 1, 2917 &cbpy_tab[0][0], 2, 1, 64); 2918 INIT_VLC_STATIC(&mv_vlc, MV_VLC_BITS, 33, 2919 &mvtab[0][1], 2, 1, 2920 &mvtab[0][0], 2, 1, 538); 2921 init_rl(&rl_inter, static_rl_table_store[0]); 2922 init_rl(&rl_intra, static_rl_table_store[1]); 2923 init_rl(&rvlc_rl_inter, static_rl_table_store[3]); 2924 init_rl(&rvlc_rl_intra, static_rl_table_store[4]); 2925 init_rl(&rl_intra_aic, static_rl_table_store[2]); 2926 INIT_VLC_RL(rl_inter, 554); 2927 INIT_VLC_RL(rl_intra, 554); 2928 INIT_VLC_RL(rvlc_rl_inter, 1072); 2929 INIT_VLC_RL(rvlc_rl_intra, 1072); 2930 INIT_VLC_RL(rl_intra_aic, 554); 2931 INIT_VLC_STATIC(&dc_lum, DC_VLC_BITS, 10 /* 13 */, 2932 &DCtab_lum[0][1], 2, 1, 2933 &DCtab_lum[0][0], 2, 1, 512); 2934 INIT_VLC_STATIC(&dc_chrom, DC_VLC_BITS, 10 /* 13 */, 2935 &DCtab_chrom[0][1], 2, 1, 2936 &DCtab_chrom[0][0], 2, 1, 512); 2937 INIT_VLC_STATIC(&sprite_trajectory, SPRITE_TRAJ_VLC_BITS, 15, 2938 &sprite_trajectory_tab[0][1], 4, 2, 2939 &sprite_trajectory_tab[0][0], 4, 2, 128); 2940 INIT_VLC_STATIC(&mb_type_b_vlc, MB_TYPE_B_VLC_BITS, 4, 2941 &mb_type_b_tab[0][1], 2, 1, 2942 &mb_type_b_tab[0][0], 2, 1, 16); 2943 INIT_VLC_STATIC(&h263_mbtype_b_vlc, H263_MBTYPE_B_VLC_BITS, 15, 2944 &h263_mbtype_b_tab[0][1], 2, 1, 2945 &h263_mbtype_b_tab[0][0], 2, 1, 80); 2946 INIT_VLC_STATIC(&cbpc_b_vlc, CBPC_B_VLC_BITS, 4, 2947 &cbpc_b_tab[0][1], 2, 1, 2948 &cbpc_b_tab[0][0], 2, 1, 8); 2949 } 2950} 2951 2952/** 2953 * Get the GOB height based on picture height. 2954 */ 2955int ff_h263_get_gob_height(MpegEncContext *s){ 2956 if (s->height <= 400) 2957 return 1; 2958 else if (s->height <= 800) 2959 return 2; 2960 else 2961 return 4; 2962} 2963 2964int ff_h263_decode_mba(MpegEncContext *s) 2965{ 2966 int i, mb_pos; 2967 2968 for(i=0; i<6; i++){ 2969 if(s->mb_num-1 <= ff_mba_max[i]) break; 2970 } 2971 mb_pos= get_bits(&s->gb, ff_mba_length[i]); 2972 s->mb_x= mb_pos % s->mb_width; 2973 s->mb_y= mb_pos / s->mb_width; 2974 2975 return mb_pos; 2976} 2977 2978void ff_h263_encode_mba(MpegEncContext *s) 2979{ 2980 int i, mb_pos; 2981 2982 for(i=0; i<6; i++){ 2983 if(s->mb_num-1 <= ff_mba_max[i]) break; 2984 } 2985 mb_pos= s->mb_x + s->mb_width*s->mb_y; 2986 put_bits(&s->pb, ff_mba_length[i], mb_pos); 2987} 2988 2989/** 2990 * decodes the group of blocks header or slice header. 2991 * @return <0 if an error occurred 2992 */ 2993static int h263_decode_gob_header(MpegEncContext *s) 2994{ 2995 unsigned int val, gfid, gob_number; 2996 int left; 2997 2998 /* Check for GOB Start Code */ 2999 val = show_bits(&s->gb, 16); 3000 if(val) 3001 return -1; 3002 3003 /* We have a GBSC probably with GSTUFF */ 3004 skip_bits(&s->gb, 16); /* Drop the zeros */ 3005 left= s->gb.size_in_bits - get_bits_count(&s->gb); 3006 //MN: we must check the bits left or we might end in a infinite loop (or segfault) 3007 for(;left>13; left--){ 3008 if(get_bits1(&s->gb)) break; /* Seek the '1' bit */ 3009 } 3010 if(left<=13) 3011 return -1; 3012 3013 if(s->h263_slice_structured){ 3014 if(get_bits1(&s->gb)==0) 3015 return -1; 3016 3017 ff_h263_decode_mba(s); 3018 3019 if(s->mb_num > 1583) 3020 if(get_bits1(&s->gb)==0) 3021 return -1; 3022 3023 s->qscale = get_bits(&s->gb, 5); /* SQUANT */ 3024 if(get_bits1(&s->gb)==0) 3025 return -1; 3026 gfid = get_bits(&s->gb, 2); /* GFID */ 3027 }else{ 3028 gob_number = get_bits(&s->gb, 5); /* GN */ 3029 s->mb_x= 0; 3030 s->mb_y= s->gob_index* gob_number; 3031 gfid = get_bits(&s->gb, 2); /* GFID */ 3032 s->qscale = get_bits(&s->gb, 5); /* GQUANT */ 3033 } 3034 3035 if(s->mb_y >= s->mb_height) 3036 return -1; 3037 3038 if(s->qscale==0) 3039 return -1; 3040 3041 return 0; 3042} 3043 3044static inline void memsetw(short *tab, int val, int n) 3045{ 3046 int i; 3047 for(i=0;i<n;i++) 3048 tab[i] = val; 3049} 3050 3051#if CONFIG_ENCODERS 3052 3053void ff_mpeg4_init_partitions(MpegEncContext *s) 3054{ 3055 uint8_t *start= pbBufPtr(&s->pb); 3056 uint8_t *end= s->pb.buf_end; 3057 int size= end - start; 3058 int pb_size = (((long)start + size/3)&(~3)) - (long)start; 3059 int tex_size= (size - 2*pb_size)&(~3); 3060 3061 set_put_bits_buffer_size(&s->pb, pb_size); 3062 init_put_bits(&s->tex_pb, start + pb_size , tex_size); 3063 init_put_bits(&s->pb2 , start + pb_size + tex_size, pb_size); 3064} 3065 3066void ff_mpeg4_merge_partitions(MpegEncContext *s) 3067{ 3068 const int pb2_len = put_bits_count(&s->pb2 ); 3069 const int tex_pb_len= put_bits_count(&s->tex_pb); 3070 const int bits= put_bits_count(&s->pb); 3071 3072 if(s->pict_type==FF_I_TYPE){ 3073 put_bits(&s->pb, 19, DC_MARKER); 3074 s->misc_bits+=19 + pb2_len + bits - s->last_bits; 3075 s->i_tex_bits+= tex_pb_len; 3076 }else{ 3077 put_bits(&s->pb, 17, MOTION_MARKER); 3078 s->misc_bits+=17 + pb2_len; 3079 s->mv_bits+= bits - s->last_bits; 3080 s->p_tex_bits+= tex_pb_len; 3081 } 3082 3083 flush_put_bits(&s->pb2); 3084 flush_put_bits(&s->tex_pb); 3085 3086 set_put_bits_buffer_size(&s->pb, s->pb2.buf_end - s->pb.buf); 3087 ff_copy_bits(&s->pb, s->pb2.buf , pb2_len); 3088 ff_copy_bits(&s->pb, s->tex_pb.buf, tex_pb_len); 3089 s->last_bits= put_bits_count(&s->pb); 3090} 3091 3092#endif //CONFIG_ENCODERS 3093 3094int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s){ 3095 switch(s->pict_type){ 3096 case FF_I_TYPE: 3097 return 16; 3098 case FF_P_TYPE: 3099 case FF_S_TYPE: 3100 return s->f_code+15; 3101 case FF_B_TYPE: 3102 return FFMAX3(s->f_code, s->b_code, 2) + 15; 3103 default: 3104 return -1; 3105 } 3106} 3107 3108#if CONFIG_ENCODERS 3109 3110void ff_mpeg4_encode_video_packet_header(MpegEncContext *s) 3111{ 3112 int mb_num_bits= av_log2(s->mb_num - 1) + 1; 3113 3114 put_bits(&s->pb, ff_mpeg4_get_video_packet_prefix_length(s), 0); 3115 put_bits(&s->pb, 1, 1); 3116 3117 put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width); 3118 put_bits(&s->pb, s->quant_precision, s->qscale); 3119 put_bits(&s->pb, 1, 0); /* no HEC */ 3120} 3121 3122#endif //CONFIG_ENCODERS 3123 3124/** 3125 * check if the next stuff is a resync marker or the end. 3126 * @return 0 if not 3127 */ 3128static inline int mpeg4_is_resync(MpegEncContext *s){ 3129 int bits_count= get_bits_count(&s->gb); 3130 int v= show_bits(&s->gb, 16); 3131 3132 if(s->workaround_bugs&FF_BUG_NO_PADDING){ 3133 return 0; 3134 } 3135 3136 while(v<=0xFF){ 3137 if(s->pict_type==FF_B_TYPE || (v>>(8-s->pict_type)!=1) || s->partitioned_frame) 3138 break; 3139 skip_bits(&s->gb, 8+s->pict_type); 3140 bits_count+= 8+s->pict_type; 3141 v= show_bits(&s->gb, 16); 3142 } 3143 3144 if(bits_count + 8 >= s->gb.size_in_bits){ 3145 v>>=8; 3146 v|= 0x7F >> (7-(bits_count&7)); 3147 3148 if(v==0x7F) 3149 return 1; 3150 }else{ 3151 if(v == ff_mpeg4_resync_prefix[bits_count&7]){ 3152 int len; 3153 GetBitContext gb= s->gb; 3154 3155 skip_bits(&s->gb, 1); 3156 align_get_bits(&s->gb); 3157 3158 for(len=0; len<32; len++){ 3159 if(get_bits1(&s->gb)) break; 3160 } 3161 3162 s->gb= gb; 3163 3164 if(len>=ff_mpeg4_get_video_packet_prefix_length(s)) 3165 return 1; 3166 } 3167 } 3168 return 0; 3169} 3170 3171/** 3172 * decodes the next video packet. 3173 * @return <0 if something went wrong 3174 */ 3175static int mpeg4_decode_video_packet_header(MpegEncContext *s) 3176{ 3177 int mb_num_bits= av_log2(s->mb_num - 1) + 1; 3178 int header_extension=0, mb_num, len; 3179 3180 /* is there enough space left for a video packet + header */ 3181 if( get_bits_count(&s->gb) > s->gb.size_in_bits-20) return -1; 3182 3183 for(len=0; len<32; len++){ 3184 if(get_bits1(&s->gb)) break; 3185 } 3186 3187 if(len!=ff_mpeg4_get_video_packet_prefix_length(s)){ 3188 av_log(s->avctx, AV_LOG_ERROR, "marker does not match f_code\n"); 3189 return -1; 3190 } 3191 3192 if(s->shape != RECT_SHAPE){ 3193 header_extension= get_bits1(&s->gb); 3194 //FIXME more stuff here 3195 } 3196 3197 mb_num= get_bits(&s->gb, mb_num_bits); 3198 if(mb_num>=s->mb_num){ 3199 av_log(s->avctx, AV_LOG_ERROR, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_num); 3200 return -1; 3201 } 3202 if(s->pict_type == FF_B_TYPE){ 3203 while(s->next_picture.mbskip_table[ s->mb_index2xy[ mb_num ] ]) mb_num++; 3204 if(mb_num >= s->mb_num) return -1; // slice contains just skipped MBs which where already decoded 3205 } 3206 3207 s->mb_x= mb_num % s->mb_width; 3208 s->mb_y= mb_num / s->mb_width; 3209 3210 if(s->shape != BIN_ONLY_SHAPE){ 3211 int qscale= get_bits(&s->gb, s->quant_precision); 3212 if(qscale) 3213 s->chroma_qscale=s->qscale= qscale; 3214 } 3215 3216 if(s->shape == RECT_SHAPE){ 3217 header_extension= get_bits1(&s->gb); 3218 } 3219 if(header_extension){ 3220 int time_increment; 3221 int time_incr=0; 3222 3223 while (get_bits1(&s->gb) != 0) 3224 time_incr++; 3225 3226 check_marker(&s->gb, "before time_increment in video packed header"); 3227 time_increment= get_bits(&s->gb, s->time_increment_bits); 3228 check_marker(&s->gb, "before vop_coding_type in video packed header"); 3229 3230 skip_bits(&s->gb, 2); /* vop coding type */ 3231 //FIXME not rect stuff here 3232 3233 if(s->shape != BIN_ONLY_SHAPE){ 3234 skip_bits(&s->gb, 3); /* intra dc vlc threshold */ 3235//FIXME don't just ignore everything 3236 if(s->pict_type == FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE){ 3237 mpeg4_decode_sprite_trajectory(s, &s->gb); 3238 av_log(s->avctx, AV_LOG_ERROR, "untested\n"); 3239 } 3240 3241 //FIXME reduced res stuff here 3242 3243 if (s->pict_type != FF_I_TYPE) { 3244 int f_code = get_bits(&s->gb, 3); /* fcode_for */ 3245 if(f_code==0){ 3246 av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (f_code=0)\n"); 3247 } 3248 } 3249 if (s->pict_type == FF_B_TYPE) { 3250 int b_code = get_bits(&s->gb, 3); 3251 if(b_code==0){ 3252 av_log(s->avctx, AV_LOG_ERROR, "Error, video packet header damaged (b_code=0)\n"); 3253 } 3254 } 3255 } 3256 } 3257 //FIXME new-pred stuff 3258 3259//printf("parse ok %d %d %d %d\n", mb_num, s->mb_x + s->mb_y*s->mb_width, get_bits_count(gb), get_bits_count(&s->gb)); 3260 3261 return 0; 3262} 3263 3264void ff_mpeg4_clean_buffers(MpegEncContext *s) 3265{ 3266 int c_wrap, c_xy, l_wrap, l_xy; 3267 3268 l_wrap= s->b8_stride; 3269 l_xy= (2*s->mb_y-1)*l_wrap + s->mb_x*2 - 1; 3270 c_wrap= s->mb_stride; 3271 c_xy= (s->mb_y-1)*c_wrap + s->mb_x - 1; 3272 3273#if 0 3274 /* clean DC */ 3275 memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1); 3276 memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1); 3277 memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1); 3278#endif 3279 3280 /* clean AC */ 3281 memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(int16_t)); 3282 memset(s->ac_val[1] + c_xy, 0, (c_wrap +1)*16*sizeof(int16_t)); 3283 memset(s->ac_val[2] + c_xy, 0, (c_wrap +1)*16*sizeof(int16_t)); 3284 3285 /* clean MV */ 3286 // we can't clear the MVs as they might be needed by a b frame 3287// memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(int16_t)); 3288// memset(s->motion_val, 0, 2*sizeof(int16_t)*(2 + s->mb_width*2)*(2 + s->mb_height*2)); 3289 s->last_mv[0][0][0]= 3290 s->last_mv[0][0][1]= 3291 s->last_mv[1][0][0]= 3292 s->last_mv[1][0][1]= 0; 3293} 3294 3295/** 3296 * finds the next resync_marker 3297 * @param p pointer to buffer to scan 3298 * @param end pointer to the end of the buffer 3299 * @return pointer to the next resync_marker, or \p end if none was found 3300 */ 3301const uint8_t *ff_h263_find_resync_marker(const uint8_t *restrict p, const uint8_t * restrict end) 3302{ 3303 assert(p < end); 3304 3305 end-=2; 3306 p++; 3307 for(;p<end; p+=2){ 3308 if(!*p){ 3309 if (!p[-1] && p[1]) return p - 1; 3310 else if(!p[ 1] && p[2]) return p; 3311 } 3312 } 3313 return end+2; 3314} 3315 3316/** 3317 * decodes the group of blocks / video packet header. 3318 * @return bit position of the resync_marker, or <0 if none was found 3319 */ 3320int ff_h263_resync(MpegEncContext *s){ 3321 int left, pos, ret; 3322 3323 if(s->codec_id==CODEC_ID_MPEG4){ 3324 skip_bits1(&s->gb); 3325 align_get_bits(&s->gb); 3326 } 3327 3328 if(show_bits(&s->gb, 16)==0){ 3329 pos= get_bits_count(&s->gb); 3330 if(s->codec_id==CODEC_ID_MPEG4) 3331 ret= mpeg4_decode_video_packet_header(s); 3332 else 3333 ret= h263_decode_gob_header(s); 3334 if(ret>=0) 3335 return pos; 3336 } 3337 //OK, it's not where it is supposed to be ... 3338 s->gb= s->last_resync_gb; 3339 align_get_bits(&s->gb); 3340 left= s->gb.size_in_bits - get_bits_count(&s->gb); 3341 3342 for(;left>16+1+5+5; left-=8){ 3343 if(show_bits(&s->gb, 16)==0){ 3344 GetBitContext bak= s->gb; 3345 3346 pos= get_bits_count(&s->gb); 3347 if(s->codec_id==CODEC_ID_MPEG4) 3348 ret= mpeg4_decode_video_packet_header(s); 3349 else 3350 ret= h263_decode_gob_header(s); 3351 if(ret>=0) 3352 return pos; 3353 3354 s->gb= bak; 3355 } 3356 skip_bits(&s->gb, 8); 3357 } 3358 3359 return -1; 3360} 3361 3362/** 3363 * gets the average motion vector for a GMC MB. 3364 * @param n either 0 for the x component or 1 for y 3365 * @returns the average MV for a GMC MB 3366 */ 3367static inline int get_amv(MpegEncContext *s, int n){ 3368 int x, y, mb_v, sum, dx, dy, shift; 3369 int len = 1 << (s->f_code + 4); 3370 const int a= s->sprite_warping_accuracy; 3371 3372 if(s->workaround_bugs & FF_BUG_AMV) 3373 len >>= s->quarter_sample; 3374 3375 if(s->real_sprite_warping_points==1){ 3376 if(s->divx_version==500 && s->divx_build==413) 3377 sum= s->sprite_offset[0][n] / (1<<(a - s->quarter_sample)); 3378 else 3379 sum= RSHIFT(s->sprite_offset[0][n]<<s->quarter_sample, a); 3380 }else{ 3381 dx= s->sprite_delta[n][0]; 3382 dy= s->sprite_delta[n][1]; 3383 shift= s->sprite_shift[0]; 3384 if(n) dy -= 1<<(shift + a + 1); 3385 else dx -= 1<<(shift + a + 1); 3386 mb_v= s->sprite_offset[0][n] + dx*s->mb_x*16 + dy*s->mb_y*16; 3387 3388 sum=0; 3389 for(y=0; y<16; y++){ 3390 int v; 3391 3392 v= mb_v + dy*y; 3393 //XXX FIXME optimize 3394 for(x=0; x<16; x++){ 3395 sum+= v>>shift; 3396 v+= dx; 3397 } 3398 } 3399 sum= RSHIFT(sum, a+8-s->quarter_sample); 3400 } 3401 3402 if (sum < -len) sum= -len; 3403 else if (sum >= len) sum= len-1; 3404 3405 return sum; 3406} 3407 3408/** 3409 * decodes first partition. 3410 * @return number of MBs decoded or <0 if an error occurred 3411 */ 3412static int mpeg4_decode_partition_a(MpegEncContext *s){ 3413 int mb_num; 3414 static const int8_t quant_tab[4] = { -1, -2, 1, 2 }; 3415 3416 /* decode first partition */ 3417 mb_num=0; 3418 s->first_slice_line=1; 3419 for(; s->mb_y<s->mb_height; s->mb_y++){ 3420 ff_init_block_index(s); 3421 for(; s->mb_x<s->mb_width; s->mb_x++){ 3422 const int xy= s->mb_x + s->mb_y*s->mb_stride; 3423 int cbpc; 3424 int dir=0; 3425 3426 mb_num++; 3427 ff_update_block_index(s); 3428 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1) 3429 s->first_slice_line=0; 3430 3431 if(s->pict_type==FF_I_TYPE){ 3432 int i; 3433 3434 do{ 3435 if(show_bits_long(&s->gb, 19)==DC_MARKER){ 3436 return mb_num-1; 3437 } 3438 3439 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2); 3440 if (cbpc < 0){ 3441 av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y); 3442 return -1; 3443 } 3444 }while(cbpc == 8); 3445 3446 s->cbp_table[xy]= cbpc & 3; 3447 s->current_picture.mb_type[xy]= MB_TYPE_INTRA; 3448 s->mb_intra = 1; 3449 3450 if(cbpc & 4) { 3451 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]); 3452 } 3453 s->current_picture.qscale_table[xy]= s->qscale; 3454 3455 s->mbintra_table[xy]= 1; 3456 for(i=0; i<6; i++){ 3457 int dc_pred_dir; 3458 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir); 3459 if(dc < 0){ 3460 av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y); 3461 return -1; 3462 } 3463 dir<<=1; 3464 if(dc_pred_dir) dir|=1; 3465 } 3466 s->pred_dir_table[xy]= dir; 3467 }else{ /* P/S_TYPE */ 3468 int mx, my, pred_x, pred_y, bits; 3469 int16_t * const mot_val= s->current_picture.motion_val[0][s->block_index[0]]; 3470 const int stride= s->b8_stride*2; 3471 3472try_again: 3473 bits= show_bits(&s->gb, 17); 3474 if(bits==MOTION_MARKER){ 3475 return mb_num-1; 3476 } 3477 skip_bits1(&s->gb); 3478 if(bits&0x10000){ 3479 /* skip mb */ 3480 if(s->pict_type==FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE){ 3481 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0; 3482 mx= get_amv(s, 0); 3483 my= get_amv(s, 1); 3484 }else{ 3485 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0; 3486 mx=my=0; 3487 } 3488 mot_val[0 ]= mot_val[2 ]= 3489 mot_val[0+stride]= mot_val[2+stride]= mx; 3490 mot_val[1 ]= mot_val[3 ]= 3491 mot_val[1+stride]= mot_val[3+stride]= my; 3492 3493 if(s->mbintra_table[xy]) 3494 ff_clean_intra_table_entries(s); 3495 continue; 3496 } 3497 3498 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2); 3499 if (cbpc < 0){ 3500 av_log(s->avctx, AV_LOG_ERROR, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y); 3501 return -1; 3502 } 3503 if(cbpc == 20) 3504 goto try_again; 3505 3506 s->cbp_table[xy]= cbpc&(8+3); //8 is dquant 3507 3508 s->mb_intra = ((cbpc & 4) != 0); 3509 3510 if(s->mb_intra){ 3511 s->current_picture.mb_type[xy]= MB_TYPE_INTRA; 3512 s->mbintra_table[xy]= 1; 3513 mot_val[0 ]= mot_val[2 ]= 3514 mot_val[0+stride]= mot_val[2+stride]= 0; 3515 mot_val[1 ]= mot_val[3 ]= 3516 mot_val[1+stride]= mot_val[3+stride]= 0; 3517 }else{ 3518 if(s->mbintra_table[xy]) 3519 ff_clean_intra_table_entries(s); 3520 3521 if(s->pict_type==FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0) 3522 s->mcsel= get_bits1(&s->gb); 3523 else s->mcsel= 0; 3524 3525 if ((cbpc & 16) == 0) { 3526 /* 16x16 motion prediction */ 3527 3528 h263_pred_motion(s, 0, 0, &pred_x, &pred_y); 3529 if(!s->mcsel){ 3530 mx = h263_decode_motion(s, pred_x, s->f_code); 3531 if (mx >= 0xffff) 3532 return -1; 3533 3534 my = h263_decode_motion(s, pred_y, s->f_code); 3535 if (my >= 0xffff) 3536 return -1; 3537 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0; 3538 } else { 3539 mx = get_amv(s, 0); 3540 my = get_amv(s, 1); 3541 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_GMC | MB_TYPE_L0; 3542 } 3543 3544 mot_val[0 ]= mot_val[2 ] = 3545 mot_val[0+stride]= mot_val[2+stride]= mx; 3546 mot_val[1 ]= mot_val[3 ]= 3547 mot_val[1+stride]= mot_val[3+stride]= my; 3548 } else { 3549 int i; 3550 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0; 3551 for(i=0;i<4;i++) { 3552 int16_t *mot_val= h263_pred_motion(s, i, 0, &pred_x, &pred_y); 3553 mx = h263_decode_motion(s, pred_x, s->f_code); 3554 if (mx >= 0xffff) 3555 return -1; 3556 3557 my = h263_decode_motion(s, pred_y, s->f_code); 3558 if (my >= 0xffff) 3559 return -1; 3560 mot_val[0] = mx; 3561 mot_val[1] = my; 3562 } 3563 } 3564 } 3565 } 3566 } 3567 s->mb_x= 0; 3568 } 3569 3570 return mb_num; 3571} 3572 3573/** 3574 * decode second partition. 3575 * @return <0 if an error occurred 3576 */ 3577static int mpeg4_decode_partition_b(MpegEncContext *s, int mb_count){ 3578 int mb_num=0; 3579 static const int8_t quant_tab[4] = { -1, -2, 1, 2 }; 3580 3581 s->mb_x= s->resync_mb_x; 3582 s->first_slice_line=1; 3583 for(s->mb_y= s->resync_mb_y; mb_num < mb_count; s->mb_y++){ 3584 ff_init_block_index(s); 3585 for(; mb_num < mb_count && s->mb_x<s->mb_width; s->mb_x++){ 3586 const int xy= s->mb_x + s->mb_y*s->mb_stride; 3587 3588 mb_num++; 3589 ff_update_block_index(s); 3590 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1) 3591 s->first_slice_line=0; 3592 3593 if(s->pict_type==FF_I_TYPE){ 3594 int ac_pred= get_bits1(&s->gb); 3595 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); 3596 if(cbpy<0){ 3597 av_log(s->avctx, AV_LOG_ERROR, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y); 3598 return -1; 3599 } 3600 3601 s->cbp_table[xy]|= cbpy<<2; 3602 s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED; 3603 }else{ /* P || S_TYPE */ 3604 if(IS_INTRA(s->current_picture.mb_type[xy])){ 3605 int dir=0,i; 3606 int ac_pred = get_bits1(&s->gb); 3607 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); 3608 3609 if(cbpy<0){ 3610 av_log(s->avctx, AV_LOG_ERROR, "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y); 3611 return -1; 3612 } 3613 3614 if(s->cbp_table[xy] & 8) { 3615 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]); 3616 } 3617 s->current_picture.qscale_table[xy]= s->qscale; 3618 3619 for(i=0; i<6; i++){ 3620 int dc_pred_dir; 3621 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir); 3622 if(dc < 0){ 3623 av_log(s->avctx, AV_LOG_ERROR, "DC corrupted at %d %d\n", s->mb_x, s->mb_y); 3624 return -1; 3625 } 3626 dir<<=1; 3627 if(dc_pred_dir) dir|=1; 3628 } 3629 s->cbp_table[xy]&= 3; //remove dquant 3630 s->cbp_table[xy]|= cbpy<<2; 3631 s->current_picture.mb_type[xy] |= ac_pred*MB_TYPE_ACPRED; 3632 s->pred_dir_table[xy]= dir; 3633 }else if(IS_SKIP(s->current_picture.mb_type[xy])){ 3634 s->current_picture.qscale_table[xy]= s->qscale; 3635 s->cbp_table[xy]= 0; 3636 }else{ 3637 int cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); 3638 3639 if(cbpy<0){ 3640 av_log(s->avctx, AV_LOG_ERROR, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y); 3641 return -1; 3642 } 3643 3644 if(s->cbp_table[xy] & 8) { 3645 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]); 3646 } 3647 s->current_picture.qscale_table[xy]= s->qscale; 3648 3649 s->cbp_table[xy]&= 3; //remove dquant 3650 s->cbp_table[xy]|= (cbpy^0xf)<<2; 3651 } 3652 } 3653 } 3654 if(mb_num >= mb_count) return 0; 3655 s->mb_x= 0; 3656 } 3657 return 0; 3658} 3659 3660/** 3661 * decodes the first & second partition 3662 * @return <0 if error (and sets error type in the error_status_table) 3663 */ 3664int ff_mpeg4_decode_partitions(MpegEncContext *s) 3665{ 3666 int mb_num; 3667 const int part_a_error= s->pict_type==FF_I_TYPE ? (DC_ERROR|MV_ERROR) : MV_ERROR; 3668 const int part_a_end = s->pict_type==FF_I_TYPE ? (DC_END |MV_END) : MV_END; 3669 3670 mb_num= mpeg4_decode_partition_a(s); 3671 if(mb_num<0){ 3672 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error); 3673 return -1; 3674 } 3675 3676 if(s->resync_mb_x + s->resync_mb_y*s->mb_width + mb_num > s->mb_num){ 3677 av_log(s->avctx, AV_LOG_ERROR, "slice below monitor ...\n"); 3678 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, part_a_error); 3679 return -1; 3680 } 3681 3682 s->mb_num_left= mb_num; 3683 3684 if(s->pict_type==FF_I_TYPE){ 3685 while(show_bits(&s->gb, 9) == 1) 3686 skip_bits(&s->gb, 9); 3687 if(get_bits_long(&s->gb, 19)!=DC_MARKER){ 3688 av_log(s->avctx, AV_LOG_ERROR, "marker missing after first I partition at %d %d\n", s->mb_x, s->mb_y); 3689 return -1; 3690 } 3691 }else{ 3692 while(show_bits(&s->gb, 10) == 1) 3693 skip_bits(&s->gb, 10); 3694 if(get_bits(&s->gb, 17)!=MOTION_MARKER){ 3695 av_log(s->avctx, AV_LOG_ERROR, "marker missing after first P partition at %d %d\n", s->mb_x, s->mb_y); 3696 return -1; 3697 } 3698 } 3699 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, part_a_end); 3700 3701 if( mpeg4_decode_partition_b(s, mb_num) < 0){ 3702 if(s->pict_type==FF_P_TYPE) 3703 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, DC_ERROR); 3704 return -1; 3705 }else{ 3706 if(s->pict_type==FF_P_TYPE) 3707 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, DC_END); 3708 } 3709 3710 return 0; 3711} 3712 3713/** 3714 * decode partition C of one MB. 3715 * @return <0 if an error occurred 3716 */ 3717static int mpeg4_decode_partitioned_mb(MpegEncContext *s, DCTELEM block[6][64]) 3718{ 3719 int cbp, mb_type; 3720 const int xy= s->mb_x + s->mb_y*s->mb_stride; 3721 3722 mb_type= s->current_picture.mb_type[xy]; 3723 cbp = s->cbp_table[xy]; 3724 3725 s->use_intra_dc_vlc= s->qscale < s->intra_dc_threshold; 3726 3727 if(s->current_picture.qscale_table[xy] != s->qscale){ 3728 ff_set_qscale(s, s->current_picture.qscale_table[xy] ); 3729 } 3730 3731 if (s->pict_type == FF_P_TYPE || s->pict_type==FF_S_TYPE) { 3732 int i; 3733 for(i=0; i<4; i++){ 3734 s->mv[0][i][0] = s->current_picture.motion_val[0][ s->block_index[i] ][0]; 3735 s->mv[0][i][1] = s->current_picture.motion_val[0][ s->block_index[i] ][1]; 3736 } 3737 s->mb_intra = IS_INTRA(mb_type); 3738 3739 if (IS_SKIP(mb_type)) { 3740 /* skip mb */ 3741 for(i=0;i<6;i++) 3742 s->block_last_index[i] = -1; 3743 s->mv_dir = MV_DIR_FORWARD; 3744 s->mv_type = MV_TYPE_16X16; 3745 if(s->pict_type==FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE){ 3746 s->mcsel=1; 3747 s->mb_skipped = 0; 3748 }else{ 3749 s->mcsel=0; 3750 s->mb_skipped = 1; 3751 } 3752 }else if(s->mb_intra){ 3753 s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]); 3754 }else if(!s->mb_intra){ 3755// s->mcsel= 0; //FIXME do we need to init that 3756 3757 s->mv_dir = MV_DIR_FORWARD; 3758 if (IS_8X8(mb_type)) { 3759 s->mv_type = MV_TYPE_8X8; 3760 } else { 3761 s->mv_type = MV_TYPE_16X16; 3762 } 3763 } 3764 } else { /* I-Frame */ 3765 s->mb_intra = 1; 3766 s->ac_pred = IS_ACPRED(s->current_picture.mb_type[xy]); 3767 } 3768 3769 if (!IS_SKIP(mb_type)) { 3770 int i; 3771 s->dsp.clear_blocks(s->block[0]); 3772 /* decode each block */ 3773 for (i = 0; i < 6; i++) { 3774 if(mpeg4_decode_block(s, block[i], i, cbp&32, s->mb_intra, s->rvlc) < 0){ 3775 av_log(s->avctx, AV_LOG_ERROR, "texture corrupted at %d %d %d\n", s->mb_x, s->mb_y, s->mb_intra); 3776 return -1; 3777 } 3778 cbp+=cbp; 3779 } 3780 } 3781 3782 /* per-MB end of slice check */ 3783 3784 if(--s->mb_num_left <= 0){ 3785//printf("%06X %d\n", show_bits(&s->gb, 24), s->gb.size_in_bits - get_bits_count(&s->gb)); 3786 if(mpeg4_is_resync(s)) 3787 return SLICE_END; 3788 else 3789 return SLICE_NOEND; 3790 }else{ 3791 if(mpeg4_is_resync(s)){ 3792 const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1; 3793 if(s->cbp_table[xy+delta]) 3794 return SLICE_END; 3795 } 3796 return SLICE_OK; 3797 } 3798} 3799 3800/** 3801 * read the next MVs for OBMC. yes this is a ugly hack, feel free to send a patch :) 3802 */ 3803static void preview_obmc(MpegEncContext *s){ 3804 GetBitContext gb= s->gb; 3805 3806 int cbpc, i, pred_x, pred_y, mx, my; 3807 int16_t *mot_val; 3808 const int xy= s->mb_x + 1 + s->mb_y * s->mb_stride; 3809 const int stride= s->b8_stride*2; 3810 3811 for(i=0; i<4; i++) 3812 s->block_index[i]+= 2; 3813 for(i=4; i<6; i++) 3814 s->block_index[i]+= 1; 3815 s->mb_x++; 3816 3817 assert(s->pict_type == FF_P_TYPE); 3818 3819 do{ 3820 if (get_bits1(&s->gb)) { 3821 /* skip mb */ 3822 mot_val = s->current_picture.motion_val[0][ s->block_index[0] ]; 3823 mot_val[0 ]= mot_val[2 ]= 3824 mot_val[0+stride]= mot_val[2+stride]= 0; 3825 mot_val[1 ]= mot_val[3 ]= 3826 mot_val[1+stride]= mot_val[3+stride]= 0; 3827 3828 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0; 3829 goto end; 3830 } 3831 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2); 3832 }while(cbpc == 20); 3833 3834 if(cbpc & 4){ 3835 s->current_picture.mb_type[xy]= MB_TYPE_INTRA; 3836 }else{ 3837 get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); 3838 if (cbpc & 8) { 3839 if(s->modified_quant){ 3840 if(get_bits1(&s->gb)) skip_bits(&s->gb, 1); 3841 else skip_bits(&s->gb, 5); 3842 }else 3843 skip_bits(&s->gb, 2); 3844 } 3845 3846 if ((cbpc & 16) == 0) { 3847 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0; 3848 /* 16x16 motion prediction */ 3849 mot_val= h263_pred_motion(s, 0, 0, &pred_x, &pred_y); 3850 if (s->umvplus) 3851 mx = h263p_decode_umotion(s, pred_x); 3852 else 3853 mx = h263_decode_motion(s, pred_x, 1); 3854 3855 if (s->umvplus) 3856 my = h263p_decode_umotion(s, pred_y); 3857 else 3858 my = h263_decode_motion(s, pred_y, 1); 3859 3860 mot_val[0 ]= mot_val[2 ]= 3861 mot_val[0+stride]= mot_val[2+stride]= mx; 3862 mot_val[1 ]= mot_val[3 ]= 3863 mot_val[1+stride]= mot_val[3+stride]= my; 3864 } else { 3865 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0; 3866 for(i=0;i<4;i++) { 3867 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y); 3868 if (s->umvplus) 3869 mx = h263p_decode_umotion(s, pred_x); 3870 else 3871 mx = h263_decode_motion(s, pred_x, 1); 3872 3873 if (s->umvplus) 3874 my = h263p_decode_umotion(s, pred_y); 3875 else 3876 my = h263_decode_motion(s, pred_y, 1); 3877 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1) 3878 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */ 3879 mot_val[0] = mx; 3880 mot_val[1] = my; 3881 } 3882 } 3883 } 3884end: 3885 3886 for(i=0; i<4; i++) 3887 s->block_index[i]-= 2; 3888 for(i=4; i<6; i++) 3889 s->block_index[i]-= 1; 3890 s->mb_x--; 3891 3892 s->gb= gb; 3893} 3894 3895static void h263_decode_dquant(MpegEncContext *s){ 3896 static const int8_t quant_tab[4] = { -1, -2, 1, 2 }; 3897 3898 if(s->modified_quant){ 3899 if(get_bits1(&s->gb)) 3900 s->qscale= modified_quant_tab[get_bits1(&s->gb)][ s->qscale ]; 3901 else 3902 s->qscale= get_bits(&s->gb, 5); 3903 }else 3904 s->qscale += quant_tab[get_bits(&s->gb, 2)]; 3905 ff_set_qscale(s, s->qscale); 3906} 3907 3908int ff_h263_decode_mb(MpegEncContext *s, 3909 DCTELEM block[6][64]) 3910{ 3911 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant; 3912 int16_t *mot_val; 3913 const int xy= s->mb_x + s->mb_y * s->mb_stride; 3914 3915 assert(!s->h263_pred); 3916 3917 if (s->pict_type == FF_P_TYPE) { 3918 do{ 3919 if (get_bits1(&s->gb)) { 3920 /* skip mb */ 3921 s->mb_intra = 0; 3922 for(i=0;i<6;i++) 3923 s->block_last_index[i] = -1; 3924 s->mv_dir = MV_DIR_FORWARD; 3925 s->mv_type = MV_TYPE_16X16; 3926 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0; 3927 s->mv[0][0][0] = 0; 3928 s->mv[0][0][1] = 0; 3929 s->mb_skipped = !(s->obmc | s->loop_filter); 3930 goto end; 3931 } 3932 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2); 3933 //fprintf(stderr, "\tCBPC: %d", cbpc); 3934 if (cbpc < 0){ 3935 av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y); 3936 return -1; 3937 } 3938 }while(cbpc == 20); 3939 3940 s->dsp.clear_blocks(s->block[0]); 3941 3942 dquant = cbpc & 8; 3943 s->mb_intra = ((cbpc & 4) != 0); 3944 if (s->mb_intra) goto intra; 3945 3946 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); 3947 3948 if(s->alt_inter_vlc==0 || (cbpc & 3)!=3) 3949 cbpy ^= 0xF; 3950 3951 cbp = (cbpc & 3) | (cbpy << 2); 3952 if (dquant) { 3953 h263_decode_dquant(s); 3954 } 3955 3956 s->mv_dir = MV_DIR_FORWARD; 3957 if ((cbpc & 16) == 0) { 3958 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0; 3959 /* 16x16 motion prediction */ 3960 s->mv_type = MV_TYPE_16X16; 3961 h263_pred_motion(s, 0, 0, &pred_x, &pred_y); 3962 if (s->umvplus) 3963 mx = h263p_decode_umotion(s, pred_x); 3964 else 3965 mx = h263_decode_motion(s, pred_x, 1); 3966 3967 if (mx >= 0xffff) 3968 return -1; 3969 3970 if (s->umvplus) 3971 my = h263p_decode_umotion(s, pred_y); 3972 else 3973 my = h263_decode_motion(s, pred_y, 1); 3974 3975 if (my >= 0xffff) 3976 return -1; 3977 s->mv[0][0][0] = mx; 3978 s->mv[0][0][1] = my; 3979 3980 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1) 3981 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */ 3982 } else { 3983 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0; 3984 s->mv_type = MV_TYPE_8X8; 3985 for(i=0;i<4;i++) { 3986 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y); 3987 if (s->umvplus) 3988 mx = h263p_decode_umotion(s, pred_x); 3989 else 3990 mx = h263_decode_motion(s, pred_x, 1); 3991 if (mx >= 0xffff) 3992 return -1; 3993 3994 if (s->umvplus) 3995 my = h263p_decode_umotion(s, pred_y); 3996 else 3997 my = h263_decode_motion(s, pred_y, 1); 3998 if (my >= 0xffff) 3999 return -1; 4000 s->mv[0][i][0] = mx; 4001 s->mv[0][i][1] = my; 4002 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1) 4003 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */ 4004 mot_val[0] = mx; 4005 mot_val[1] = my; 4006 } 4007 } 4008 4009 /* decode each block */ 4010 for (i = 0; i < 6; i++) { 4011 if (h263_decode_block(s, block[i], i, cbp&32) < 0) 4012 return -1; 4013 cbp+=cbp; 4014 } 4015 4016 if(s->obmc){ 4017 if(s->pict_type == FF_P_TYPE && s->mb_x+1<s->mb_width && s->mb_num_left != 1) 4018 preview_obmc(s); 4019 } 4020 } else if(s->pict_type==FF_B_TYPE) { 4021 int mb_type; 4022 const int stride= s->b8_stride; 4023 int16_t *mot_val0 = s->current_picture.motion_val[0][ 2*(s->mb_x + s->mb_y*stride) ]; 4024 int16_t *mot_val1 = s->current_picture.motion_val[1][ 2*(s->mb_x + s->mb_y*stride) ]; 4025// const int mv_xy= s->mb_x + 1 + s->mb_y * s->mb_stride; 4026 4027 //FIXME ugly 4028 mot_val0[0 ]= mot_val0[2 ]= mot_val0[0+2*stride]= mot_val0[2+2*stride]= 4029 mot_val0[1 ]= mot_val0[3 ]= mot_val0[1+2*stride]= mot_val0[3+2*stride]= 4030 mot_val1[0 ]= mot_val1[2 ]= mot_val1[0+2*stride]= mot_val1[2+2*stride]= 4031 mot_val1[1 ]= mot_val1[3 ]= mot_val1[1+2*stride]= mot_val1[3+2*stride]= 0; 4032 4033 do{ 4034 mb_type= get_vlc2(&s->gb, h263_mbtype_b_vlc.table, H263_MBTYPE_B_VLC_BITS, 2); 4035 if (mb_type < 0){ 4036 av_log(s->avctx, AV_LOG_ERROR, "b mb_type damaged at %d %d\n", s->mb_x, s->mb_y); 4037 return -1; 4038 } 4039 4040 mb_type= h263_mb_type_b_map[ mb_type ]; 4041 }while(!mb_type); 4042 4043 s->mb_intra = IS_INTRA(mb_type); 4044 if(HAS_CBP(mb_type)){ 4045 s->dsp.clear_blocks(s->block[0]); 4046 cbpc = get_vlc2(&s->gb, cbpc_b_vlc.table, CBPC_B_VLC_BITS, 1); 4047 if(s->mb_intra){ 4048 dquant = IS_QUANT(mb_type); 4049 goto intra; 4050 } 4051 4052 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); 4053 4054 if (cbpy < 0){ 4055 av_log(s->avctx, AV_LOG_ERROR, "b cbpy damaged at %d %d\n", s->mb_x, s->mb_y); 4056 return -1; 4057 } 4058 4059 if(s->alt_inter_vlc==0 || (cbpc & 3)!=3) 4060 cbpy ^= 0xF; 4061 4062 cbp = (cbpc & 3) | (cbpy << 2); 4063 }else 4064 cbp=0; 4065 4066 assert(!s->mb_intra); 4067 4068 if(IS_QUANT(mb_type)){ 4069 h263_decode_dquant(s); 4070 } 4071 4072 if(IS_DIRECT(mb_type)){ 4073 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT; 4074 mb_type |= ff_mpeg4_set_direct_mv(s, 0, 0); 4075 }else{ 4076 s->mv_dir = 0; 4077 s->mv_type= MV_TYPE_16X16; 4078//FIXME UMV 4079 4080 if(USES_LIST(mb_type, 0)){ 4081 int16_t *mot_val= h263_pred_motion(s, 0, 0, &mx, &my); 4082 s->mv_dir = MV_DIR_FORWARD; 4083 4084 mx = h263_decode_motion(s, mx, 1); 4085 my = h263_decode_motion(s, my, 1); 4086 4087 s->mv[0][0][0] = mx; 4088 s->mv[0][0][1] = my; 4089 mot_val[0 ]= mot_val[2 ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx; 4090 mot_val[1 ]= mot_val[3 ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my; 4091 } 4092 4093 if(USES_LIST(mb_type, 1)){ 4094 int16_t *mot_val= h263_pred_motion(s, 0, 1, &mx, &my); 4095 s->mv_dir |= MV_DIR_BACKWARD; 4096 4097 mx = h263_decode_motion(s, mx, 1); 4098 my = h263_decode_motion(s, my, 1); 4099 4100 s->mv[1][0][0] = mx; 4101 s->mv[1][0][1] = my; 4102 mot_val[0 ]= mot_val[2 ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx; 4103 mot_val[1 ]= mot_val[3 ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my; 4104 } 4105 } 4106 4107 s->current_picture.mb_type[xy]= mb_type; 4108 4109 /* decode each block */ 4110 for (i = 0; i < 6; i++) { 4111 if (h263_decode_block(s, block[i], i, cbp&32) < 0) 4112 return -1; 4113 cbp+=cbp; 4114 } 4115 } else { /* I-Frame */ 4116 do{ 4117 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2); 4118 if (cbpc < 0){ 4119 av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y); 4120 return -1; 4121 } 4122 }while(cbpc == 8); 4123 4124 s->dsp.clear_blocks(s->block[0]); 4125 4126 dquant = cbpc & 4; 4127 s->mb_intra = 1; 4128intra: 4129 s->current_picture.mb_type[xy]= MB_TYPE_INTRA; 4130 if (s->h263_aic) { 4131 s->ac_pred = get_bits1(&s->gb); 4132 if(s->ac_pred){ 4133 s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED; 4134 4135 s->h263_aic_dir = get_bits1(&s->gb); 4136 } 4137 }else 4138 s->ac_pred = 0; 4139 4140 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); 4141 if(cbpy<0){ 4142 av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y); 4143 return -1; 4144 } 4145 cbp = (cbpc & 3) | (cbpy << 2); 4146 if (dquant) { 4147 h263_decode_dquant(s); 4148 } 4149 4150 /* decode each block */ 4151 for (i = 0; i < 6; i++) { 4152 if (h263_decode_block(s, block[i], i, cbp&32) < 0) 4153 return -1; 4154 cbp+=cbp; 4155 } 4156 } 4157end: 4158 4159 /* per-MB end of slice check */ 4160 { 4161 int v= show_bits(&s->gb, 16); 4162 4163 if(get_bits_count(&s->gb) + 16 > s->gb.size_in_bits){ 4164 v>>= get_bits_count(&s->gb) + 16 - s->gb.size_in_bits; 4165 } 4166 4167 if(v==0) 4168 return SLICE_END; 4169 } 4170 4171 return SLICE_OK; 4172} 4173 4174int ff_mpeg4_decode_mb(MpegEncContext *s, 4175 DCTELEM block[6][64]) 4176{ 4177 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant; 4178 int16_t *mot_val; 4179 static int8_t quant_tab[4] = { -1, -2, 1, 2 }; 4180 const int xy= s->mb_x + s->mb_y * s->mb_stride; 4181 4182 assert(s->h263_pred); 4183 4184 if (s->pict_type == FF_P_TYPE || s->pict_type==FF_S_TYPE) { 4185 do{ 4186 if (get_bits1(&s->gb)) { 4187 /* skip mb */ 4188 s->mb_intra = 0; 4189 for(i=0;i<6;i++) 4190 s->block_last_index[i] = -1; 4191 s->mv_dir = MV_DIR_FORWARD; 4192 s->mv_type = MV_TYPE_16X16; 4193 if(s->pict_type==FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE){ 4194 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0; 4195 s->mcsel=1; 4196 s->mv[0][0][0]= get_amv(s, 0); 4197 s->mv[0][0][1]= get_amv(s, 1); 4198 4199 s->mb_skipped = 0; 4200 }else{ 4201 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0; 4202 s->mcsel=0; 4203 s->mv[0][0][0] = 0; 4204 s->mv[0][0][1] = 0; 4205 s->mb_skipped = 1; 4206 } 4207 goto end; 4208 } 4209 cbpc = get_vlc2(&s->gb, inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2); 4210 //fprintf(stderr, "\tCBPC: %d", cbpc); 4211 if (cbpc < 0){ 4212 av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y); 4213 return -1; 4214 } 4215 }while(cbpc == 20); 4216 4217 s->dsp.clear_blocks(s->block[0]); 4218 dquant = cbpc & 8; 4219 s->mb_intra = ((cbpc & 4) != 0); 4220 if (s->mb_intra) goto intra; 4221 4222 if(s->pict_type==FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0) 4223 s->mcsel= get_bits1(&s->gb); 4224 else s->mcsel= 0; 4225 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1) ^ 0x0F; 4226 4227 cbp = (cbpc & 3) | (cbpy << 2); 4228 if (dquant) { 4229 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]); 4230 } 4231 if((!s->progressive_sequence) && (cbp || (s->workaround_bugs&FF_BUG_XVID_ILACE))) 4232 s->interlaced_dct= get_bits1(&s->gb); 4233 4234 s->mv_dir = MV_DIR_FORWARD; 4235 if ((cbpc & 16) == 0) { 4236 if(s->mcsel){ 4237 s->current_picture.mb_type[xy]= MB_TYPE_GMC | MB_TYPE_16x16 | MB_TYPE_L0; 4238 /* 16x16 global motion prediction */ 4239 s->mv_type = MV_TYPE_16X16; 4240 mx= get_amv(s, 0); 4241 my= get_amv(s, 1); 4242 s->mv[0][0][0] = mx; 4243 s->mv[0][0][1] = my; 4244 }else if((!s->progressive_sequence) && get_bits1(&s->gb)){ 4245 s->current_picture.mb_type[xy]= MB_TYPE_16x8 | MB_TYPE_L0 | MB_TYPE_INTERLACED; 4246 /* 16x8 field motion prediction */ 4247 s->mv_type= MV_TYPE_FIELD; 4248 4249 s->field_select[0][0]= get_bits1(&s->gb); 4250 s->field_select[0][1]= get_bits1(&s->gb); 4251 4252 h263_pred_motion(s, 0, 0, &pred_x, &pred_y); 4253 4254 for(i=0; i<2; i++){ 4255 mx = h263_decode_motion(s, pred_x, s->f_code); 4256 if (mx >= 0xffff) 4257 return -1; 4258 4259 my = h263_decode_motion(s, pred_y/2, s->f_code); 4260 if (my >= 0xffff) 4261 return -1; 4262 4263 s->mv[0][i][0] = mx; 4264 s->mv[0][i][1] = my; 4265 } 4266 }else{ 4267 s->current_picture.mb_type[xy]= MB_TYPE_16x16 | MB_TYPE_L0; 4268 /* 16x16 motion prediction */ 4269 s->mv_type = MV_TYPE_16X16; 4270 h263_pred_motion(s, 0, 0, &pred_x, &pred_y); 4271 mx = h263_decode_motion(s, pred_x, s->f_code); 4272 4273 if (mx >= 0xffff) 4274 return -1; 4275 4276 my = h263_decode_motion(s, pred_y, s->f_code); 4277 4278 if (my >= 0xffff) 4279 return -1; 4280 s->mv[0][0][0] = mx; 4281 s->mv[0][0][1] = my; 4282 } 4283 } else { 4284 s->current_picture.mb_type[xy]= MB_TYPE_8x8 | MB_TYPE_L0; 4285 s->mv_type = MV_TYPE_8X8; 4286 for(i=0;i<4;i++) { 4287 mot_val = h263_pred_motion(s, i, 0, &pred_x, &pred_y); 4288 mx = h263_decode_motion(s, pred_x, s->f_code); 4289 if (mx >= 0xffff) 4290 return -1; 4291 4292 my = h263_decode_motion(s, pred_y, s->f_code); 4293 if (my >= 0xffff) 4294 return -1; 4295 s->mv[0][i][0] = mx; 4296 s->mv[0][i][1] = my; 4297 mot_val[0] = mx; 4298 mot_val[1] = my; 4299 } 4300 } 4301 } else if(s->pict_type==FF_B_TYPE) { 4302 int modb1; // first bit of modb 4303 int modb2; // second bit of modb 4304 int mb_type; 4305 4306 s->mb_intra = 0; //B-frames never contain intra blocks 4307 s->mcsel=0; // ... true gmc blocks 4308 4309 if(s->mb_x==0){ 4310 for(i=0; i<2; i++){ 4311 s->last_mv[i][0][0]= 4312 s->last_mv[i][0][1]= 4313 s->last_mv[i][1][0]= 4314 s->last_mv[i][1][1]= 0; 4315 } 4316 } 4317 4318 /* if we skipped it in the future P Frame than skip it now too */ 4319 s->mb_skipped= s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]; // Note, skiptab=0 if last was GMC 4320 4321 if(s->mb_skipped){ 4322 /* skip mb */ 4323 for(i=0;i<6;i++) 4324 s->block_last_index[i] = -1; 4325 4326 s->mv_dir = MV_DIR_FORWARD; 4327 s->mv_type = MV_TYPE_16X16; 4328 s->mv[0][0][0] = 0; 4329 s->mv[0][0][1] = 0; 4330 s->mv[1][0][0] = 0; 4331 s->mv[1][0][1] = 0; 4332 s->current_picture.mb_type[xy]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0; 4333 goto end; 4334 } 4335 4336 modb1= get_bits1(&s->gb); 4337 if(modb1){ 4338 mb_type= MB_TYPE_DIRECT2 | MB_TYPE_SKIP | MB_TYPE_L0L1; //like MB_TYPE_B_DIRECT but no vectors coded 4339 cbp=0; 4340 }else{ 4341 modb2= get_bits1(&s->gb); 4342 mb_type= get_vlc2(&s->gb, mb_type_b_vlc.table, MB_TYPE_B_VLC_BITS, 1); 4343 if(mb_type<0){ 4344 av_log(s->avctx, AV_LOG_ERROR, "illegal MB_type\n"); 4345 return -1; 4346 } 4347 mb_type= mb_type_b_map[ mb_type ]; 4348 if(modb2) cbp= 0; 4349 else{ 4350 s->dsp.clear_blocks(s->block[0]); 4351 cbp= get_bits(&s->gb, 6); 4352 } 4353 4354 if ((!IS_DIRECT(mb_type)) && cbp) { 4355 if(get_bits1(&s->gb)){ 4356 ff_set_qscale(s, s->qscale + get_bits1(&s->gb)*4 - 2); 4357 } 4358 } 4359 4360 if(!s->progressive_sequence){ 4361 if(cbp) 4362 s->interlaced_dct= get_bits1(&s->gb); 4363 4364 if(!IS_DIRECT(mb_type) && get_bits1(&s->gb)){ 4365 mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED; 4366 mb_type &= ~MB_TYPE_16x16; 4367 4368 if(USES_LIST(mb_type, 0)){ 4369 s->field_select[0][0]= get_bits1(&s->gb); 4370 s->field_select[0][1]= get_bits1(&s->gb); 4371 } 4372 if(USES_LIST(mb_type, 1)){ 4373 s->field_select[1][0]= get_bits1(&s->gb); 4374 s->field_select[1][1]= get_bits1(&s->gb); 4375 } 4376 } 4377 } 4378 4379 s->mv_dir = 0; 4380 if((mb_type & (MB_TYPE_DIRECT2|MB_TYPE_INTERLACED)) == 0){ 4381 s->mv_type= MV_TYPE_16X16; 4382 4383 if(USES_LIST(mb_type, 0)){ 4384 s->mv_dir = MV_DIR_FORWARD; 4385 4386 mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code); 4387 my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code); 4388 s->last_mv[0][1][0]= s->last_mv[0][0][0]= s->mv[0][0][0] = mx; 4389 s->last_mv[0][1][1]= s->last_mv[0][0][1]= s->mv[0][0][1] = my; 4390 } 4391 4392 if(USES_LIST(mb_type, 1)){ 4393 s->mv_dir |= MV_DIR_BACKWARD; 4394 4395 mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code); 4396 my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code); 4397 s->last_mv[1][1][0]= s->last_mv[1][0][0]= s->mv[1][0][0] = mx; 4398 s->last_mv[1][1][1]= s->last_mv[1][0][1]= s->mv[1][0][1] = my; 4399 } 4400 }else if(!IS_DIRECT(mb_type)){ 4401 s->mv_type= MV_TYPE_FIELD; 4402 4403 if(USES_LIST(mb_type, 0)){ 4404 s->mv_dir = MV_DIR_FORWARD; 4405 4406 for(i=0; i<2; i++){ 4407 mx = h263_decode_motion(s, s->last_mv[0][i][0] , s->f_code); 4408 my = h263_decode_motion(s, s->last_mv[0][i][1]/2, s->f_code); 4409 s->last_mv[0][i][0]= s->mv[0][i][0] = mx; 4410 s->last_mv[0][i][1]= (s->mv[0][i][1] = my)*2; 4411 } 4412 } 4413 4414 if(USES_LIST(mb_type, 1)){ 4415 s->mv_dir |= MV_DIR_BACKWARD; 4416 4417 for(i=0; i<2; i++){ 4418 mx = h263_decode_motion(s, s->last_mv[1][i][0] , s->b_code); 4419 my = h263_decode_motion(s, s->last_mv[1][i][1]/2, s->b_code); 4420 s->last_mv[1][i][0]= s->mv[1][i][0] = mx; 4421 s->last_mv[1][i][1]= (s->mv[1][i][1] = my)*2; 4422 } 4423 } 4424 } 4425 } 4426 4427 if(IS_DIRECT(mb_type)){ 4428 if(IS_SKIP(mb_type)) 4429 mx=my=0; 4430 else{ 4431 mx = h263_decode_motion(s, 0, 1); 4432 my = h263_decode_motion(s, 0, 1); 4433 } 4434 4435 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT; 4436 mb_type |= ff_mpeg4_set_direct_mv(s, mx, my); 4437 } 4438 s->current_picture.mb_type[xy]= mb_type; 4439 } else { /* I-Frame */ 4440 do{ 4441 cbpc = get_vlc2(&s->gb, intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2); 4442 if (cbpc < 0){ 4443 av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y); 4444 return -1; 4445 } 4446 }while(cbpc == 8); 4447 4448 dquant = cbpc & 4; 4449 s->mb_intra = 1; 4450intra: 4451 s->ac_pred = get_bits1(&s->gb); 4452 if(s->ac_pred) 4453 s->current_picture.mb_type[xy]= MB_TYPE_INTRA | MB_TYPE_ACPRED; 4454 else 4455 s->current_picture.mb_type[xy]= MB_TYPE_INTRA; 4456 4457 cbpy = get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1); 4458 if(cbpy<0){ 4459 av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y); 4460 return -1; 4461 } 4462 cbp = (cbpc & 3) | (cbpy << 2); 4463 4464 s->use_intra_dc_vlc= s->qscale < s->intra_dc_threshold; 4465 4466 if (dquant) { 4467 ff_set_qscale(s, s->qscale + quant_tab[get_bits(&s->gb, 2)]); 4468 } 4469 4470 if(!s->progressive_sequence) 4471 s->interlaced_dct= get_bits1(&s->gb); 4472 4473 s->dsp.clear_blocks(s->block[0]); 4474 /* decode each block */ 4475 for (i = 0; i < 6; i++) { 4476 if (mpeg4_decode_block(s, block[i], i, cbp&32, 1, 0) < 0) 4477 return -1; 4478 cbp+=cbp; 4479 } 4480 goto end; 4481 } 4482 4483 /* decode each block */ 4484 for (i = 0; i < 6; i++) { 4485 if (mpeg4_decode_block(s, block[i], i, cbp&32, 0, 0) < 0) 4486 return -1; 4487 cbp+=cbp; 4488 } 4489end: 4490 4491 /* per-MB end of slice check */ 4492 if(s->codec_id==CODEC_ID_MPEG4){ 4493 if(mpeg4_is_resync(s)){ 4494 const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1; 4495 if(s->pict_type==FF_B_TYPE && s->next_picture.mbskip_table[xy + delta]) 4496 return SLICE_OK; 4497 return SLICE_END; 4498 } 4499 } 4500 4501 return SLICE_OK; 4502} 4503 4504static int h263_decode_motion(MpegEncContext * s, int pred, int f_code) 4505{ 4506 int code, val, sign, shift, l; 4507 code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2); 4508 4509 if (code == 0) 4510 return pred; 4511 if (code < 0) 4512 return 0xffff; 4513 4514 sign = get_bits1(&s->gb); 4515 shift = f_code - 1; 4516 val = code; 4517 if (shift) { 4518 val = (val - 1) << shift; 4519 val |= get_bits(&s->gb, shift); 4520 val++; 4521 } 4522 if (sign) 4523 val = -val; 4524 val += pred; 4525 4526 /* modulo decoding */ 4527 if (!s->h263_long_vectors) { 4528 l = INT_BIT - 5 - f_code; 4529 val = (val<<l)>>l; 4530 } else { 4531 /* horrible h263 long vector mode */ 4532 if (pred < -31 && val < -63) 4533 val += 64; 4534 if (pred > 32 && val > 63) 4535 val -= 64; 4536 4537 } 4538 return val; 4539} 4540 4541/* Decodes RVLC of H.263+ UMV */ 4542static int h263p_decode_umotion(MpegEncContext * s, int pred) 4543{ 4544 int code = 0, sign; 4545 4546 if (get_bits1(&s->gb)) /* Motion difference = 0 */ 4547 return pred; 4548 4549 code = 2 + get_bits1(&s->gb); 4550 4551 while (get_bits1(&s->gb)) 4552 { 4553 code <<= 1; 4554 code += get_bits1(&s->gb); 4555 } 4556 sign = code & 1; 4557 code >>= 1; 4558 4559 code = (sign) ? (pred - code) : (pred + code); 4560#ifdef DEBUG 4561 av_log( s->avctx, AV_LOG_DEBUG,"H.263+ UMV Motion = %d\n", code); 4562#endif 4563 return code; 4564 4565} 4566 4567static int h263_decode_block(MpegEncContext * s, DCTELEM * block, 4568 int n, int coded) 4569{ 4570 int code, level, i, j, last, run; 4571 RLTable *rl = &rl_inter; 4572 const uint8_t *scan_table; 4573 GetBitContext gb= s->gb; 4574 4575 scan_table = s->intra_scantable.permutated; 4576 if (s->h263_aic && s->mb_intra) { 4577 rl = &rl_intra_aic; 4578 i = 0; 4579 if (s->ac_pred) { 4580 if (s->h263_aic_dir) 4581 scan_table = s->intra_v_scantable.permutated; /* left */ 4582 else 4583 scan_table = s->intra_h_scantable.permutated; /* top */ 4584 } 4585 } else if (s->mb_intra) { 4586 /* DC coef */ 4587 if(s->codec_id == CODEC_ID_RV10){ 4588#if CONFIG_RV10_DECODER 4589 if (s->rv10_version == 3 && s->pict_type == FF_I_TYPE) { 4590 int component, diff; 4591 component = (n <= 3 ? 0 : n - 4 + 1); 4592 level = s->last_dc[component]; 4593 if (s->rv10_first_dc_coded[component]) { 4594 diff = rv_decode_dc(s, n); 4595 if (diff == 0xffff) 4596 return -1; 4597 level += diff; 4598 level = level & 0xff; /* handle wrap round */ 4599 s->last_dc[component] = level; 4600 } else { 4601 s->rv10_first_dc_coded[component] = 1; 4602 } 4603 } else { 4604 level = get_bits(&s->gb, 8); 4605 if (level == 255) 4606 level = 128; 4607 } 4608#endif 4609 }else{ 4610 level = get_bits(&s->gb, 8); 4611 if((level&0x7F) == 0){ 4612 av_log(s->avctx, AV_LOG_ERROR, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y); 4613 if(s->error_recognition >= FF_ER_COMPLIANT) 4614 return -1; 4615 } 4616 if (level == 255) 4617 level = 128; 4618 } 4619 block[0] = level; 4620 i = 1; 4621 } else { 4622 i = 0; 4623 } 4624 if (!coded) { 4625 if (s->mb_intra && s->h263_aic) 4626 goto not_coded; 4627 s->block_last_index[n] = i - 1; 4628 return 0; 4629 } 4630retry: 4631 for(;;) { 4632 code = get_vlc2(&s->gb, rl->vlc.table, TEX_VLC_BITS, 2); 4633 if (code < 0){ 4634 av_log(s->avctx, AV_LOG_ERROR, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y); 4635 return -1; 4636 } 4637 if (code == rl->n) { 4638 /* escape */ 4639 if (s->h263_flv > 1) { 4640 int is11 = get_bits1(&s->gb); 4641 last = get_bits1(&s->gb); 4642 run = get_bits(&s->gb, 6); 4643 if(is11){ 4644 level = get_sbits(&s->gb, 11); 4645 } else { 4646 level = get_sbits(&s->gb, 7); 4647 } 4648 } else { 4649 last = get_bits1(&s->gb); 4650 run = get_bits(&s->gb, 6); 4651 level = (int8_t)get_bits(&s->gb, 8); 4652 if(level == -128){ 4653 if (s->codec_id == CODEC_ID_RV10) { 4654 /* XXX: should patch encoder too */ 4655 level = get_sbits(&s->gb, 12); 4656 }else{ 4657 level = get_bits(&s->gb, 5); 4658 level |= get_sbits(&s->gb, 6)<<5; 4659 } 4660 } 4661 } 4662 } else { 4663 run = rl->table_run[code]; 4664 level = rl->table_level[code]; 4665 last = code >= rl->last; 4666 if (get_bits1(&s->gb)) 4667 level = -level; 4668 } 4669 i += run; 4670 if (i >= 64){ 4671 if(s->alt_inter_vlc && rl == &rl_inter && !s->mb_intra){ 4672 //Looks like a hack but no, it's the way it is supposed to work ... 4673 rl = &rl_intra_aic; 4674 i = 0; 4675 s->gb= gb; 4676 s->dsp.clear_block(block); 4677 goto retry; 4678 } 4679 av_log(s->avctx, AV_LOG_ERROR, "run overflow at %dx%d i:%d\n", s->mb_x, s->mb_y, s->mb_intra); 4680 return -1; 4681 } 4682 j = scan_table[i]; 4683 block[j] = level; 4684 if (last) 4685 break; 4686 i++; 4687 } 4688not_coded: 4689 if (s->mb_intra && s->h263_aic) { 4690 h263_pred_acdc(s, block, n); 4691 i = 63; 4692 } 4693 s->block_last_index[n] = i; 4694 return 0; 4695} 4696 4697/** 4698 * decodes the dc value. 4699 * @param n block index (0-3 are luma, 4-5 are chroma) 4700 * @param dir_ptr the prediction direction will be stored here 4701 * @return the quantized dc 4702 */ 4703static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr) 4704{ 4705 int level, code; 4706 4707 if (n < 4) 4708 code = get_vlc2(&s->gb, dc_lum.table, DC_VLC_BITS, 1); 4709 else 4710 code = get_vlc2(&s->gb, dc_chrom.table, DC_VLC_BITS, 1); 4711 if (code < 0 || code > 9 /* && s->nbit<9 */){ 4712 av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n"); 4713 return -1; 4714 } 4715 if (code == 0) { 4716 level = 0; 4717 } else { 4718 if(IS_3IV1){ 4719 if(code==1) 4720 level= 2*get_bits1(&s->gb)-1; 4721 else{ 4722 if(get_bits1(&s->gb)) 4723 level = get_bits(&s->gb, code-1) + (1<<(code-1)); 4724 else 4725 level = -get_bits(&s->gb, code-1) - (1<<(code-1)); 4726 } 4727 }else{ 4728 level = get_xbits(&s->gb, code); 4729 } 4730 4731 if (code > 8){ 4732 if(get_bits1(&s->gb)==0){ /* marker */ 4733 if(s->error_recognition>=2){ 4734 av_log(s->avctx, AV_LOG_ERROR, "dc marker bit missing\n"); 4735 return -1; 4736 } 4737 } 4738 } 4739 } 4740 4741 return ff_mpeg4_pred_dc(s, n, level, dir_ptr, 0); 4742} 4743 4744/** 4745 * decodes a block. 4746 * @return <0 if an error occurred 4747 */ 4748static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block, 4749 int n, int coded, int intra, int rvlc) 4750{ 4751 int level, i, last, run; 4752 int dc_pred_dir; 4753 RLTable * rl; 4754 RL_VLC_ELEM * rl_vlc; 4755 const uint8_t * scan_table; 4756 int qmul, qadd; 4757 4758 //Note intra & rvlc should be optimized away if this is inlined 4759 4760 if(intra) { 4761 if(s->use_intra_dc_vlc){ 4762 /* DC coef */ 4763 if(s->partitioned_frame){ 4764 level = s->dc_val[0][ s->block_index[n] ]; 4765 if(n<4) level= FASTDIV((level + (s->y_dc_scale>>1)), s->y_dc_scale); 4766 else level= FASTDIV((level + (s->c_dc_scale>>1)), s->c_dc_scale); 4767 dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_stride]<<n)&32; 4768 }else{ 4769 level = mpeg4_decode_dc(s, n, &dc_pred_dir); 4770 if (level < 0) 4771 return -1; 4772 } 4773 block[0] = level; 4774 i = 0; 4775 }else{ 4776 i = -1; 4777 ff_mpeg4_pred_dc(s, n, 0, &dc_pred_dir, 0); 4778 } 4779 if (!coded) 4780 goto not_coded; 4781 4782 if(rvlc){ 4783 rl = &rvlc_rl_intra; 4784 rl_vlc = rvlc_rl_intra.rl_vlc[0]; 4785 }else{ 4786 rl = &rl_intra; 4787 rl_vlc = rl_intra.rl_vlc[0]; 4788 } 4789 if (s->ac_pred) { 4790 if (dc_pred_dir == 0) 4791 scan_table = s->intra_v_scantable.permutated; /* left */ 4792 else 4793 scan_table = s->intra_h_scantable.permutated; /* top */ 4794 } else { 4795 scan_table = s->intra_scantable.permutated; 4796 } 4797 qmul=1; 4798 qadd=0; 4799 } else { 4800 i = -1; 4801 if (!coded) { 4802 s->block_last_index[n] = i; 4803 return 0; 4804 } 4805 if(rvlc) rl = &rvlc_rl_inter; 4806 else rl = &rl_inter; 4807 4808 scan_table = s->intra_scantable.permutated; 4809 4810 if(s->mpeg_quant){ 4811 qmul=1; 4812 qadd=0; 4813 if(rvlc){ 4814 rl_vlc = rvlc_rl_inter.rl_vlc[0]; 4815 }else{ 4816 rl_vlc = rl_inter.rl_vlc[0]; 4817 } 4818 }else{ 4819 qmul = s->qscale << 1; 4820 qadd = (s->qscale - 1) | 1; 4821 if(rvlc){ 4822 rl_vlc = rvlc_rl_inter.rl_vlc[s->qscale]; 4823 }else{ 4824 rl_vlc = rl_inter.rl_vlc[s->qscale]; 4825 } 4826 } 4827 } 4828 { 4829 OPEN_READER(re, &s->gb); 4830 for(;;) { 4831 UPDATE_CACHE(re, &s->gb); 4832 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0); 4833 if (level==0) { 4834 /* escape */ 4835 if(rvlc){ 4836 if(SHOW_UBITS(re, &s->gb, 1)==0){ 4837 av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in rvlc esc\n"); 4838 return -1; 4839 }; SKIP_CACHE(re, &s->gb, 1); 4840 4841 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1); 4842 run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6); 4843 SKIP_COUNTER(re, &s->gb, 1+1+6); 4844 UPDATE_CACHE(re, &s->gb); 4845 4846 if(SHOW_UBITS(re, &s->gb, 1)==0){ 4847 av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in rvlc esc\n"); 4848 return -1; 4849 }; SKIP_CACHE(re, &s->gb, 1); 4850 4851 level= SHOW_UBITS(re, &s->gb, 11); SKIP_CACHE(re, &s->gb, 11); 4852 4853 if(SHOW_UBITS(re, &s->gb, 5)!=0x10){ 4854 av_log(s->avctx, AV_LOG_ERROR, "reverse esc missing\n"); 4855 return -1; 4856 }; SKIP_CACHE(re, &s->gb, 5); 4857 4858 level= level * qmul + qadd; 4859 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); LAST_SKIP_CACHE(re, &s->gb, 1); 4860 SKIP_COUNTER(re, &s->gb, 1+11+5+1); 4861 4862 i+= run + 1; 4863 if(last) i+=192; 4864 }else{ 4865 int cache; 4866 cache= GET_CACHE(re, &s->gb); 4867 4868 if(IS_3IV1) 4869 cache ^= 0xC0000000; 4870 4871 if (cache&0x80000000) { 4872 if (cache&0x40000000) { 4873 /* third escape */ 4874 SKIP_CACHE(re, &s->gb, 2); 4875 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1); 4876 run= SHOW_UBITS(re, &s->gb, 6); LAST_SKIP_CACHE(re, &s->gb, 6); 4877 SKIP_COUNTER(re, &s->gb, 2+1+6); 4878 UPDATE_CACHE(re, &s->gb); 4879 4880 if(IS_3IV1){ 4881 level= SHOW_SBITS(re, &s->gb, 12); LAST_SKIP_BITS(re, &s->gb, 12); 4882 }else{ 4883 if(SHOW_UBITS(re, &s->gb, 1)==0){ 4884 av_log(s->avctx, AV_LOG_ERROR, "1. marker bit missing in 3. esc\n"); 4885 return -1; 4886 }; SKIP_CACHE(re, &s->gb, 1); 4887 4888 level= SHOW_SBITS(re, &s->gb, 12); SKIP_CACHE(re, &s->gb, 12); 4889 4890 if(SHOW_UBITS(re, &s->gb, 1)==0){ 4891 av_log(s->avctx, AV_LOG_ERROR, "2. marker bit missing in 3. esc\n"); 4892 return -1; 4893 }; LAST_SKIP_CACHE(re, &s->gb, 1); 4894 4895 SKIP_COUNTER(re, &s->gb, 1+12+1); 4896 } 4897 4898#if 0 4899 if(s->error_recognition >= FF_ER_COMPLIANT){ 4900 const int abs_level= FFABS(level); 4901 if(abs_level<=MAX_LEVEL && run<=MAX_RUN){ 4902 const int run1= run - rl->max_run[last][abs_level] - 1; 4903 if(abs_level <= rl->max_level[last][run]){ 4904 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n"); 4905 return -1; 4906 } 4907 if(s->error_recognition > FF_ER_COMPLIANT){ 4908 if(abs_level <= rl->max_level[last][run]*2){ 4909 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\n"); 4910 return -1; 4911 } 4912 if(run1 >= 0 && abs_level <= rl->max_level[last][run1]){ 4913 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\n"); 4914 return -1; 4915 } 4916 } 4917 } 4918 } 4919#endif 4920 if (level>0) level= level * qmul + qadd; 4921 else level= level * qmul - qadd; 4922 4923 if((unsigned)(level + 2048) > 4095){ 4924 if(s->error_recognition > FF_ER_COMPLIANT){ 4925 if(level > 2560 || level<-2560){ 4926 av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc, qp=%d\n", s->qscale); 4927 return -1; 4928 } 4929 } 4930 level= level<0 ? -2048 : 2047; 4931 } 4932 4933 i+= run + 1; 4934 if(last) i+=192; 4935 } else { 4936 /* second escape */ 4937#if MIN_CACHE_BITS < 20 4938 LAST_SKIP_BITS(re, &s->gb, 2); 4939 UPDATE_CACHE(re, &s->gb); 4940#else 4941 SKIP_BITS(re, &s->gb, 2); 4942#endif 4943 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1); 4944 i+= run + rl->max_run[run>>7][level/qmul] +1; //FIXME opt indexing 4945 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); 4946 LAST_SKIP_BITS(re, &s->gb, 1); 4947 } 4948 } else { 4949 /* first escape */ 4950#if MIN_CACHE_BITS < 19 4951 LAST_SKIP_BITS(re, &s->gb, 1); 4952 UPDATE_CACHE(re, &s->gb); 4953#else 4954 SKIP_BITS(re, &s->gb, 1); 4955#endif 4956 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1); 4957 i+= run; 4958 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing 4959 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); 4960 LAST_SKIP_BITS(re, &s->gb, 1); 4961 } 4962 } 4963 } else { 4964 i+= run; 4965 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); 4966 LAST_SKIP_BITS(re, &s->gb, 1); 4967 } 4968 if (i > 62){ 4969 i-= 192; 4970 if(i&(~63)){ 4971 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y); 4972 return -1; 4973 } 4974 4975 block[scan_table[i]] = level; 4976 break; 4977 } 4978 4979 block[scan_table[i]] = level; 4980 } 4981 CLOSE_READER(re, &s->gb); 4982 } 4983 not_coded: 4984 if (intra) { 4985 if(!s->use_intra_dc_vlc){ 4986 block[0] = ff_mpeg4_pred_dc(s, n, block[0], &dc_pred_dir, 0); 4987 4988 i -= i>>31; //if(i == -1) i=0; 4989 } 4990 4991 mpeg4_pred_ac(s, block, n, dc_pred_dir); 4992 if (s->ac_pred) { 4993 i = 63; /* XXX: not optimal */ 4994 } 4995 } 4996 s->block_last_index[n] = i; 4997 return 0; 4998} 4999 5000/* most is hardcoded. should extend to handle all h263 streams */ 5001int h263_decode_picture_header(MpegEncContext *s) 5002{ 5003 int format, width, height, i; 5004 uint32_t startcode; 5005 5006 align_get_bits(&s->gb); 5007 5008 startcode= get_bits(&s->gb, 22-8); 5009 5010 for(i= s->gb.size_in_bits - get_bits_count(&s->gb); i>24; i-=8) { 5011 startcode = ((startcode << 8) | get_bits(&s->gb, 8)) & 0x003FFFFF; 5012 5013 if(startcode == 0x20) 5014 break; 5015 } 5016 5017 if (startcode != 0x20) { 5018 av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n"); 5019 return -1; 5020 } 5021 /* temporal reference */ 5022 i = get_bits(&s->gb, 8); /* picture timestamp */ 5023 if( (s->picture_number&~0xFF)+i < s->picture_number) 5024 i+= 256; 5025 s->current_picture_ptr->pts= 5026 s->picture_number= (s->picture_number&~0xFF) + i; 5027 5028 /* PTYPE starts here */ 5029 if (get_bits1(&s->gb) != 1) { 5030 /* marker */ 5031 av_log(s->avctx, AV_LOG_ERROR, "Bad marker\n"); 5032 return -1; 5033 } 5034 if (get_bits1(&s->gb) != 0) { 5035 av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n"); 5036 return -1; /* h263 id */ 5037 } 5038 skip_bits1(&s->gb); /* split screen off */ 5039 skip_bits1(&s->gb); /* camera off */ 5040 skip_bits1(&s->gb); /* freeze picture release off */ 5041 5042 format = get_bits(&s->gb, 3); 5043 /* 5044 0 forbidden 5045 1 sub-QCIF 5046 10 QCIF 5047 7 extended PTYPE (PLUSPTYPE) 5048 */ 5049 5050 if (format != 7 && format != 6) { 5051 s->h263_plus = 0; 5052 /* H.263v1 */ 5053 width = h263_format[format][0]; 5054 height = h263_format[format][1]; 5055 if (!width) 5056 return -1; 5057 5058 s->pict_type = FF_I_TYPE + get_bits1(&s->gb); 5059 5060 s->h263_long_vectors = get_bits1(&s->gb); 5061 5062 if (get_bits1(&s->gb) != 0) { 5063 av_log(s->avctx, AV_LOG_ERROR, "H263 SAC not supported\n"); 5064 return -1; /* SAC: off */ 5065 } 5066 s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */ 5067 s->unrestricted_mv = s->h263_long_vectors || s->obmc; 5068 5069 if (get_bits1(&s->gb) != 0) { 5070 av_log(s->avctx, AV_LOG_ERROR, "H263 PB frame not supported\n"); 5071 return -1; /* not PB frame */ 5072 } 5073 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5); 5074 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */ 5075 5076 s->width = width; 5077 s->height = height; 5078 s->avctx->sample_aspect_ratio= (AVRational){12,11}; 5079 s->avctx->time_base= (AVRational){1001, 30000}; 5080 } else { 5081 int ufep; 5082 5083 /* H.263v2 */ 5084 s->h263_plus = 1; 5085 ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */ 5086 5087 /* ufep other than 0 and 1 are reserved */ 5088 if (ufep == 1) { 5089 /* OPPTYPE */ 5090 format = get_bits(&s->gb, 3); 5091 dprintf(s->avctx, "ufep=1, format: %d\n", format); 5092 s->custom_pcf= get_bits1(&s->gb); 5093 s->umvplus = get_bits1(&s->gb); /* Unrestricted Motion Vector */ 5094 if (get_bits1(&s->gb) != 0) { 5095 av_log(s->avctx, AV_LOG_ERROR, "Syntax-based Arithmetic Coding (SAC) not supported\n"); 5096 } 5097 s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */ 5098 s->h263_aic = get_bits1(&s->gb); /* Advanced Intra Coding (AIC) */ 5099 s->loop_filter= get_bits1(&s->gb); 5100 s->unrestricted_mv = s->umvplus || s->obmc || s->loop_filter; 5101 5102 s->h263_slice_structured= get_bits1(&s->gb); 5103 if (get_bits1(&s->gb) != 0) { 5104 av_log(s->avctx, AV_LOG_ERROR, "Reference Picture Selection not supported\n"); 5105 } 5106 if (get_bits1(&s->gb) != 0) { 5107 av_log(s->avctx, AV_LOG_ERROR, "Independent Segment Decoding not supported\n"); 5108 } 5109 s->alt_inter_vlc= get_bits1(&s->gb); 5110 s->modified_quant= get_bits1(&s->gb); 5111 if(s->modified_quant) 5112 s->chroma_qscale_table= ff_h263_chroma_qscale_table; 5113 5114 skip_bits(&s->gb, 1); /* Prevent start code emulation */ 5115 5116 skip_bits(&s->gb, 3); /* Reserved */ 5117 } else if (ufep != 0) { 5118 av_log(s->avctx, AV_LOG_ERROR, "Bad UFEP type (%d)\n", ufep); 5119 return -1; 5120 } 5121 5122 /* MPPTYPE */ 5123 s->pict_type = get_bits(&s->gb, 3); 5124 switch(s->pict_type){ 5125 case 0: s->pict_type= FF_I_TYPE;break; 5126 case 1: s->pict_type= FF_P_TYPE;break; 5127 case 3: s->pict_type= FF_B_TYPE;break; 5128 case 7: s->pict_type= FF_I_TYPE;break; //ZYGO 5129 default: 5130 return -1; 5131 } 5132 skip_bits(&s->gb, 2); 5133 s->no_rounding = get_bits1(&s->gb); 5134 skip_bits(&s->gb, 4); 5135 5136 /* Get the picture dimensions */ 5137 if (ufep) { 5138 if (format == 6) { 5139 /* Custom Picture Format (CPFMT) */ 5140 s->aspect_ratio_info = get_bits(&s->gb, 4); 5141 dprintf(s->avctx, "aspect: %d\n", s->aspect_ratio_info); 5142 /* aspect ratios: 5143 0 - forbidden 5144 1 - 1:1 5145 2 - 12:11 (CIF 4:3) 5146 3 - 10:11 (525-type 4:3) 5147 4 - 16:11 (CIF 16:9) 5148 5 - 40:33 (525-type 16:9) 5149 6-14 - reserved 5150 */ 5151 width = (get_bits(&s->gb, 9) + 1) * 4; 5152 skip_bits1(&s->gb); 5153 height = get_bits(&s->gb, 9) * 4; 5154 dprintf(s->avctx, "\nH.263+ Custom picture: %dx%d\n",width,height); 5155 if (s->aspect_ratio_info == FF_ASPECT_EXTENDED) { 5156 /* aspected dimensions */ 5157 s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 8); 5158 s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 8); 5159 }else{ 5160 s->avctx->sample_aspect_ratio= pixel_aspect[s->aspect_ratio_info]; 5161 } 5162 } else { 5163 width = h263_format[format][0]; 5164 height = h263_format[format][1]; 5165 s->avctx->sample_aspect_ratio= (AVRational){12,11}; 5166 } 5167 if ((width == 0) || (height == 0)) 5168 return -1; 5169 s->width = width; 5170 s->height = height; 5171 5172 if(s->custom_pcf){ 5173 int gcd; 5174 s->avctx->time_base.den= 1800000; 5175 s->avctx->time_base.num= 1000 + get_bits1(&s->gb); 5176 s->avctx->time_base.num*= get_bits(&s->gb, 7); 5177 if(s->avctx->time_base.num == 0){ 5178 av_log(s, AV_LOG_ERROR, "zero framerate\n"); 5179 return -1; 5180 } 5181 gcd= av_gcd(s->avctx->time_base.den, s->avctx->time_base.num); 5182 s->avctx->time_base.den /= gcd; 5183 s->avctx->time_base.num /= gcd; 5184// av_log(s->avctx, AV_LOG_DEBUG, "%d/%d\n", s->avctx->time_base.den, s->avctx->time_base.num); 5185 }else{ 5186 s->avctx->time_base= (AVRational){1001, 30000}; 5187 } 5188 } 5189 5190 if(s->custom_pcf){ 5191 skip_bits(&s->gb, 2); //extended Temporal reference 5192 } 5193 5194 if (ufep) { 5195 if (s->umvplus) { 5196 if(get_bits1(&s->gb)==0) /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */ 5197 skip_bits1(&s->gb); 5198 } 5199 if(s->h263_slice_structured){ 5200 if (get_bits1(&s->gb) != 0) { 5201 av_log(s->avctx, AV_LOG_ERROR, "rectangular slices not supported\n"); 5202 } 5203 if (get_bits1(&s->gb) != 0) { 5204 av_log(s->avctx, AV_LOG_ERROR, "unordered slices not supported\n"); 5205 } 5206 } 5207 } 5208 5209 s->qscale = get_bits(&s->gb, 5); 5210 } 5211 5212 s->mb_width = (s->width + 15) / 16; 5213 s->mb_height = (s->height + 15) / 16; 5214 s->mb_num = s->mb_width * s->mb_height; 5215 5216 /* PEI */ 5217 while (get_bits1(&s->gb) != 0) { 5218 skip_bits(&s->gb, 8); 5219 } 5220 5221 if(s->h263_slice_structured){ 5222 if (get_bits1(&s->gb) != 1) { 5223 av_log(s->avctx, AV_LOG_ERROR, "SEPB1 marker missing\n"); 5224 return -1; 5225 } 5226 5227 ff_h263_decode_mba(s); 5228 5229 if (get_bits1(&s->gb) != 1) { 5230 av_log(s->avctx, AV_LOG_ERROR, "SEPB2 marker missing\n"); 5231 return -1; 5232 } 5233 } 5234 s->f_code = 1; 5235 5236 if(s->h263_aic){ 5237 s->y_dc_scale_table= 5238 s->c_dc_scale_table= ff_aic_dc_scale_table; 5239 }else{ 5240 s->y_dc_scale_table= 5241 s->c_dc_scale_table= ff_mpeg1_dc_scale_table; 5242 } 5243 5244 if(s->avctx->debug&FF_DEBUG_PICT_INFO){ 5245 show_pict_info(s); 5246 } 5247#if 1 5248 if (s->pict_type == FF_I_TYPE && s->codec_tag == AV_RL32("ZYGO")){ 5249 int i,j; 5250 for(i=0; i<85; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb)); 5251 av_log(s->avctx, AV_LOG_DEBUG, "\n"); 5252 for(i=0; i<13; i++){ 5253 for(j=0; j<3; j++){ 5254 int v= get_bits(&s->gb, 8); 5255 v |= get_sbits(&s->gb, 8)<<8; 5256 av_log(s->avctx, AV_LOG_DEBUG, " %5d", v); 5257 } 5258 av_log(s->avctx, AV_LOG_DEBUG, "\n"); 5259 } 5260 for(i=0; i<50; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb)); 5261 } 5262#endif 5263 5264 return 0; 5265} 5266 5267static void mpeg4_decode_sprite_trajectory(MpegEncContext * s, GetBitContext *gb) 5268{ 5269 int i; 5270 int a= 2<<s->sprite_warping_accuracy; 5271 int rho= 3-s->sprite_warping_accuracy; 5272 int r=16/a; 5273 const int vop_ref[4][2]= {{0,0}, {s->width,0}, {0, s->height}, {s->width, s->height}}; // only true for rectangle shapes 5274 int d[4][2]={{0,0}, {0,0}, {0,0}, {0,0}}; 5275 int sprite_ref[4][2]; 5276 int virtual_ref[2][2]; 5277 int w2, h2, w3, h3; 5278 int alpha=0, beta=0; 5279 int w= s->width; 5280 int h= s->height; 5281 int min_ab; 5282 5283 for(i=0; i<s->num_sprite_warping_points; i++){ 5284 int length; 5285 int x=0, y=0; 5286 5287 length= get_vlc2(gb, sprite_trajectory.table, SPRITE_TRAJ_VLC_BITS, 3); 5288 if(length){ 5289 x= get_xbits(gb, length); 5290 } 5291 if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(gb); /* marker bit */ 5292 5293 length= get_vlc2(gb, sprite_trajectory.table, SPRITE_TRAJ_VLC_BITS, 3); 5294 if(length){ 5295 y=get_xbits(gb, length); 5296 } 5297 skip_bits1(gb); /* marker bit */ 5298//printf("%d %d %d %d\n", x, y, i, s->sprite_warping_accuracy); 5299 d[i][0]= x; 5300 d[i][1]= y; 5301 } 5302 5303 while((1<<alpha)<w) alpha++; 5304 while((1<<beta )<h) beta++; // there seems to be a typo in the mpeg4 std for the definition of w' and h' 5305 w2= 1<<alpha; 5306 h2= 1<<beta; 5307 5308// Note, the 4th point isn't used for GMC 5309 if(s->divx_version==500 && s->divx_build==413){ 5310 sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0]; 5311 sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1]; 5312 sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0]; 5313 sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1]; 5314 sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0]; 5315 sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1]; 5316 } else { 5317 sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]); 5318 sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]); 5319 sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]); 5320 sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]); 5321 sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]); 5322 sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]); 5323 } 5324/* sprite_ref[3][0]= (a>>1)*(2*vop_ref[3][0] + d[0][0] + d[1][0] + d[2][0] + d[3][0]); 5325 sprite_ref[3][1]= (a>>1)*(2*vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */ 5326 5327// this is mostly identical to the mpeg4 std (and is totally unreadable because of that ...) 5328// perhaps it should be reordered to be more readable ... 5329// the idea behind this virtual_ref mess is to be able to use shifts later per pixel instead of divides 5330// so the distance between points is converted from w&h based to w2&h2 based which are of the 2^x form 5331 virtual_ref[0][0]= 16*(vop_ref[0][0] + w2) 5332 + 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); 5333 virtual_ref[0][1]= 16*vop_ref[0][1] 5334 + 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); 5335 virtual_ref[1][0]= 16*vop_ref[0][0] 5336 + 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); 5337 virtual_ref[1][1]= 16*(vop_ref[0][1] + h2) 5338 + 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); 5339 5340 switch(s->num_sprite_warping_points) 5341 { 5342 case 0: 5343 s->sprite_offset[0][0]= 0; 5344 s->sprite_offset[0][1]= 0; 5345 s->sprite_offset[1][0]= 0; 5346 s->sprite_offset[1][1]= 0; 5347 s->sprite_delta[0][0]= a; 5348 s->sprite_delta[0][1]= 0; 5349 s->sprite_delta[1][0]= 0; 5350 s->sprite_delta[1][1]= a; 5351 s->sprite_shift[0]= 0; 5352 s->sprite_shift[1]= 0; 5353 break; 5354 case 1: //GMC only 5355 s->sprite_offset[0][0]= sprite_ref[0][0] - a*vop_ref[0][0]; 5356 s->sprite_offset[0][1]= sprite_ref[0][1] - a*vop_ref[0][1]; 5357 s->sprite_offset[1][0]= ((sprite_ref[0][0]>>1)|(sprite_ref[0][0]&1)) - a*(vop_ref[0][0]/2); 5358 s->sprite_offset[1][1]= ((sprite_ref[0][1]>>1)|(sprite_ref[0][1]&1)) - a*(vop_ref[0][1]/2); 5359 s->sprite_delta[0][0]= a; 5360 s->sprite_delta[0][1]= 0; 5361 s->sprite_delta[1][0]= 0; 5362 s->sprite_delta[1][1]= a; 5363 s->sprite_shift[0]= 0; 5364 s->sprite_shift[1]= 0; 5365 break; 5366 case 2: 5367 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+rho)) 5368 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][0]) 5369 + ( r*sprite_ref[0][1] - virtual_ref[0][1])*(-vop_ref[0][1]) 5370 + (1<<(alpha+rho-1)); 5371 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+rho)) 5372 + (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-vop_ref[0][0]) 5373 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-vop_ref[0][1]) 5374 + (1<<(alpha+rho-1)); 5375 s->sprite_offset[1][0]= ( (-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][0] + 1) 5376 +( r*sprite_ref[0][1] - virtual_ref[0][1])*(-2*vop_ref[0][1] + 1) 5377 +2*w2*r*sprite_ref[0][0] 5378 - 16*w2 5379 + (1<<(alpha+rho+1))); 5380 s->sprite_offset[1][1]= ( (-r*sprite_ref[0][1] + virtual_ref[0][1])*(-2*vop_ref[0][0] + 1) 5381 +(-r*sprite_ref[0][0] + virtual_ref[0][0])*(-2*vop_ref[0][1] + 1) 5382 +2*w2*r*sprite_ref[0][1] 5383 - 16*w2 5384 + (1<<(alpha+rho+1))); 5385 s->sprite_delta[0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0]); 5386 s->sprite_delta[0][1]= (+r*sprite_ref[0][1] - virtual_ref[0][1]); 5387 s->sprite_delta[1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1]); 5388 s->sprite_delta[1][1]= (-r*sprite_ref[0][0] + virtual_ref[0][0]); 5389 5390 s->sprite_shift[0]= alpha+rho; 5391 s->sprite_shift[1]= alpha+rho+2; 5392 break; 5393 case 3: 5394 min_ab= FFMIN(alpha, beta); 5395 w3= w2>>min_ab; 5396 h3= h2>>min_ab; 5397 s->sprite_offset[0][0]= (sprite_ref[0][0]<<(alpha+beta+rho-min_ab)) 5398 + (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-vop_ref[0][0]) 5399 + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-vop_ref[0][1]) 5400 + (1<<(alpha+beta+rho-min_ab-1)); 5401 s->sprite_offset[0][1]= (sprite_ref[0][1]<<(alpha+beta+rho-min_ab)) 5402 + (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-vop_ref[0][0]) 5403 + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-vop_ref[0][1]) 5404 + (1<<(alpha+beta+rho-min_ab-1)); 5405 s->sprite_offset[1][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3*(-2*vop_ref[0][0] + 1) 5406 + (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3*(-2*vop_ref[0][1] + 1) 5407 + 2*w2*h3*r*sprite_ref[0][0] 5408 - 16*w2*h3 5409 + (1<<(alpha+beta+rho-min_ab+1)); 5410 s->sprite_offset[1][1]= (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3*(-2*vop_ref[0][0] + 1) 5411 + (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3*(-2*vop_ref[0][1] + 1) 5412 + 2*w2*h3*r*sprite_ref[0][1] 5413 - 16*w2*h3 5414 + (1<<(alpha+beta+rho-min_ab+1)); 5415 s->sprite_delta[0][0]= (-r*sprite_ref[0][0] + virtual_ref[0][0])*h3; 5416 s->sprite_delta[0][1]= (-r*sprite_ref[0][0] + virtual_ref[1][0])*w3; 5417 s->sprite_delta[1][0]= (-r*sprite_ref[0][1] + virtual_ref[0][1])*h3; 5418 s->sprite_delta[1][1]= (-r*sprite_ref[0][1] + virtual_ref[1][1])*w3; 5419 5420 s->sprite_shift[0]= alpha + beta + rho - min_ab; 5421 s->sprite_shift[1]= alpha + beta + rho - min_ab + 2; 5422 break; 5423 } 5424 /* try to simplify the situation */ 5425 if( s->sprite_delta[0][0] == a<<s->sprite_shift[0] 5426 && s->sprite_delta[0][1] == 0 5427 && s->sprite_delta[1][0] == 0 5428 && s->sprite_delta[1][1] == a<<s->sprite_shift[0]) 5429 { 5430 s->sprite_offset[0][0]>>=s->sprite_shift[0]; 5431 s->sprite_offset[0][1]>>=s->sprite_shift[0]; 5432 s->sprite_offset[1][0]>>=s->sprite_shift[1]; 5433 s->sprite_offset[1][1]>>=s->sprite_shift[1]; 5434 s->sprite_delta[0][0]= a; 5435 s->sprite_delta[0][1]= 0; 5436 s->sprite_delta[1][0]= 0; 5437 s->sprite_delta[1][1]= a; 5438 s->sprite_shift[0]= 0; 5439 s->sprite_shift[1]= 0; 5440 s->real_sprite_warping_points=1; 5441 } 5442 else{ 5443 int shift_y= 16 - s->sprite_shift[0]; 5444 int shift_c= 16 - s->sprite_shift[1]; 5445//printf("shifts %d %d\n", shift_y, shift_c); 5446 for(i=0; i<2; i++){ 5447 s->sprite_offset[0][i]<<= shift_y; 5448 s->sprite_offset[1][i]<<= shift_c; 5449 s->sprite_delta[0][i]<<= shift_y; 5450 s->sprite_delta[1][i]<<= shift_y; 5451 s->sprite_shift[i]= 16; 5452 } 5453 s->real_sprite_warping_points= s->num_sprite_warping_points; 5454 } 5455#if 0 5456printf("vop:%d:%d %d:%d %d:%d, sprite:%d:%d %d:%d %d:%d, virtual: %d:%d %d:%d\n", 5457 vop_ref[0][0], vop_ref[0][1], 5458 vop_ref[1][0], vop_ref[1][1], 5459 vop_ref[2][0], vop_ref[2][1], 5460 sprite_ref[0][0], sprite_ref[0][1], 5461 sprite_ref[1][0], sprite_ref[1][1], 5462 sprite_ref[2][0], sprite_ref[2][1], 5463 virtual_ref[0][0], virtual_ref[0][1], 5464 virtual_ref[1][0], virtual_ref[1][1] 5465 ); 5466 5467printf("offset: %d:%d , delta: %d %d %d %d, shift %d\n", 5468 s->sprite_offset[0][0], s->sprite_offset[0][1], 5469 s->sprite_delta[0][0], s->sprite_delta[0][1], 5470 s->sprite_delta[1][0], s->sprite_delta[1][1], 5471 s->sprite_shift[0] 5472 ); 5473#endif 5474} 5475 5476static int mpeg4_decode_gop_header(MpegEncContext * s, GetBitContext *gb){ 5477 int hours, minutes, seconds; 5478 5479 hours= get_bits(gb, 5); 5480 minutes= get_bits(gb, 6); 5481 skip_bits1(gb); 5482 seconds= get_bits(gb, 6); 5483 5484 s->time_base= seconds + 60*(minutes + 60*hours); 5485 5486 skip_bits1(gb); 5487 skip_bits1(gb); 5488 5489 return 0; 5490} 5491 5492static int decode_vol_header(MpegEncContext *s, GetBitContext *gb){ 5493 int width, height, vo_ver_id; 5494 5495 /* vol header */ 5496 skip_bits(gb, 1); /* random access */ 5497 s->vo_type= get_bits(gb, 8); 5498 if (get_bits1(gb) != 0) { /* is_ol_id */ 5499 vo_ver_id = get_bits(gb, 4); /* vo_ver_id */ 5500 skip_bits(gb, 3); /* vo_priority */ 5501 } else { 5502 vo_ver_id = 1; 5503 } 5504//printf("vo type:%d\n",s->vo_type); 5505 s->aspect_ratio_info= get_bits(gb, 4); 5506 if(s->aspect_ratio_info == FF_ASPECT_EXTENDED){ 5507 s->avctx->sample_aspect_ratio.num= get_bits(gb, 8); // par_width 5508 s->avctx->sample_aspect_ratio.den= get_bits(gb, 8); // par_height 5509 }else{ 5510 s->avctx->sample_aspect_ratio= pixel_aspect[s->aspect_ratio_info]; 5511 } 5512 5513 if ((s->vol_control_parameters=get_bits1(gb))) { /* vol control parameter */ 5514 int chroma_format= get_bits(gb, 2); 5515 if(chroma_format!=CHROMA_420){ 5516 av_log(s->avctx, AV_LOG_ERROR, "illegal chroma format\n"); 5517 } 5518 s->low_delay= get_bits1(gb); 5519 if(get_bits1(gb)){ /* vbv parameters */ 5520 get_bits(gb, 15); /* first_half_bitrate */ 5521 skip_bits1(gb); /* marker */ 5522 get_bits(gb, 15); /* latter_half_bitrate */ 5523 skip_bits1(gb); /* marker */ 5524 get_bits(gb, 15); /* first_half_vbv_buffer_size */ 5525 skip_bits1(gb); /* marker */ 5526 get_bits(gb, 3); /* latter_half_vbv_buffer_size */ 5527 get_bits(gb, 11); /* first_half_vbv_occupancy */ 5528 skip_bits1(gb); /* marker */ 5529 get_bits(gb, 15); /* latter_half_vbv_occupancy */ 5530 skip_bits1(gb); /* marker */ 5531 } 5532 }else{ 5533 // set low delay flag only once the smartest? low delay detection won't be overriden 5534 if(s->picture_number==0) 5535 s->low_delay=0; 5536 } 5537 5538 s->shape = get_bits(gb, 2); /* vol shape */ 5539 if(s->shape != RECT_SHAPE) av_log(s->avctx, AV_LOG_ERROR, "only rectangular vol supported\n"); 5540 if(s->shape == GRAY_SHAPE && vo_ver_id != 1){ 5541 av_log(s->avctx, AV_LOG_ERROR, "Gray shape not supported\n"); 5542 skip_bits(gb, 4); //video_object_layer_shape_extension 5543 } 5544 5545 check_marker(gb, "before time_increment_resolution"); 5546 5547 s->avctx->time_base.den = get_bits(gb, 16); 5548 if(!s->avctx->time_base.den){ 5549 av_log(s->avctx, AV_LOG_ERROR, "time_base.den==0\n"); 5550 return -1; 5551 } 5552 5553 s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1; 5554 if (s->time_increment_bits < 1) 5555 s->time_increment_bits = 1; 5556 5557 check_marker(gb, "before fixed_vop_rate"); 5558 5559 if (get_bits1(gb) != 0) { /* fixed_vop_rate */ 5560 s->avctx->time_base.num = get_bits(gb, s->time_increment_bits); 5561 }else 5562 s->avctx->time_base.num = 1; 5563 5564 s->t_frame=0; 5565 5566 if (s->shape != BIN_ONLY_SHAPE) { 5567 if (s->shape == RECT_SHAPE) { 5568 skip_bits1(gb); /* marker */ 5569 width = get_bits(gb, 13); 5570 skip_bits1(gb); /* marker */ 5571 height = get_bits(gb, 13); 5572 skip_bits1(gb); /* marker */ 5573 if(width && height && !(s->width && s->codec_tag == AV_RL32("MP4S"))){ /* they should be non zero but who knows ... */ 5574 s->width = width; 5575 s->height = height; 5576// printf("width/height: %d %d\n", width, height); 5577 } 5578 } 5579 5580 s->progressive_sequence= 5581 s->progressive_frame= get_bits1(gb)^1; 5582 s->interlaced_dct=0; 5583 if(!get_bits1(gb) && (s->avctx->debug & FF_DEBUG_PICT_INFO)) 5584 av_log(s->avctx, AV_LOG_INFO, "MPEG4 OBMC not supported (very likely buggy encoder)\n"); /* OBMC Disable */ 5585 if (vo_ver_id == 1) { 5586 s->vol_sprite_usage = get_bits1(gb); /* vol_sprite_usage */ 5587 } else { 5588 s->vol_sprite_usage = get_bits(gb, 2); /* vol_sprite_usage */ 5589 } 5590 if(s->vol_sprite_usage==STATIC_SPRITE) av_log(s->avctx, AV_LOG_ERROR, "Static Sprites not supported\n"); 5591 if(s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE){ 5592 if(s->vol_sprite_usage==STATIC_SPRITE){ 5593 s->sprite_width = get_bits(gb, 13); 5594 skip_bits1(gb); /* marker */ 5595 s->sprite_height= get_bits(gb, 13); 5596 skip_bits1(gb); /* marker */ 5597 s->sprite_left = get_bits(gb, 13); 5598 skip_bits1(gb); /* marker */ 5599 s->sprite_top = get_bits(gb, 13); 5600 skip_bits1(gb); /* marker */ 5601 } 5602 s->num_sprite_warping_points= get_bits(gb, 6); 5603 if(s->num_sprite_warping_points > 3){ 5604 av_log(s->avctx, AV_LOG_ERROR, "%d sprite_warping_points\n", s->num_sprite_warping_points); 5605 s->num_sprite_warping_points= 0; 5606 return -1; 5607 } 5608 s->sprite_warping_accuracy = get_bits(gb, 2); 5609 s->sprite_brightness_change= get_bits1(gb); 5610 if(s->vol_sprite_usage==STATIC_SPRITE) 5611 s->low_latency_sprite= get_bits1(gb); 5612 } 5613 // FIXME sadct disable bit if verid!=1 && shape not rect 5614 5615 if (get_bits1(gb) == 1) { /* not_8_bit */ 5616 s->quant_precision = get_bits(gb, 4); /* quant_precision */ 5617 if(get_bits(gb, 4)!=8) av_log(s->avctx, AV_LOG_ERROR, "N-bit not supported\n"); /* bits_per_pixel */ 5618 if(s->quant_precision!=5) av_log(s->avctx, AV_LOG_ERROR, "quant precision %d\n", s->quant_precision); 5619 } else { 5620 s->quant_precision = 5; 5621 } 5622 5623 // FIXME a bunch of grayscale shape things 5624 5625 if((s->mpeg_quant=get_bits1(gb))){ /* vol_quant_type */ 5626 int i, v; 5627 5628 /* load default matrixes */ 5629 for(i=0; i<64; i++){ 5630 int j= s->dsp.idct_permutation[i]; 5631 v= ff_mpeg4_default_intra_matrix[i]; 5632 s->intra_matrix[j]= v; 5633 s->chroma_intra_matrix[j]= v; 5634 5635 v= ff_mpeg4_default_non_intra_matrix[i]; 5636 s->inter_matrix[j]= v; 5637 s->chroma_inter_matrix[j]= v; 5638 } 5639 5640 /* load custom intra matrix */ 5641 if(get_bits1(gb)){ 5642 int last=0; 5643 for(i=0; i<64; i++){ 5644 int j; 5645 v= get_bits(gb, 8); 5646 if(v==0) break; 5647 5648 last= v; 5649 j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ]; 5650 s->intra_matrix[j]= v; 5651 s->chroma_intra_matrix[j]= v; 5652 } 5653 5654 /* replicate last value */ 5655 for(; i<64; i++){ 5656 int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ]; 5657 s->intra_matrix[j]= last; 5658 s->chroma_intra_matrix[j]= last; 5659 } 5660 } 5661 5662 /* load custom non intra matrix */ 5663 if(get_bits1(gb)){ 5664 int last=0; 5665 for(i=0; i<64; i++){ 5666 int j; 5667 v= get_bits(gb, 8); 5668 if(v==0) break; 5669 5670 last= v; 5671 j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ]; 5672 s->inter_matrix[j]= v; 5673 s->chroma_inter_matrix[j]= v; 5674 } 5675 5676 /* replicate last value */ 5677 for(; i<64; i++){ 5678 int j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ]; 5679 s->inter_matrix[j]= last; 5680 s->chroma_inter_matrix[j]= last; 5681 } 5682 } 5683 5684 // FIXME a bunch of grayscale shape things 5685 } 5686 5687 if(vo_ver_id != 1) 5688 s->quarter_sample= get_bits1(gb); 5689 else s->quarter_sample=0; 5690 5691 if(!get_bits1(gb)){ 5692 int pos= get_bits_count(gb); 5693 int estimation_method= get_bits(gb, 2); 5694 if(estimation_method<2){ 5695 if(!get_bits1(gb)){ 5696 s->cplx_estimation_trash_i += 8*get_bits1(gb); //opaque 5697 s->cplx_estimation_trash_i += 8*get_bits1(gb); //transparent 5698 s->cplx_estimation_trash_i += 8*get_bits1(gb); //intra_cae 5699 s->cplx_estimation_trash_i += 8*get_bits1(gb); //inter_cae 5700 s->cplx_estimation_trash_i += 8*get_bits1(gb); //no_update 5701 s->cplx_estimation_trash_i += 8*get_bits1(gb); //upampling 5702 } 5703 if(!get_bits1(gb)){ 5704 s->cplx_estimation_trash_i += 8*get_bits1(gb); //intra_blocks 5705 s->cplx_estimation_trash_p += 8*get_bits1(gb); //inter_blocks 5706 s->cplx_estimation_trash_p += 8*get_bits1(gb); //inter4v_blocks 5707 s->cplx_estimation_trash_i += 8*get_bits1(gb); //not coded blocks 5708 } 5709 if(!check_marker(gb, "in complexity estimation part 1")){ 5710 skip_bits_long(gb, pos - get_bits_count(gb)); 5711 goto no_cplx_est; 5712 } 5713 if(!get_bits1(gb)){ 5714 s->cplx_estimation_trash_i += 8*get_bits1(gb); //dct_coeffs 5715 s->cplx_estimation_trash_i += 8*get_bits1(gb); //dct_lines 5716 s->cplx_estimation_trash_i += 8*get_bits1(gb); //vlc_syms 5717 s->cplx_estimation_trash_i += 4*get_bits1(gb); //vlc_bits 5718 } 5719 if(!get_bits1(gb)){ 5720 s->cplx_estimation_trash_p += 8*get_bits1(gb); //apm 5721 s->cplx_estimation_trash_p += 8*get_bits1(gb); //npm 5722 s->cplx_estimation_trash_b += 8*get_bits1(gb); //interpolate_mc_q 5723 s->cplx_estimation_trash_p += 8*get_bits1(gb); //forwback_mc_q 5724 s->cplx_estimation_trash_p += 8*get_bits1(gb); //halfpel2 5725 s->cplx_estimation_trash_p += 8*get_bits1(gb); //halfpel4 5726 } 5727 if(!check_marker(gb, "in complexity estimation part 2")){ 5728 skip_bits_long(gb, pos - get_bits_count(gb)); 5729 goto no_cplx_est; 5730 } 5731 if(estimation_method==1){ 5732 s->cplx_estimation_trash_i += 8*get_bits1(gb); //sadct 5733 s->cplx_estimation_trash_p += 8*get_bits1(gb); //qpel 5734 } 5735 }else 5736 av_log(s->avctx, AV_LOG_ERROR, "Invalid Complexity estimation method %d\n", estimation_method); 5737 }else{ 5738no_cplx_est: 5739 s->cplx_estimation_trash_i= 5740 s->cplx_estimation_trash_p= 5741 s->cplx_estimation_trash_b= 0; 5742 } 5743 5744 s->resync_marker= !get_bits1(gb); /* resync_marker_disabled */ 5745 5746 s->data_partitioning= get_bits1(gb); 5747 if(s->data_partitioning){ 5748 s->rvlc= get_bits1(gb); 5749 } 5750 5751 if(vo_ver_id != 1) { 5752 s->new_pred= get_bits1(gb); 5753 if(s->new_pred){ 5754 av_log(s->avctx, AV_LOG_ERROR, "new pred not supported\n"); 5755 skip_bits(gb, 2); /* requested upstream message type */ 5756 skip_bits1(gb); /* newpred segment type */ 5757 } 5758 s->reduced_res_vop= get_bits1(gb); 5759 if(s->reduced_res_vop) av_log(s->avctx, AV_LOG_ERROR, "reduced resolution VOP not supported\n"); 5760 } 5761 else{ 5762 s->new_pred=0; 5763 s->reduced_res_vop= 0; 5764 } 5765 5766 s->scalability= get_bits1(gb); 5767 5768 if (s->scalability) { 5769 GetBitContext bak= *gb; 5770 int ref_layer_id; 5771 int ref_layer_sampling_dir; 5772 int h_sampling_factor_n; 5773 int h_sampling_factor_m; 5774 int v_sampling_factor_n; 5775 int v_sampling_factor_m; 5776 5777 s->hierachy_type= get_bits1(gb); 5778 ref_layer_id= get_bits(gb, 4); 5779 ref_layer_sampling_dir= get_bits1(gb); 5780 h_sampling_factor_n= get_bits(gb, 5); 5781 h_sampling_factor_m= get_bits(gb, 5); 5782 v_sampling_factor_n= get_bits(gb, 5); 5783 v_sampling_factor_m= get_bits(gb, 5); 5784 s->enhancement_type= get_bits1(gb); 5785 5786 if( h_sampling_factor_n==0 || h_sampling_factor_m==0 5787 || v_sampling_factor_n==0 || v_sampling_factor_m==0){ 5788 5789// fprintf(stderr, "illegal scalability header (VERY broken encoder), trying to workaround\n"); 5790 s->scalability=0; 5791 5792 *gb= bak; 5793 }else 5794 av_log(s->avctx, AV_LOG_ERROR, "scalability not supported\n"); 5795 5796 // bin shape stuff FIXME 5797 } 5798 } 5799 return 0; 5800} 5801 5802/** 5803 * decodes the user data stuff in the header. 5804 * Also initializes divx/xvid/lavc_version/build. 5805 */ 5806static int decode_user_data(MpegEncContext *s, GetBitContext *gb){ 5807 char buf[256]; 5808 int i; 5809 int e; 5810 int ver = 0, build = 0, ver2 = 0, ver3 = 0; 5811 char last; 5812 5813 for(i=0; i<255 && get_bits_count(gb) < gb->size_in_bits; i++){ 5814 if(show_bits(gb, 23) == 0) break; 5815 buf[i]= get_bits(gb, 8); 5816 } 5817 buf[i]=0; 5818 5819 /* divx detection */ 5820 e=sscanf(buf, "DivX%dBuild%d%c", &ver, &build, &last); 5821 if(e<2) 5822 e=sscanf(buf, "DivX%db%d%c", &ver, &build, &last); 5823 if(e>=2){ 5824 s->divx_version= ver; 5825 s->divx_build= build; 5826 s->divx_packed= e==3 && last=='p'; 5827 if(s->divx_packed && !s->showed_packed_warning) { 5828 av_log(s->avctx, AV_LOG_WARNING, "Invalid and inefficient vfw-avi packed B frames detected\n"); 5829 s->showed_packed_warning=1; 5830 } 5831 } 5832 5833 /* ffmpeg detection */ 5834 e=sscanf(buf, "FFmpe%*[^b]b%d", &build)+3; 5835 if(e!=4) 5836 e=sscanf(buf, "FFmpeg v%d.%d.%d / libavcodec build: %d", &ver, &ver2, &ver3, &build); 5837 if(e!=4){ 5838 e=sscanf(buf, "Lavc%d.%d.%d", &ver, &ver2, &ver3)+1; 5839 if (e>1) 5840 build= (ver<<16) + (ver2<<8) + ver3; 5841 } 5842 if(e!=4){ 5843 if(strcmp(buf, "ffmpeg")==0){ 5844 s->lavc_build= 4600; 5845 } 5846 } 5847 if(e==4){ 5848 s->lavc_build= build; 5849 } 5850 5851 /* Xvid detection */ 5852 e=sscanf(buf, "XviD%d", &build); 5853 if(e==1){ 5854 s->xvid_build= build; 5855 } 5856 5857//printf("User Data: %s\n", buf); 5858 return 0; 5859} 5860 5861static int decode_vop_header(MpegEncContext *s, GetBitContext *gb){ 5862 int time_incr, time_increment; 5863 5864 s->pict_type = get_bits(gb, 2) + FF_I_TYPE; /* pict type: I = 0 , P = 1 */ 5865 if(s->pict_type==FF_B_TYPE && s->low_delay && s->vol_control_parameters==0 && !(s->flags & CODEC_FLAG_LOW_DELAY)){ 5866 av_log(s->avctx, AV_LOG_ERROR, "low_delay flag incorrectly, clearing it\n"); 5867 s->low_delay=0; 5868 } 5869 5870 s->partitioned_frame= s->data_partitioning && s->pict_type!=FF_B_TYPE; 5871 if(s->partitioned_frame) 5872 s->decode_mb= mpeg4_decode_partitioned_mb; 5873 else 5874 s->decode_mb= ff_mpeg4_decode_mb; 5875 5876 time_incr=0; 5877 while (get_bits1(gb) != 0) 5878 time_incr++; 5879 5880 check_marker(gb, "before time_increment"); 5881 5882 if(s->time_increment_bits==0 || !(show_bits(gb, s->time_increment_bits+1)&1)){ 5883 av_log(s->avctx, AV_LOG_ERROR, "hmm, seems the headers are not complete, trying to guess time_increment_bits\n"); 5884 5885 for(s->time_increment_bits=1 ;s->time_increment_bits<16; s->time_increment_bits++){ 5886 if(show_bits(gb, s->time_increment_bits+1)&1) break; 5887 } 5888 5889 av_log(s->avctx, AV_LOG_ERROR, "my guess is %d bits ;)\n",s->time_increment_bits); 5890 } 5891 5892 if(IS_3IV1) time_increment= get_bits1(gb); //FIXME investigate further 5893 else time_increment= get_bits(gb, s->time_increment_bits); 5894 5895// printf("%d %X\n", s->time_increment_bits, time_increment); 5896//av_log(s->avctx, AV_LOG_DEBUG, " type:%d modulo_time_base:%d increment:%d t_frame %d\n", s->pict_type, time_incr, time_increment, s->t_frame); 5897 if(s->pict_type!=FF_B_TYPE){ 5898 s->last_time_base= s->time_base; 5899 s->time_base+= time_incr; 5900 s->time= s->time_base*s->avctx->time_base.den + time_increment; 5901 if(s->workaround_bugs&FF_BUG_UMP4){ 5902 if(s->time < s->last_non_b_time){ 5903// fprintf(stderr, "header is not mpeg4 compatible, broken encoder, trying to workaround\n"); 5904 s->time_base++; 5905 s->time+= s->avctx->time_base.den; 5906 } 5907 } 5908 s->pp_time= s->time - s->last_non_b_time; 5909 s->last_non_b_time= s->time; 5910 }else{ 5911 s->time= (s->last_time_base + time_incr)*s->avctx->time_base.den + time_increment; 5912 s->pb_time= s->pp_time - (s->last_non_b_time - s->time); 5913 if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){ 5914// printf("messed up order, maybe after seeking? skipping current b frame\n"); 5915 return FRAME_SKIPPED; 5916 } 5917 ff_mpeg4_init_direct_mv(s); 5918 5919 if(s->t_frame==0) s->t_frame= s->pb_time; 5920 if(s->t_frame==0) s->t_frame=1; // 1/0 protection 5921 s->pp_field_time= ( ROUNDED_DIV(s->last_non_b_time, s->t_frame) 5922 - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2; 5923 s->pb_field_time= ( ROUNDED_DIV(s->time, s->t_frame) 5924 - ROUNDED_DIV(s->last_non_b_time - s->pp_time, s->t_frame))*2; 5925 if(!s->progressive_sequence){ 5926 if(s->pp_field_time <= s->pb_field_time || s->pb_field_time <= 1) 5927 return FRAME_SKIPPED; 5928 } 5929 } 5930//av_log(s->avctx, AV_LOG_DEBUG, "last nonb %"PRId64" last_base %d time %"PRId64" pp %d pb %d t %d ppf %d pbf %d\n", s->last_non_b_time, s->last_time_base, s->time, s->pp_time, s->pb_time, s->t_frame, s->pp_field_time, s->pb_field_time); 5931 5932 if(s->avctx->time_base.num) 5933 s->current_picture_ptr->pts= (s->time + s->avctx->time_base.num/2) / s->avctx->time_base.num; 5934 else 5935 s->current_picture_ptr->pts= AV_NOPTS_VALUE; 5936 if(s->avctx->debug&FF_DEBUG_PTS) 5937 av_log(s->avctx, AV_LOG_DEBUG, "MPEG4 PTS: %"PRId64"\n", s->current_picture_ptr->pts); 5938 5939 check_marker(gb, "before vop_coded"); 5940 5941 /* vop coded */ 5942 if (get_bits1(gb) != 1){ 5943 if(s->avctx->debug&FF_DEBUG_PICT_INFO) 5944 av_log(s->avctx, AV_LOG_ERROR, "vop not coded\n"); 5945 return FRAME_SKIPPED; 5946 } 5947//printf("time %d %d %d || %"PRId64" %"PRId64" %"PRId64"\n", s->time_increment_bits, s->avctx->time_base.den, s->time_base, 5948//s->time, s->last_non_b_time, s->last_non_b_time - s->pp_time); 5949 if (s->shape != BIN_ONLY_SHAPE && ( s->pict_type == FF_P_TYPE 5950 || (s->pict_type == FF_S_TYPE && s->vol_sprite_usage==GMC_SPRITE))) { 5951 /* rounding type for motion estimation */ 5952 s->no_rounding = get_bits1(gb); 5953 } else { 5954 s->no_rounding = 0; 5955 } 5956//FIXME reduced res stuff 5957 5958 if (s->shape != RECT_SHAPE) { 5959 if (s->vol_sprite_usage != 1 || s->pict_type != FF_I_TYPE) { 5960 int width, height, hor_spat_ref, ver_spat_ref; 5961 5962 width = get_bits(gb, 13); 5963 skip_bits1(gb); /* marker */ 5964 height = get_bits(gb, 13); 5965 skip_bits1(gb); /* marker */ 5966 hor_spat_ref = get_bits(gb, 13); /* hor_spat_ref */ 5967 skip_bits1(gb); /* marker */ 5968 ver_spat_ref = get_bits(gb, 13); /* ver_spat_ref */ 5969 } 5970 skip_bits1(gb); /* change_CR_disable */ 5971 5972 if (get_bits1(gb) != 0) { 5973 skip_bits(gb, 8); /* constant_alpha_value */ 5974 } 5975 } 5976//FIXME complexity estimation stuff 5977 5978 if (s->shape != BIN_ONLY_SHAPE) { 5979 skip_bits_long(gb, s->cplx_estimation_trash_i); 5980 if(s->pict_type != FF_I_TYPE) 5981 skip_bits_long(gb, s->cplx_estimation_trash_p); 5982 if(s->pict_type == FF_B_TYPE) 5983 skip_bits_long(gb, s->cplx_estimation_trash_b); 5984 5985 s->intra_dc_threshold= mpeg4_dc_threshold[ get_bits(gb, 3) ]; 5986 if(!s->progressive_sequence){ 5987 s->top_field_first= get_bits1(gb); 5988 s->alternate_scan= get_bits1(gb); 5989 }else 5990 s->alternate_scan= 0; 5991 } 5992 5993 if(s->alternate_scan){ 5994 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan); 5995 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan); 5996 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_vertical_scan); 5997 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan); 5998 } else{ 5999 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct); 6000 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct); 6001 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan); 6002 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan); 6003 } 6004 6005 if(s->pict_type == FF_S_TYPE && (s->vol_sprite_usage==STATIC_SPRITE || s->vol_sprite_usage==GMC_SPRITE)){ 6006 mpeg4_decode_sprite_trajectory(s, gb); 6007 if(s->sprite_brightness_change) av_log(s->avctx, AV_LOG_ERROR, "sprite_brightness_change not supported\n"); 6008 if(s->vol_sprite_usage==STATIC_SPRITE) av_log(s->avctx, AV_LOG_ERROR, "static sprite not supported\n"); 6009 } 6010 6011 if (s->shape != BIN_ONLY_SHAPE) { 6012 s->chroma_qscale= s->qscale = get_bits(gb, s->quant_precision); 6013 if(s->qscale==0){ 6014 av_log(s->avctx, AV_LOG_ERROR, "Error, header damaged or not MPEG4 header (qscale=0)\n"); 6015 return -1; // makes no sense to continue, as there is nothing left from the image then 6016 } 6017 6018 if (s->pict_type != FF_I_TYPE) { 6019 s->f_code = get_bits(gb, 3); /* fcode_for */ 6020 if(s->f_code==0){ 6021 av_log(s->avctx, AV_LOG_ERROR, "Error, header damaged or not MPEG4 header (f_code=0)\n"); 6022 return -1; // makes no sense to continue, as the MV decoding will break very quickly 6023 } 6024 }else 6025 s->f_code=1; 6026 6027 if (s->pict_type == FF_B_TYPE) { 6028 s->b_code = get_bits(gb, 3); 6029 }else 6030 s->b_code=1; 6031 6032 if(s->avctx->debug&FF_DEBUG_PICT_INFO){ 6033 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", 6034 s->qscale, s->f_code, s->b_code, 6035 s->pict_type == FF_I_TYPE ? "I" : (s->pict_type == FF_P_TYPE ? "P" : (s->pict_type == FF_B_TYPE ? "B" : "S")), 6036 gb->size_in_bits,s->progressive_sequence, s->alternate_scan, s->top_field_first, 6037 s->quarter_sample ? "q" : "h", s->data_partitioning, s->resync_marker, s->num_sprite_warping_points, 6038 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); 6039 } 6040 6041 if(!s->scalability){ 6042 if (s->shape!=RECT_SHAPE && s->pict_type!=FF_I_TYPE) { 6043 skip_bits1(gb); // vop shape coding type 6044 } 6045 }else{ 6046 if(s->enhancement_type){ 6047 int load_backward_shape= get_bits1(gb); 6048 if(load_backward_shape){ 6049 av_log(s->avctx, AV_LOG_ERROR, "load backward shape isn't supported\n"); 6050 } 6051 } 6052 skip_bits(gb, 2); //ref_select_code 6053 } 6054 } 6055 /* detect buggy encoders which don't set the low_delay flag (divx4/xvid/opendivx)*/ 6056 // note we cannot detect divx5 without b-frames easily (although it's buggy too) 6057 if(s->vo_type==0 && s->vol_control_parameters==0 && s->divx_version==0 && s->picture_number==0){ 6058 av_log(s->avctx, AV_LOG_ERROR, "looks like this file was encoded with (divx4/(old)xvid/opendivx) -> forcing low_delay flag\n"); 6059 s->low_delay=1; 6060 } 6061 6062 s->picture_number++; // better than pic number==0 always ;) 6063 6064 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support 6065 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table; 6066 6067 if(s->workaround_bugs&FF_BUG_EDGE){ 6068 s->h_edge_pos= s->width; 6069 s->v_edge_pos= s->height; 6070 } 6071 return 0; 6072} 6073 6074/** 6075 * decode mpeg4 headers 6076 * @return <0 if no VOP found (or a damaged one) 6077 * FRAME_SKIPPED if a not coded VOP is found 6078 * 0 if a VOP is found 6079 */ 6080int ff_mpeg4_decode_picture_header(MpegEncContext * s, GetBitContext *gb) 6081{ 6082 int startcode, v; 6083 6084 /* search next start code */ 6085 align_get_bits(gb); 6086 6087 if(s->codec_tag == AV_RL32("WV1F") && show_bits(gb, 24) == 0x575630){ 6088 skip_bits(gb, 24); 6089 if(get_bits(gb, 8) == 0xF0) 6090 goto end; 6091 } 6092 6093 startcode = 0xff; 6094 for(;;) { 6095 if(get_bits_count(gb) >= gb->size_in_bits){ 6096 if(gb->size_in_bits==8 && (s->divx_version || s->xvid_build)){ 6097 av_log(s->avctx, AV_LOG_ERROR, "frame skip %d\n", gb->size_in_bits); 6098 return FRAME_SKIPPED; //divx bug 6099 }else 6100 return -1; //end of stream 6101 } 6102 6103 /* use the bits after the test */ 6104 v = get_bits(gb, 8); 6105 startcode = ((startcode << 8) | v) & 0xffffffff; 6106 6107 if((startcode&0xFFFFFF00) != 0x100) 6108 continue; //no startcode 6109 6110 if(s->avctx->debug&FF_DEBUG_STARTCODE){ 6111 av_log(s->avctx, AV_LOG_DEBUG, "startcode: %3X ", startcode); 6112 if (startcode<=0x11F) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Start"); 6113 else if(startcode<=0x12F) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Layer Start"); 6114 else if(startcode<=0x13F) av_log(s->avctx, AV_LOG_DEBUG, "Reserved"); 6115 else if(startcode<=0x15F) av_log(s->avctx, AV_LOG_DEBUG, "FGS bp start"); 6116 else if(startcode<=0x1AF) av_log(s->avctx, AV_LOG_DEBUG, "Reserved"); 6117 else if(startcode==0x1B0) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Seq Start"); 6118 else if(startcode==0x1B1) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Seq End"); 6119 else if(startcode==0x1B2) av_log(s->avctx, AV_LOG_DEBUG, "User Data"); 6120 else if(startcode==0x1B3) av_log(s->avctx, AV_LOG_DEBUG, "Group of VOP start"); 6121 else if(startcode==0x1B4) av_log(s->avctx, AV_LOG_DEBUG, "Video Session Error"); 6122 else if(startcode==0x1B5) av_log(s->avctx, AV_LOG_DEBUG, "Visual Object Start"); 6123 else if(startcode==0x1B6) av_log(s->avctx, AV_LOG_DEBUG, "Video Object Plane start"); 6124 else if(startcode==0x1B7) av_log(s->avctx, AV_LOG_DEBUG, "slice start"); 6125 else if(startcode==0x1B8) av_log(s->avctx, AV_LOG_DEBUG, "extension start"); 6126 else if(startcode==0x1B9) av_log(s->avctx, AV_LOG_DEBUG, "fgs start"); 6127 else if(startcode==0x1BA) av_log(s->avctx, AV_LOG_DEBUG, "FBA Object start"); 6128 else if(startcode==0x1BB) av_log(s->avctx, AV_LOG_DEBUG, "FBA Object Plane start"); 6129 else if(startcode==0x1BC) av_log(s->avctx, AV_LOG_DEBUG, "Mesh Object start"); 6130 else if(startcode==0x1BD) av_log(s->avctx, AV_LOG_DEBUG, "Mesh Object Plane start"); 6131 else if(startcode==0x1BE) av_log(s->avctx, AV_LOG_DEBUG, "Still Texture Object start"); 6132 else if(startcode==0x1BF) av_log(s->avctx, AV_LOG_DEBUG, "Texture Spatial Layer start"); 6133 else if(startcode==0x1C0) av_log(s->avctx, AV_LOG_DEBUG, "Texture SNR Layer start"); 6134 else if(startcode==0x1C1) av_log(s->avctx, AV_LOG_DEBUG, "Texture Tile start"); 6135 else if(startcode==0x1C2) av_log(s->avctx, AV_LOG_DEBUG, "Texture Shape Layer start"); 6136 else if(startcode==0x1C3) av_log(s->avctx, AV_LOG_DEBUG, "stuffing start"); 6137 else if(startcode<=0x1C5) av_log(s->avctx, AV_LOG_DEBUG, "reserved"); 6138 else if(startcode<=0x1FF) av_log(s->avctx, AV_LOG_DEBUG, "System start"); 6139 av_log(s->avctx, AV_LOG_DEBUG, " at %d\n", get_bits_count(gb)); 6140 } 6141 6142 if(startcode >= 0x120 && startcode <= 0x12F){ 6143 if(decode_vol_header(s, gb) < 0) 6144 return -1; 6145 } 6146 else if(startcode == USER_DATA_STARTCODE){ 6147 decode_user_data(s, gb); 6148 } 6149 else if(startcode == GOP_STARTCODE){ 6150 mpeg4_decode_gop_header(s, gb); 6151 } 6152 else if(startcode == VOP_STARTCODE){ 6153 break; 6154 } 6155 6156 align_get_bits(gb); 6157 startcode = 0xff; 6158 } 6159end: 6160 if(s->flags& CODEC_FLAG_LOW_DELAY) 6161 s->low_delay=1; 6162 s->avctx->has_b_frames= !s->low_delay; 6163 return decode_vop_header(s, gb); 6164} 6165 6166/* don't understand why they choose a different header ! */ 6167int intel_h263_decode_picture_header(MpegEncContext *s) 6168{ 6169 int format; 6170 6171 /* picture header */ 6172 if (get_bits_long(&s->gb, 22) != 0x20) { 6173 av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n"); 6174 return -1; 6175 } 6176 s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */ 6177 6178 if (get_bits1(&s->gb) != 1) { 6179 av_log(s->avctx, AV_LOG_ERROR, "Bad marker\n"); 6180 return -1; /* marker */ 6181 } 6182 if (get_bits1(&s->gb) != 0) { 6183 av_log(s->avctx, AV_LOG_ERROR, "Bad H263 id\n"); 6184 return -1; /* h263 id */ 6185 } 6186 skip_bits1(&s->gb); /* split screen off */ 6187 skip_bits1(&s->gb); /* camera off */ 6188 skip_bits1(&s->gb); /* freeze picture release off */ 6189 6190 format = get_bits(&s->gb, 3); 6191 if (format != 7) { 6192 av_log(s->avctx, AV_LOG_ERROR, "Intel H263 free format not supported\n"); 6193 return -1; 6194 } 6195 s->h263_plus = 0; 6196 6197 s->pict_type = FF_I_TYPE + get_bits1(&s->gb); 6198 6199 s->unrestricted_mv = get_bits1(&s->gb); 6200 s->h263_long_vectors = s->unrestricted_mv; 6201 6202 if (get_bits1(&s->gb) != 0) { 6203 av_log(s->avctx, AV_LOG_ERROR, "SAC not supported\n"); 6204 return -1; /* SAC: off */ 6205 } 6206 s->obmc= get_bits1(&s->gb); 6207 s->pb_frame = get_bits1(&s->gb); 6208 6209 if(format == 7){ 6210 format = get_bits(&s->gb, 3); 6211 if(format == 0 || format == 7){ 6212 av_log(s->avctx, AV_LOG_ERROR, "Wrong Intel H263 format\n"); 6213 return -1; 6214 } 6215 if(get_bits(&s->gb, 2)) 6216 av_log(s->avctx, AV_LOG_ERROR, "Bad value for reserved field\n"); 6217 s->loop_filter = get_bits1(&s->gb); 6218 if(get_bits1(&s->gb)) 6219 av_log(s->avctx, AV_LOG_ERROR, "Bad value for reserved field\n"); 6220 if(get_bits1(&s->gb)) 6221 s->pb_frame = 2; 6222 if(get_bits(&s->gb, 5)) 6223 av_log(s->avctx, AV_LOG_ERROR, "Bad value for reserved field\n"); 6224 if(get_bits(&s->gb, 5) != 1) 6225 av_log(s->avctx, AV_LOG_ERROR, "Invalid marker\n"); 6226 } 6227 if(format == 6){ 6228 int ar = get_bits(&s->gb, 4); 6229 skip_bits(&s->gb, 9); // display width 6230 skip_bits1(&s->gb); 6231 skip_bits(&s->gb, 9); // display height 6232 if(ar == 15){ 6233 skip_bits(&s->gb, 8); // aspect ratio - width 6234 skip_bits(&s->gb, 8); // aspect ratio - height 6235 } 6236 } 6237 6238 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5); 6239 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */ 6240 6241 if(s->pb_frame){ 6242 skip_bits(&s->gb, 3); //temporal reference for B-frame 6243 skip_bits(&s->gb, 2); //dbquant 6244 } 6245 6246 /* PEI */ 6247 while (get_bits1(&s->gb) != 0) { 6248 skip_bits(&s->gb, 8); 6249 } 6250 s->f_code = 1; 6251 6252 s->y_dc_scale_table= 6253 s->c_dc_scale_table= ff_mpeg1_dc_scale_table; 6254 6255 if(s->avctx->debug&FF_DEBUG_PICT_INFO) 6256 show_pict_info(s); 6257 6258 if(s->pb_frame){ 6259 av_log(s->avctx, AV_LOG_ERROR, "PB frame mode no supported\n"); 6260 return -1; /* PB frame mode */ 6261 } 6262 return 0; 6263} 6264 6265int flv_h263_decode_picture_header(MpegEncContext *s) 6266{ 6267 int format, width, height; 6268 6269 /* picture header */ 6270 if (get_bits_long(&s->gb, 17) != 1) { 6271 av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n"); 6272 return -1; 6273 } 6274 format = get_bits(&s->gb, 5); 6275 if (format != 0 && format != 1) { 6276 av_log(s->avctx, AV_LOG_ERROR, "Bad picture format\n"); 6277 return -1; 6278 } 6279 s->h263_flv = format+1; 6280 s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */ 6281 format = get_bits(&s->gb, 3); 6282 switch (format) { 6283 case 0: 6284 width = get_bits(&s->gb, 8); 6285 height = get_bits(&s->gb, 8); 6286 break; 6287 case 1: 6288 width = get_bits(&s->gb, 16); 6289 height = get_bits(&s->gb, 16); 6290 break; 6291 case 2: 6292 width = 352; 6293 height = 288; 6294 break; 6295 case 3: 6296 width = 176; 6297 height = 144; 6298 break; 6299 case 4: 6300 width = 128; 6301 height = 96; 6302 break; 6303 case 5: 6304 width = 320; 6305 height = 240; 6306 break; 6307 case 6: 6308 width = 160; 6309 height = 120; 6310 break; 6311 default: 6312 width = height = 0; 6313 break; 6314 } 6315 if(avcodec_check_dimensions(s->avctx, width, height)) 6316 return -1; 6317 s->width = width; 6318 s->height = height; 6319 6320 s->pict_type = FF_I_TYPE + get_bits(&s->gb, 2); 6321 s->dropable= s->pict_type > FF_P_TYPE; 6322 if (s->dropable) 6323 s->pict_type = FF_P_TYPE; 6324 6325 skip_bits1(&s->gb); /* deblocking flag */ 6326 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5); 6327 6328 s->h263_plus = 0; 6329 6330 s->unrestricted_mv = 1; 6331 s->h263_long_vectors = 0; 6332 6333 /* PEI */ 6334 while (get_bits1(&s->gb) != 0) { 6335 skip_bits(&s->gb, 8); 6336 } 6337 s->f_code = 1; 6338 6339 if(s->avctx->debug & FF_DEBUG_PICT_INFO){ 6340 av_log(s->avctx, AV_LOG_DEBUG, "%c esc_type:%d, qp:%d num:%d\n", 6341 s->dropable ? 'D' : av_get_pict_type_char(s->pict_type), s->h263_flv-1, s->qscale, s->picture_number); 6342 } 6343 6344 s->y_dc_scale_table= 6345 s->c_dc_scale_table= ff_mpeg1_dc_scale_table; 6346 6347 return 0; 6348} 6349