1/* 2 * MSMPEG4 backend for ffmpeg encoder and decoder 3 * Copyright (c) 2001 Fabrice Bellard 4 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at> 5 * 6 * msmpeg4v1 & v2 stuff by Michael Niedermayer <michaelni@gmx.at> 7 * 8 * This file is part of FFmpeg. 9 * 10 * FFmpeg is free software; you can redistribute it and/or 11 * modify it under the terms of the GNU Lesser General Public 12 * License as published by the Free Software Foundation; either 13 * version 2.1 of the License, or (at your option) any later version. 14 * 15 * FFmpeg is distributed in the hope that it will be useful, 16 * but WITHOUT ANY WARRANTY; without even the implied warranty of 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 18 * Lesser General Public License for more details. 19 * 20 * You should have received a copy of the GNU Lesser General Public 21 * License along with FFmpeg; if not, write to the Free Software 22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 23 */ 24 25/** 26 * @file 27 * MSMPEG4 backend for ffmpeg encoder and decoder. 28 */ 29 30#include "avcodec.h" 31#include "dsputil.h" 32#include "mpegvideo.h" 33#include "msmpeg4.h" 34#include "libavutil/x86_cpu.h" 35#include "h263.h" 36#include "mpeg4video.h" 37 38/* 39 * You can also call this codec : MPEG4 with a twist ! 40 * 41 * TODO: 42 * - (encoding) select best mv table (two choices) 43 * - (encoding) select best vlc/dc table 44 */ 45//#define DEBUG 46 47#define DC_VLC_BITS 9 48#define V2_INTRA_CBPC_VLC_BITS 3 49#define V2_MB_TYPE_VLC_BITS 7 50#define MV_VLC_BITS 9 51#define V2_MV_VLC_BITS 9 52#define TEX_VLC_BITS 9 53 54#define II_BITRATE 128*1024 55#define MBAC_BITRATE 50*1024 56 57#define DEFAULT_INTER_INDEX 3 58 59static uint32_t v2_dc_lum_table[512][2]; 60static uint32_t v2_dc_chroma_table[512][2]; 61 62/* vc1 externs */ 63extern const uint8_t wmv3_dc_scale_table[32]; 64 65#ifdef DEBUG 66int frame_count = 0; 67#endif 68 69#include "msmpeg4data.h" 70 71#if CONFIG_ENCODERS //strangely gcc includes this even if it is not referenced 72static uint8_t rl_length[NB_RL_TABLES][MAX_LEVEL+1][MAX_RUN+1][2]; 73#endif //CONFIG_ENCODERS 74 75static uint8_t static_rl_table_store[NB_RL_TABLES][2][2*MAX_RUN + MAX_LEVEL + 3]; 76 77/* This table is practically identical to the one from h263 78 * except that it is inverted. */ 79static av_cold void init_h263_dc_for_msmpeg4(void) 80{ 81 int level, uni_code, uni_len; 82 83 for(level=-256; level<256; level++){ 84 int size, v, l; 85 /* find number of bits */ 86 size = 0; 87 v = abs(level); 88 while (v) { 89 v >>= 1; 90 size++; 91 } 92 93 if (level < 0) 94 l= (-level) ^ ((1 << size) - 1); 95 else 96 l= level; 97 98 /* luminance h263 */ 99 uni_code= ff_mpeg4_DCtab_lum[size][0]; 100 uni_len = ff_mpeg4_DCtab_lum[size][1]; 101 uni_code ^= (1<<uni_len)-1; //M$ does not like compatibility 102 103 if (size > 0) { 104 uni_code<<=size; uni_code|=l; 105 uni_len+=size; 106 if (size > 8){ 107 uni_code<<=1; uni_code|=1; 108 uni_len++; 109 } 110 } 111 v2_dc_lum_table[level+256][0]= uni_code; 112 v2_dc_lum_table[level+256][1]= uni_len; 113 114 /* chrominance h263 */ 115 uni_code= ff_mpeg4_DCtab_chrom[size][0]; 116 uni_len = ff_mpeg4_DCtab_chrom[size][1]; 117 uni_code ^= (1<<uni_len)-1; //M$ does not like compatibility 118 119 if (size > 0) { 120 uni_code<<=size; uni_code|=l; 121 uni_len+=size; 122 if (size > 8){ 123 uni_code<<=1; uni_code|=1; 124 uni_len++; 125 } 126 } 127 v2_dc_chroma_table[level+256][0]= uni_code; 128 v2_dc_chroma_table[level+256][1]= uni_len; 129 130 } 131} 132 133static av_cold void common_init(MpegEncContext * s) 134{ 135 static int initialized=0; 136 137 switch(s->msmpeg4_version){ 138 case 1: 139 case 2: 140 s->y_dc_scale_table= 141 s->c_dc_scale_table= ff_mpeg1_dc_scale_table; 142 break; 143 case 3: 144 if(s->workaround_bugs){ 145 s->y_dc_scale_table= old_ff_y_dc_scale_table; 146 s->c_dc_scale_table= wmv1_c_dc_scale_table; 147 } else{ 148 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; 149 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table; 150 } 151 break; 152 case 4: 153 case 5: 154 s->y_dc_scale_table= wmv1_y_dc_scale_table; 155 s->c_dc_scale_table= wmv1_c_dc_scale_table; 156 break; 157#if CONFIG_VC1_DECODER 158 case 6: 159 s->y_dc_scale_table= wmv3_dc_scale_table; 160 s->c_dc_scale_table= wmv3_dc_scale_table; 161 break; 162#endif 163 164 } 165 166 167 if(s->msmpeg4_version>=4){ 168 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , wmv1_scantable[1]); 169 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, wmv1_scantable[2]); 170 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, wmv1_scantable[3]); 171 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , wmv1_scantable[0]); 172 } 173 //Note the default tables are set in common_init in mpegvideo.c 174 175 if(!initialized){ 176 initialized=1; 177 178 init_h263_dc_for_msmpeg4(); 179 } 180} 181 182#if CONFIG_ENCODERS 183 184/* build the table which associate a (x,y) motion vector to a vlc */ 185static void init_mv_table(MVTable *tab) 186{ 187 int i, x, y; 188 189 tab->table_mv_index = av_malloc(sizeof(uint16_t) * 4096); 190 /* mark all entries as not used */ 191 for(i=0;i<4096;i++) 192 tab->table_mv_index[i] = tab->n; 193 194 for(i=0;i<tab->n;i++) { 195 x = tab->table_mvx[i]; 196 y = tab->table_mvy[i]; 197 tab->table_mv_index[(x << 6) | y] = i; 198 } 199} 200 201void ff_msmpeg4_code012(PutBitContext *pb, int n) 202{ 203 if (n == 0) { 204 put_bits(pb, 1, 0); 205 } else { 206 put_bits(pb, 1, 1); 207 put_bits(pb, 1, (n >= 2)); 208 } 209} 210 211static int get_size_of_code(MpegEncContext * s, RLTable *rl, int last, int run, int level, int intra){ 212 int size=0; 213 int code; 214 int run_diff= intra ? 0 : 1; 215 216 code = get_rl_index(rl, last, run, level); 217 size+= rl->table_vlc[code][1]; 218 if (code == rl->n) { 219 int level1, run1; 220 221 level1 = level - rl->max_level[last][run]; 222 if (level1 < 1) 223 goto esc2; 224 code = get_rl_index(rl, last, run, level1); 225 if (code == rl->n) { 226 esc2: 227 size++; 228 if (level > MAX_LEVEL) 229 goto esc3; 230 run1 = run - rl->max_run[last][level] - run_diff; 231 if (run1 < 0) 232 goto esc3; 233 code = get_rl_index(rl, last, run1, level); 234 if (code == rl->n) { 235 esc3: 236 /* third escape */ 237 size+=1+1+6+8; 238 } else { 239 /* second escape */ 240 size+= 1+1+ rl->table_vlc[code][1]; 241 } 242 } else { 243 /* first escape */ 244 size+= 1+1+ rl->table_vlc[code][1]; 245 } 246 } else { 247 size++; 248 } 249 return size; 250} 251 252av_cold void ff_msmpeg4_encode_init(MpegEncContext *s) 253{ 254 static int init_done=0; 255 int i; 256 257 common_init(s); 258 if(s->msmpeg4_version>=4){ 259 s->min_qcoeff= -255; 260 s->max_qcoeff= 255; 261 } 262 263 if (!init_done) { 264 /* init various encoding tables */ 265 init_done = 1; 266 init_mv_table(&mv_tables[0]); 267 init_mv_table(&mv_tables[1]); 268 for(i=0;i<NB_RL_TABLES;i++) 269 init_rl(&rl_table[i], static_rl_table_store[i]); 270 271 for(i=0; i<NB_RL_TABLES; i++){ 272 int level; 273 for(level=0; level<=MAX_LEVEL; level++){ 274 int run; 275 for(run=0; run<=MAX_RUN; run++){ 276 int last; 277 for(last=0; last<2; last++){ 278 rl_length[i][level][run][last]= get_size_of_code(s, &rl_table[ i], last, run, level, 0); 279 } 280 } 281 } 282 } 283 } 284} 285 286static void find_best_tables(MpegEncContext * s) 287{ 288 int i; 289 int best =-1, best_size =9999999; 290 int chroma_best=-1, best_chroma_size=9999999; 291 292 for(i=0; i<3; i++){ 293 int level; 294 int chroma_size=0; 295 int size=0; 296 297 if(i>0){// ;) 298 size++; 299 chroma_size++; 300 } 301 for(level=0; level<=MAX_LEVEL; level++){ 302 int run; 303 for(run=0; run<=MAX_RUN; run++){ 304 int last; 305 const int last_size= size + chroma_size; 306 for(last=0; last<2; last++){ 307 int inter_count = s->ac_stats[0][0][level][run][last] + s->ac_stats[0][1][level][run][last]; 308 int intra_luma_count = s->ac_stats[1][0][level][run][last]; 309 int intra_chroma_count= s->ac_stats[1][1][level][run][last]; 310 311 if(s->pict_type==FF_I_TYPE){ 312 size += intra_luma_count *rl_length[i ][level][run][last]; 313 chroma_size+= intra_chroma_count*rl_length[i+3][level][run][last]; 314 }else{ 315 size+= intra_luma_count *rl_length[i ][level][run][last] 316 +intra_chroma_count*rl_length[i+3][level][run][last] 317 +inter_count *rl_length[i+3][level][run][last]; 318 } 319 } 320 if(last_size == size+chroma_size) break; 321 } 322 } 323 if(size<best_size){ 324 best_size= size; 325 best= i; 326 } 327 if(chroma_size<best_chroma_size){ 328 best_chroma_size= chroma_size; 329 chroma_best= i; 330 } 331 } 332 333// printf("type:%d, best:%d, qp:%d, var:%d, mcvar:%d, size:%d //\n", 334// s->pict_type, best, s->qscale, s->mb_var_sum, s->mc_mb_var_sum, best_size); 335 336 if(s->pict_type==FF_P_TYPE) chroma_best= best; 337 338 memset(s->ac_stats, 0, sizeof(int)*(MAX_LEVEL+1)*(MAX_RUN+1)*2*2*2); 339 340 s->rl_table_index = best; 341 s->rl_chroma_table_index= chroma_best; 342 343 if(s->pict_type != s->last_non_b_pict_type){ 344 s->rl_table_index= 2; 345 if(s->pict_type==FF_I_TYPE) 346 s->rl_chroma_table_index= 1; 347 else 348 s->rl_chroma_table_index= 2; 349 } 350 351} 352 353/* write MSMPEG4 compatible frame header */ 354void msmpeg4_encode_picture_header(MpegEncContext * s, int picture_number) 355{ 356 find_best_tables(s); 357 358 align_put_bits(&s->pb); 359 put_bits(&s->pb, 2, s->pict_type - 1); 360 361 put_bits(&s->pb, 5, s->qscale); 362 if(s->msmpeg4_version<=2){ 363 s->rl_table_index = 2; 364 s->rl_chroma_table_index = 2; 365 } 366 367 s->dc_table_index = 1; 368 s->mv_table_index = 1; /* only if P frame */ 369 s->use_skip_mb_code = 1; /* only if P frame */ 370 s->per_mb_rl_table = 0; 371 if(s->msmpeg4_version==4) 372 s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE && s->pict_type==FF_P_TYPE); 373//printf("%d %d %d %d %d\n", s->pict_type, s->bit_rate, s->inter_intra_pred, s->width, s->height); 374 375 if (s->pict_type == FF_I_TYPE) { 376 s->slice_height= s->mb_height/1; 377 put_bits(&s->pb, 5, 0x16 + s->mb_height/s->slice_height); 378 379 if(s->msmpeg4_version==4){ 380 msmpeg4_encode_ext_header(s); 381 if(s->bit_rate>MBAC_BITRATE) 382 put_bits(&s->pb, 1, s->per_mb_rl_table); 383 } 384 385 if(s->msmpeg4_version>2){ 386 if(!s->per_mb_rl_table){ 387 ff_msmpeg4_code012(&s->pb, s->rl_chroma_table_index); 388 ff_msmpeg4_code012(&s->pb, s->rl_table_index); 389 } 390 391 put_bits(&s->pb, 1, s->dc_table_index); 392 } 393 } else { 394 put_bits(&s->pb, 1, s->use_skip_mb_code); 395 396 if(s->msmpeg4_version==4 && s->bit_rate>MBAC_BITRATE) 397 put_bits(&s->pb, 1, s->per_mb_rl_table); 398 399 if(s->msmpeg4_version>2){ 400 if(!s->per_mb_rl_table) 401 ff_msmpeg4_code012(&s->pb, s->rl_table_index); 402 403 put_bits(&s->pb, 1, s->dc_table_index); 404 405 put_bits(&s->pb, 1, s->mv_table_index); 406 } 407 } 408 409 s->esc3_level_length= 0; 410 s->esc3_run_length= 0; 411} 412 413void msmpeg4_encode_ext_header(MpegEncContext * s) 414{ 415 put_bits(&s->pb, 5, s->avctx->time_base.den / s->avctx->time_base.num); //yes 29.97 -> 29 416 417 put_bits(&s->pb, 11, FFMIN(s->bit_rate/1024, 2047)); 418 419 if(s->msmpeg4_version>=3) 420 put_bits(&s->pb, 1, s->flipflop_rounding); 421 else 422 assert(s->flipflop_rounding==0); 423} 424 425#endif //CONFIG_ENCODERS 426 427/* predict coded block */ 428int ff_msmpeg4_coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr) 429{ 430 int xy, wrap, pred, a, b, c; 431 432 xy = s->block_index[n]; 433 wrap = s->b8_stride; 434 435 /* B C 436 * A X 437 */ 438 a = s->coded_block[xy - 1 ]; 439 b = s->coded_block[xy - 1 - wrap]; 440 c = s->coded_block[xy - wrap]; 441 442 if (b == c) { 443 pred = a; 444 } else { 445 pred = c; 446 } 447 448 /* store value */ 449 *coded_block_ptr = &s->coded_block[xy]; 450 451 return pred; 452} 453 454#if CONFIG_ENCODERS 455 456void ff_msmpeg4_encode_motion(MpegEncContext * s, 457 int mx, int my) 458{ 459 int code; 460 MVTable *mv; 461 462 /* modulo encoding */ 463 /* WARNING : you cannot reach all the MVs even with the modulo 464 encoding. This is a somewhat strange compromise they took !!! */ 465 if (mx <= -64) 466 mx += 64; 467 else if (mx >= 64) 468 mx -= 64; 469 if (my <= -64) 470 my += 64; 471 else if (my >= 64) 472 my -= 64; 473 474 mx += 32; 475 my += 32; 476#if 0 477 if ((unsigned)mx >= 64 || 478 (unsigned)my >= 64) 479 av_log(s->avctx, AV_LOG_ERROR, "error mx=%d my=%d\n", mx, my); 480#endif 481 mv = &mv_tables[s->mv_table_index]; 482 483 code = mv->table_mv_index[(mx << 6) | my]; 484 put_bits(&s->pb, 485 mv->table_mv_bits[code], 486 mv->table_mv_code[code]); 487 if (code == mv->n) { 488 /* escape : code literally */ 489 put_bits(&s->pb, 6, mx); 490 put_bits(&s->pb, 6, my); 491 } 492} 493 494void ff_msmpeg4_handle_slices(MpegEncContext *s){ 495 if (s->mb_x == 0) { 496 if (s->slice_height && (s->mb_y % s->slice_height) == 0) { 497 if(s->msmpeg4_version < 4){ 498 ff_mpeg4_clean_buffers(s); 499 } 500 s->first_slice_line = 1; 501 } else { 502 s->first_slice_line = 0; 503 } 504 } 505} 506 507static void msmpeg4v2_encode_motion(MpegEncContext * s, int val) 508{ 509 int range, bit_size, sign, code, bits; 510 511 if (val == 0) { 512 /* zero vector */ 513 code = 0; 514 put_bits(&s->pb, mvtab[code][1], mvtab[code][0]); 515 } else { 516 bit_size = s->f_code - 1; 517 range = 1 << bit_size; 518 if (val <= -64) 519 val += 64; 520 else if (val >= 64) 521 val -= 64; 522 523 if (val >= 0) { 524 sign = 0; 525 } else { 526 val = -val; 527 sign = 1; 528 } 529 val--; 530 code = (val >> bit_size) + 1; 531 bits = val & (range - 1); 532 533 put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign); 534 if (bit_size > 0) { 535 put_bits(&s->pb, bit_size, bits); 536 } 537 } 538} 539 540void msmpeg4_encode_mb(MpegEncContext * s, 541 DCTELEM block[6][64], 542 int motion_x, int motion_y) 543{ 544 int cbp, coded_cbp, i; 545 int pred_x, pred_y; 546 uint8_t *coded_block; 547 548 ff_msmpeg4_handle_slices(s); 549 550 if (!s->mb_intra) { 551 /* compute cbp */ 552 cbp = 0; 553 for (i = 0; i < 6; i++) { 554 if (s->block_last_index[i] >= 0) 555 cbp |= 1 << (5 - i); 556 } 557 if (s->use_skip_mb_code && (cbp | motion_x | motion_y) == 0) { 558 /* skip macroblock */ 559 put_bits(&s->pb, 1, 1); 560 s->last_bits++; 561 s->misc_bits++; 562 s->skip_count++; 563 564 return; 565 } 566 if (s->use_skip_mb_code) 567 put_bits(&s->pb, 1, 0); /* mb coded */ 568 569 if(s->msmpeg4_version<=2){ 570 put_bits(&s->pb, 571 v2_mb_type[cbp&3][1], 572 v2_mb_type[cbp&3][0]); 573 if((cbp&3) != 3) coded_cbp= cbp ^ 0x3C; 574 else coded_cbp= cbp; 575 576 put_bits(&s->pb, 577 ff_h263_cbpy_tab[coded_cbp>>2][1], 578 ff_h263_cbpy_tab[coded_cbp>>2][0]); 579 580 s->misc_bits += get_bits_diff(s); 581 582 h263_pred_motion(s, 0, 0, &pred_x, &pred_y); 583 msmpeg4v2_encode_motion(s, motion_x - pred_x); 584 msmpeg4v2_encode_motion(s, motion_y - pred_y); 585 }else{ 586 put_bits(&s->pb, 587 table_mb_non_intra[cbp + 64][1], 588 table_mb_non_intra[cbp + 64][0]); 589 590 s->misc_bits += get_bits_diff(s); 591 592 /* motion vector */ 593 h263_pred_motion(s, 0, 0, &pred_x, &pred_y); 594 ff_msmpeg4_encode_motion(s, motion_x - pred_x, 595 motion_y - pred_y); 596 } 597 598 s->mv_bits += get_bits_diff(s); 599 600 for (i = 0; i < 6; i++) { 601 ff_msmpeg4_encode_block(s, block[i], i); 602 } 603 s->p_tex_bits += get_bits_diff(s); 604 } else { 605 /* compute cbp */ 606 cbp = 0; 607 coded_cbp = 0; 608 for (i = 0; i < 6; i++) { 609 int val, pred; 610 val = (s->block_last_index[i] >= 1); 611 cbp |= val << (5 - i); 612 if (i < 4) { 613 /* predict value for close blocks only for luma */ 614 pred = ff_msmpeg4_coded_block_pred(s, i, &coded_block); 615 *coded_block = val; 616 val = val ^ pred; 617 } 618 coded_cbp |= val << (5 - i); 619 } 620#if 0 621 if (coded_cbp) 622 printf("cbp=%x %x\n", cbp, coded_cbp); 623#endif 624 625 if(s->msmpeg4_version<=2){ 626 if (s->pict_type == FF_I_TYPE) { 627 put_bits(&s->pb, 628 v2_intra_cbpc[cbp&3][1], v2_intra_cbpc[cbp&3][0]); 629 } else { 630 if (s->use_skip_mb_code) 631 put_bits(&s->pb, 1, 0); /* mb coded */ 632 put_bits(&s->pb, 633 v2_mb_type[(cbp&3) + 4][1], 634 v2_mb_type[(cbp&3) + 4][0]); 635 } 636 put_bits(&s->pb, 1, 0); /* no AC prediction yet */ 637 put_bits(&s->pb, 638 ff_h263_cbpy_tab[cbp>>2][1], 639 ff_h263_cbpy_tab[cbp>>2][0]); 640 }else{ 641 if (s->pict_type == FF_I_TYPE) { 642 put_bits(&s->pb, 643 ff_msmp4_mb_i_table[coded_cbp][1], ff_msmp4_mb_i_table[coded_cbp][0]); 644 } else { 645 if (s->use_skip_mb_code) 646 put_bits(&s->pb, 1, 0); /* mb coded */ 647 put_bits(&s->pb, 648 table_mb_non_intra[cbp][1], 649 table_mb_non_intra[cbp][0]); 650 } 651 put_bits(&s->pb, 1, 0); /* no AC prediction yet */ 652 if(s->inter_intra_pred){ 653 s->h263_aic_dir=0; 654 put_bits(&s->pb, table_inter_intra[s->h263_aic_dir][1], table_inter_intra[s->h263_aic_dir][0]); 655 } 656 } 657 s->misc_bits += get_bits_diff(s); 658 659 for (i = 0; i < 6; i++) { 660 ff_msmpeg4_encode_block(s, block[i], i); 661 } 662 s->i_tex_bits += get_bits_diff(s); 663 s->i_count++; 664 } 665} 666 667#endif //CONFIG_ENCODERS 668 669static inline int msmpeg4v1_pred_dc(MpegEncContext * s, int n, 670 int32_t **dc_val_ptr) 671{ 672 int i; 673 674 if (n < 4) { 675 i= 0; 676 } else { 677 i= n-3; 678 } 679 680 *dc_val_ptr= &s->last_dc[i]; 681 return s->last_dc[i]; 682} 683 684static int get_dc(uint8_t *src, int stride, int scale) 685{ 686 int y; 687 int sum=0; 688 for(y=0; y<8; y++){ 689 int x; 690 for(x=0; x<8; x++){ 691 sum+=src[x + y*stride]; 692 } 693 } 694 return FASTDIV((sum + (scale>>1)), scale); 695} 696 697/* dir = 0: left, dir = 1: top prediction */ 698static inline int msmpeg4_pred_dc(MpegEncContext * s, int n, 699 int16_t **dc_val_ptr, int *dir_ptr) 700{ 701 int a, b, c, wrap, pred, scale; 702 int16_t *dc_val; 703 704 /* find prediction */ 705 if (n < 4) { 706 scale = s->y_dc_scale; 707 } else { 708 scale = s->c_dc_scale; 709 } 710 711 wrap = s->block_wrap[n]; 712 dc_val= s->dc_val[0] + s->block_index[n]; 713 714 /* B C 715 * A X 716 */ 717 a = dc_val[ - 1]; 718 b = dc_val[ - 1 - wrap]; 719 c = dc_val[ - wrap]; 720 721 if(s->first_slice_line && (n&2)==0 && s->msmpeg4_version<4){ 722 b=c=1024; 723 } 724 725 /* XXX: the following solution consumes divisions, but it does not 726 necessitate to modify mpegvideo.c. The problem comes from the 727 fact they decided to store the quantized DC (which would lead 728 to problems if Q could vary !) */ 729#if ARCH_X86 && HAVE_7REGS && HAVE_EBX_AVAILABLE 730 __asm__ volatile( 731 "movl %3, %%eax \n\t" 732 "shrl $1, %%eax \n\t" 733 "addl %%eax, %2 \n\t" 734 "addl %%eax, %1 \n\t" 735 "addl %0, %%eax \n\t" 736 "mull %4 \n\t" 737 "movl %%edx, %0 \n\t" 738 "movl %1, %%eax \n\t" 739 "mull %4 \n\t" 740 "movl %%edx, %1 \n\t" 741 "movl %2, %%eax \n\t" 742 "mull %4 \n\t" 743 "movl %%edx, %2 \n\t" 744 : "+b" (a), "+c" (b), "+D" (c) 745 : "g" (scale), "S" (ff_inverse[scale]) 746 : "%eax", "%edx" 747 ); 748#else 749 /* #elif ARCH_ALPHA */ 750 /* Divisions are extremely costly on Alpha; optimize the most 751 common case. But they are costly everywhere... 752 */ 753 if (scale == 8) { 754 a = (a + (8 >> 1)) / 8; 755 b = (b + (8 >> 1)) / 8; 756 c = (c + (8 >> 1)) / 8; 757 } else { 758 a = FASTDIV((a + (scale >> 1)), scale); 759 b = FASTDIV((b + (scale >> 1)), scale); 760 c = FASTDIV((c + (scale >> 1)), scale); 761 } 762#endif 763 /* XXX: WARNING: they did not choose the same test as MPEG4. This 764 is very important ! */ 765 if(s->msmpeg4_version>3){ 766 if(s->inter_intra_pred){ 767 uint8_t *dest; 768 int wrap; 769 770 if(n==1){ 771 pred=a; 772 *dir_ptr = 0; 773 }else if(n==2){ 774 pred=c; 775 *dir_ptr = 1; 776 }else if(n==3){ 777 if (abs(a - b) < abs(b - c)) { 778 pred = c; 779 *dir_ptr = 1; 780 } else { 781 pred = a; 782 *dir_ptr = 0; 783 } 784 }else{ 785 if(n<4){ 786 wrap= s->linesize; 787 dest= s->current_picture.data[0] + (((n>>1) + 2*s->mb_y) * 8* wrap ) + ((n&1) + 2*s->mb_x) * 8; 788 }else{ 789 wrap= s->uvlinesize; 790 dest= s->current_picture.data[n-3] + (s->mb_y * 8 * wrap) + s->mb_x * 8; 791 } 792 if(s->mb_x==0) a= (1024 + (scale>>1))/scale; 793 else a= get_dc(dest-8, wrap, scale*8); 794 if(s->mb_y==0) c= (1024 + (scale>>1))/scale; 795 else c= get_dc(dest-8*wrap, wrap, scale*8); 796 797 if (s->h263_aic_dir==0) { 798 pred= a; 799 *dir_ptr = 0; 800 }else if (s->h263_aic_dir==1) { 801 if(n==0){ 802 pred= c; 803 *dir_ptr = 1; 804 }else{ 805 pred= a; 806 *dir_ptr = 0; 807 } 808 }else if (s->h263_aic_dir==2) { 809 if(n==0){ 810 pred= a; 811 *dir_ptr = 0; 812 }else{ 813 pred= c; 814 *dir_ptr = 1; 815 } 816 } else { 817 pred= c; 818 *dir_ptr = 1; 819 } 820 } 821 }else{ 822 if (abs(a - b) < abs(b - c)) { 823 pred = c; 824 *dir_ptr = 1; 825 } else { 826 pred = a; 827 *dir_ptr = 0; 828 } 829 } 830 }else{ 831 if (abs(a - b) <= abs(b - c)) { 832 pred = c; 833 *dir_ptr = 1; 834 } else { 835 pred = a; 836 *dir_ptr = 0; 837 } 838 } 839 840 /* update predictor */ 841 *dc_val_ptr = &dc_val[0]; 842 return pred; 843} 844 845#define DC_MAX 119 846 847static void msmpeg4_encode_dc(MpegEncContext * s, int level, int n, int *dir_ptr) 848{ 849 int sign, code; 850 int pred, extquant; 851 int extrabits = 0; 852 853 if(s->msmpeg4_version==1){ 854 int32_t *dc_val; 855 pred = msmpeg4v1_pred_dc(s, n, &dc_val); 856 857 /* update predictor */ 858 *dc_val= level; 859 }else{ 860 int16_t *dc_val; 861 pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr); 862 863 /* update predictor */ 864 if (n < 4) { 865 *dc_val = level * s->y_dc_scale; 866 } else { 867 *dc_val = level * s->c_dc_scale; 868 } 869 } 870 871 /* do the prediction */ 872 level -= pred; 873 874 if(s->msmpeg4_version<=2){ 875 if (n < 4) { 876 put_bits(&s->pb, 877 v2_dc_lum_table[level+256][1], 878 v2_dc_lum_table[level+256][0]); 879 }else{ 880 put_bits(&s->pb, 881 v2_dc_chroma_table[level+256][1], 882 v2_dc_chroma_table[level+256][0]); 883 } 884 }else{ 885 sign = 0; 886 if (level < 0) { 887 level = -level; 888 sign = 1; 889 } 890 code = level; 891 if (code > DC_MAX) 892 code = DC_MAX; 893 else if( s->msmpeg4_version>=6 ) { 894 if( s->qscale == 1 ) { 895 extquant = (level + 3) & 0x3; 896 code = ((level+3)>>2); 897 } else if( s->qscale == 2 ) { 898 extquant = (level + 1) & 0x1; 899 code = ((level+1)>>1); 900 } 901 } 902 903 if (s->dc_table_index == 0) { 904 if (n < 4) { 905 put_bits(&s->pb, ff_table0_dc_lum[code][1], ff_table0_dc_lum[code][0]); 906 } else { 907 put_bits(&s->pb, ff_table0_dc_chroma[code][1], ff_table0_dc_chroma[code][0]); 908 } 909 } else { 910 if (n < 4) { 911 put_bits(&s->pb, ff_table1_dc_lum[code][1], ff_table1_dc_lum[code][0]); 912 } else { 913 put_bits(&s->pb, ff_table1_dc_chroma[code][1], ff_table1_dc_chroma[code][0]); 914 } 915 } 916 917 if(s->msmpeg4_version>=6 && s->qscale<=2) 918 extrabits = 3 - s->qscale; 919 920 if (code == DC_MAX) 921 put_bits(&s->pb, 8 + extrabits, level); 922 else if(extrabits > 0)//== VC1 && s->qscale<=2 923 put_bits(&s->pb, extrabits, extquant); 924 925 if (level != 0) { 926 put_bits(&s->pb, 1, sign); 927 } 928 } 929} 930 931/* Encoding of a block. Very similar to MPEG4 except for a different 932 escape coding (same as H263) and more vlc tables. 933 */ 934void ff_msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n) 935{ 936 int level, run, last, i, j, last_index; 937 int last_non_zero, sign, slevel; 938 int code, run_diff, dc_pred_dir; 939 const RLTable *rl; 940 const uint8_t *scantable; 941 942 if (s->mb_intra) { 943 msmpeg4_encode_dc(s, block[0], n, &dc_pred_dir); 944 i = 1; 945 if (n < 4) { 946 rl = &rl_table[s->rl_table_index]; 947 } else { 948 rl = &rl_table[3 + s->rl_chroma_table_index]; 949 } 950 run_diff = s->msmpeg4_version>=4; 951 scantable= s->intra_scantable.permutated; 952 } else { 953 i = 0; 954 rl = &rl_table[3 + s->rl_table_index]; 955 if(s->msmpeg4_version<=2) 956 run_diff = 0; 957 else 958 run_diff = 1; 959 scantable= s->inter_scantable.permutated; 960 } 961 962 /* recalculate block_last_index for M$ wmv1 */ 963 if(s->msmpeg4_version>=4 && s->msmpeg4_version<6 && s->block_last_index[n]>0){ 964 for(last_index=63; last_index>=0; last_index--){ 965 if(block[scantable[last_index]]) break; 966 } 967 s->block_last_index[n]= last_index; 968 }else 969 last_index = s->block_last_index[n]; 970 /* AC coefs */ 971 last_non_zero = i - 1; 972 for (; i <= last_index; i++) { 973 j = scantable[i]; 974 level = block[j]; 975 if (level) { 976 run = i - last_non_zero - 1; 977 last = (i == last_index); 978 sign = 0; 979 slevel = level; 980 if (level < 0) { 981 sign = 1; 982 level = -level; 983 } 984 985 if(level<=MAX_LEVEL && run<=MAX_RUN){ 986 s->ac_stats[s->mb_intra][n>3][level][run][last]++; 987 } 988#if 0 989else 990 s->ac_stats[s->mb_intra][n>3][40][63][0]++; //esc3 like 991#endif 992 code = get_rl_index(rl, last, run, level); 993 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); 994 if (code == rl->n) { 995 int level1, run1; 996 997 level1 = level - rl->max_level[last][run]; 998 if (level1 < 1) 999 goto esc2; 1000 code = get_rl_index(rl, last, run, level1); 1001 if (code == rl->n) { 1002 esc2: 1003 put_bits(&s->pb, 1, 0); 1004 if (level > MAX_LEVEL) 1005 goto esc3; 1006 run1 = run - rl->max_run[last][level] - run_diff; 1007 if (run1 < 0) 1008 goto esc3; 1009 code = get_rl_index(rl, last, run1+1, level); 1010 if (s->msmpeg4_version == 4 && code == rl->n) 1011 goto esc3; 1012 code = get_rl_index(rl, last, run1, level); 1013 if (code == rl->n) { 1014 esc3: 1015 /* third escape */ 1016 put_bits(&s->pb, 1, 0); 1017 put_bits(&s->pb, 1, last); 1018 if(s->msmpeg4_version>=4){ 1019 if(s->esc3_level_length==0){ 1020 s->esc3_level_length=8; 1021 s->esc3_run_length= 6; 1022 //ESCLVLSZ + ESCRUNSZ 1023 if(s->qscale<8) 1024 put_bits(&s->pb, 6 + (s->msmpeg4_version>=6), 3); 1025 else 1026 put_bits(&s->pb, 8, 3); 1027 } 1028 put_bits(&s->pb, s->esc3_run_length, run); 1029 put_bits(&s->pb, 1, sign); 1030 put_bits(&s->pb, s->esc3_level_length, level); 1031 }else{ 1032 put_bits(&s->pb, 6, run); 1033 put_sbits(&s->pb, 8, slevel); 1034 } 1035 } else { 1036 /* second escape */ 1037 put_bits(&s->pb, 1, 1); 1038 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); 1039 put_bits(&s->pb, 1, sign); 1040 } 1041 } else { 1042 /* first escape */ 1043 put_bits(&s->pb, 1, 1); 1044 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); 1045 put_bits(&s->pb, 1, sign); 1046 } 1047 } else { 1048 put_bits(&s->pb, 1, sign); 1049 } 1050 last_non_zero = i; 1051 } 1052 } 1053} 1054 1055/****************************************/ 1056/* decoding stuff */ 1057 1058VLC ff_mb_non_intra_vlc[4]; 1059static VLC v2_dc_lum_vlc; 1060static VLC v2_dc_chroma_vlc; 1061static VLC v2_intra_cbpc_vlc; 1062static VLC v2_mb_type_vlc; 1063static VLC v2_mv_vlc; 1064VLC ff_inter_intra_vlc; 1065 1066/* This is identical to h263 except that its range is multiplied by 2. */ 1067static int msmpeg4v2_decode_motion(MpegEncContext * s, int pred, int f_code) 1068{ 1069 int code, val, sign, shift; 1070 1071 code = get_vlc2(&s->gb, v2_mv_vlc.table, V2_MV_VLC_BITS, 2); 1072// printf("MV code %d at %d %d pred: %d\n", code, s->mb_x,s->mb_y, pred); 1073 if (code < 0) 1074 return 0xffff; 1075 1076 if (code == 0) 1077 return pred; 1078 sign = get_bits1(&s->gb); 1079 shift = f_code - 1; 1080 val = code; 1081 if (shift) { 1082 val = (val - 1) << shift; 1083 val |= get_bits(&s->gb, shift); 1084 val++; 1085 } 1086 if (sign) 1087 val = -val; 1088 1089 val += pred; 1090 if (val <= -64) 1091 val += 64; 1092 else if (val >= 64) 1093 val -= 64; 1094 1095 return val; 1096} 1097 1098static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64]) 1099{ 1100 int cbp, code, i; 1101 1102 if (s->pict_type == FF_P_TYPE) { 1103 if (s->use_skip_mb_code) { 1104 if (get_bits1(&s->gb)) { 1105 /* skip mb */ 1106 s->mb_intra = 0; 1107 for(i=0;i<6;i++) 1108 s->block_last_index[i] = -1; 1109 s->mv_dir = MV_DIR_FORWARD; 1110 s->mv_type = MV_TYPE_16X16; 1111 s->mv[0][0][0] = 0; 1112 s->mv[0][0][1] = 0; 1113 s->mb_skipped = 1; 1114 return 0; 1115 } 1116 } 1117 1118 if(s->msmpeg4_version==2) 1119 code = get_vlc2(&s->gb, v2_mb_type_vlc.table, V2_MB_TYPE_VLC_BITS, 1); 1120 else 1121 code = get_vlc2(&s->gb, ff_h263_inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2); 1122 if(code<0 || code>7){ 1123 av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", code, s->mb_x, s->mb_y); 1124 return -1; 1125 } 1126 1127 s->mb_intra = code >>2; 1128 1129 cbp = code & 0x3; 1130 } else { 1131 s->mb_intra = 1; 1132 if(s->msmpeg4_version==2) 1133 cbp= get_vlc2(&s->gb, v2_intra_cbpc_vlc.table, V2_INTRA_CBPC_VLC_BITS, 1); 1134 else 1135 cbp= get_vlc2(&s->gb, ff_h263_intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 1); 1136 if(cbp<0 || cbp>3){ 1137 av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y); 1138 return -1; 1139 } 1140 } 1141 1142 if (!s->mb_intra) { 1143 int mx, my, cbpy; 1144 1145 cbpy= get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1); 1146 if(cbpy<0){ 1147 av_log(s->avctx, AV_LOG_ERROR, "cbpy %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y); 1148 return -1; 1149 } 1150 1151 cbp|= cbpy<<2; 1152 if(s->msmpeg4_version==1 || (cbp&3) != 3) cbp^= 0x3C; 1153 1154 h263_pred_motion(s, 0, 0, &mx, &my); 1155 mx= msmpeg4v2_decode_motion(s, mx, 1); 1156 my= msmpeg4v2_decode_motion(s, my, 1); 1157 1158 s->mv_dir = MV_DIR_FORWARD; 1159 s->mv_type = MV_TYPE_16X16; 1160 s->mv[0][0][0] = mx; 1161 s->mv[0][0][1] = my; 1162 } else { 1163 if(s->msmpeg4_version==2){ 1164 s->ac_pred = get_bits1(&s->gb); 1165 cbp|= get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors 1166 } else{ 1167 s->ac_pred = 0; 1168 cbp|= get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors 1169 if(s->pict_type==FF_P_TYPE) cbp^=0x3C; 1170 } 1171 } 1172 1173 s->dsp.clear_blocks(s->block[0]); 1174 for (i = 0; i < 6; i++) { 1175 if (ff_msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0) 1176 { 1177 av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i); 1178 return -1; 1179 } 1180 } 1181 return 0; 1182} 1183 1184static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64]) 1185{ 1186 int cbp, code, i; 1187 uint8_t *coded_val; 1188 uint32_t * const mb_type_ptr= &s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ]; 1189 1190 if (s->pict_type == FF_P_TYPE) { 1191 if (s->use_skip_mb_code) { 1192 if (get_bits1(&s->gb)) { 1193 /* skip mb */ 1194 s->mb_intra = 0; 1195 for(i=0;i<6;i++) 1196 s->block_last_index[i] = -1; 1197 s->mv_dir = MV_DIR_FORWARD; 1198 s->mv_type = MV_TYPE_16X16; 1199 s->mv[0][0][0] = 0; 1200 s->mv[0][0][1] = 0; 1201 s->mb_skipped = 1; 1202 *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16; 1203 1204 return 0; 1205 } 1206 } 1207 1208 code = get_vlc2(&s->gb, ff_mb_non_intra_vlc[DEFAULT_INTER_INDEX].table, MB_NON_INTRA_VLC_BITS, 3); 1209 if (code < 0) 1210 return -1; 1211 //s->mb_intra = (code & 0x40) ? 0 : 1; 1212 s->mb_intra = (~code & 0x40) >> 6; 1213 1214 cbp = code & 0x3f; 1215 } else { 1216 s->mb_intra = 1; 1217 code = get_vlc2(&s->gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2); 1218 if (code < 0) 1219 return -1; 1220 /* predict coded block pattern */ 1221 cbp = 0; 1222 for(i=0;i<6;i++) { 1223 int val = ((code >> (5 - i)) & 1); 1224 if (i < 4) { 1225 int pred = ff_msmpeg4_coded_block_pred(s, i, &coded_val); 1226 val = val ^ pred; 1227 *coded_val = val; 1228 } 1229 cbp |= val << (5 - i); 1230 } 1231 } 1232 1233 if (!s->mb_intra) { 1234 int mx, my; 1235//printf("P at %d %d\n", s->mb_x, s->mb_y); 1236 if(s->per_mb_rl_table && cbp){ 1237 s->rl_table_index = decode012(&s->gb); 1238 s->rl_chroma_table_index = s->rl_table_index; 1239 } 1240 h263_pred_motion(s, 0, 0, &mx, &my); 1241 if (ff_msmpeg4_decode_motion(s, &mx, &my) < 0) 1242 return -1; 1243 s->mv_dir = MV_DIR_FORWARD; 1244 s->mv_type = MV_TYPE_16X16; 1245 s->mv[0][0][0] = mx; 1246 s->mv[0][0][1] = my; 1247 *mb_type_ptr = MB_TYPE_L0 | MB_TYPE_16x16; 1248 } else { 1249//printf("I at %d %d %d %06X\n", s->mb_x, s->mb_y, ((cbp&3)? 1 : 0) +((cbp&0x3C)? 2 : 0), show_bits(&s->gb, 24)); 1250 s->ac_pred = get_bits1(&s->gb); 1251 *mb_type_ptr = MB_TYPE_INTRA; 1252 if(s->inter_intra_pred){ 1253 s->h263_aic_dir= get_vlc2(&s->gb, ff_inter_intra_vlc.table, INTER_INTRA_VLC_BITS, 1); 1254// printf("%d%d %d %d/", s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y); 1255 } 1256 if(s->per_mb_rl_table && cbp){ 1257 s->rl_table_index = decode012(&s->gb); 1258 s->rl_chroma_table_index = s->rl_table_index; 1259 } 1260 } 1261 1262 s->dsp.clear_blocks(s->block[0]); 1263 for (i = 0; i < 6; i++) { 1264 if (ff_msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0) 1265 { 1266 av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i); 1267 return -1; 1268 } 1269 } 1270 1271 return 0; 1272} 1273 1274/* init all vlc decoding tables */ 1275av_cold int ff_msmpeg4_decode_init(AVCodecContext *avctx) 1276{ 1277 MpegEncContext *s = avctx->priv_data; 1278 static int done = 0; 1279 int i; 1280 MVTable *mv; 1281 1282 ff_h263_decode_init(avctx); 1283 1284 common_init(s); 1285 1286 if (!done) { 1287 done = 1; 1288 1289 for(i=0;i<NB_RL_TABLES;i++) { 1290 init_rl(&rl_table[i], static_rl_table_store[i]); 1291 } 1292 INIT_VLC_RL(rl_table[0], 642); 1293 INIT_VLC_RL(rl_table[1], 1104); 1294 INIT_VLC_RL(rl_table[2], 554); 1295 INIT_VLC_RL(rl_table[3], 940); 1296 INIT_VLC_RL(rl_table[4], 962); 1297 INIT_VLC_RL(rl_table[5], 554); 1298 1299 mv = &mv_tables[0]; 1300 INIT_VLC_STATIC(&mv->vlc, MV_VLC_BITS, mv->n + 1, 1301 mv->table_mv_bits, 1, 1, 1302 mv->table_mv_code, 2, 2, 3714); 1303 mv = &mv_tables[1]; 1304 INIT_VLC_STATIC(&mv->vlc, MV_VLC_BITS, mv->n + 1, 1305 mv->table_mv_bits, 1, 1, 1306 mv->table_mv_code, 2, 2, 2694); 1307 1308 INIT_VLC_STATIC(&ff_msmp4_dc_luma_vlc[0], DC_VLC_BITS, 120, 1309 &ff_table0_dc_lum[0][1], 8, 4, 1310 &ff_table0_dc_lum[0][0], 8, 4, 1158); 1311 INIT_VLC_STATIC(&ff_msmp4_dc_chroma_vlc[0], DC_VLC_BITS, 120, 1312 &ff_table0_dc_chroma[0][1], 8, 4, 1313 &ff_table0_dc_chroma[0][0], 8, 4, 1118); 1314 INIT_VLC_STATIC(&ff_msmp4_dc_luma_vlc[1], DC_VLC_BITS, 120, 1315 &ff_table1_dc_lum[0][1], 8, 4, 1316 &ff_table1_dc_lum[0][0], 8, 4, 1476); 1317 INIT_VLC_STATIC(&ff_msmp4_dc_chroma_vlc[1], DC_VLC_BITS, 120, 1318 &ff_table1_dc_chroma[0][1], 8, 4, 1319 &ff_table1_dc_chroma[0][0], 8, 4, 1216); 1320 1321 INIT_VLC_STATIC(&v2_dc_lum_vlc, DC_VLC_BITS, 512, 1322 &v2_dc_lum_table[0][1], 8, 4, 1323 &v2_dc_lum_table[0][0], 8, 4, 1472); 1324 INIT_VLC_STATIC(&v2_dc_chroma_vlc, DC_VLC_BITS, 512, 1325 &v2_dc_chroma_table[0][1], 8, 4, 1326 &v2_dc_chroma_table[0][0], 8, 4, 1506); 1327 1328 INIT_VLC_STATIC(&v2_intra_cbpc_vlc, V2_INTRA_CBPC_VLC_BITS, 4, 1329 &v2_intra_cbpc[0][1], 2, 1, 1330 &v2_intra_cbpc[0][0], 2, 1, 8); 1331 INIT_VLC_STATIC(&v2_mb_type_vlc, V2_MB_TYPE_VLC_BITS, 8, 1332 &v2_mb_type[0][1], 2, 1, 1333 &v2_mb_type[0][0], 2, 1, 128); 1334 INIT_VLC_STATIC(&v2_mv_vlc, V2_MV_VLC_BITS, 33, 1335 &mvtab[0][1], 2, 1, 1336 &mvtab[0][0], 2, 1, 538); 1337 1338 INIT_VLC_STATIC(&ff_mb_non_intra_vlc[0], MB_NON_INTRA_VLC_BITS, 128, 1339 &wmv2_inter_table[0][0][1], 8, 4, 1340 &wmv2_inter_table[0][0][0], 8, 4, 1636); 1341 INIT_VLC_STATIC(&ff_mb_non_intra_vlc[1], MB_NON_INTRA_VLC_BITS, 128, 1342 &wmv2_inter_table[1][0][1], 8, 4, 1343 &wmv2_inter_table[1][0][0], 8, 4, 2648); 1344 INIT_VLC_STATIC(&ff_mb_non_intra_vlc[2], MB_NON_INTRA_VLC_BITS, 128, 1345 &wmv2_inter_table[2][0][1], 8, 4, 1346 &wmv2_inter_table[2][0][0], 8, 4, 1532); 1347 INIT_VLC_STATIC(&ff_mb_non_intra_vlc[3], MB_NON_INTRA_VLC_BITS, 128, 1348 &wmv2_inter_table[3][0][1], 8, 4, 1349 &wmv2_inter_table[3][0][0], 8, 4, 2488); 1350 1351 INIT_VLC_STATIC(&ff_msmp4_mb_i_vlc, MB_INTRA_VLC_BITS, 64, 1352 &ff_msmp4_mb_i_table[0][1], 4, 2, 1353 &ff_msmp4_mb_i_table[0][0], 4, 2, 536); 1354 1355 INIT_VLC_STATIC(&ff_inter_intra_vlc, INTER_INTRA_VLC_BITS, 4, 1356 &table_inter_intra[0][1], 2, 1, 1357 &table_inter_intra[0][0], 2, 1, 8); 1358 } 1359 1360 switch(s->msmpeg4_version){ 1361 case 1: 1362 case 2: 1363 s->decode_mb= msmpeg4v12_decode_mb; 1364 break; 1365 case 3: 1366 case 4: 1367 s->decode_mb= msmpeg4v34_decode_mb; 1368 break; 1369 case 5: 1370 if (CONFIG_WMV2_DECODER) 1371 s->decode_mb= ff_wmv2_decode_mb; 1372 case 6: 1373 //FIXME + TODO VC1 decode mb 1374 break; 1375 } 1376 1377 s->slice_height= s->mb_height; //to avoid 1/0 if the first frame is not a keyframe 1378 1379 return 0; 1380} 1381 1382int msmpeg4_decode_picture_header(MpegEncContext * s) 1383{ 1384 int code; 1385 1386#if 0 1387{ 1388int i; 1389for(i=0; i<s->gb.size_in_bits; i++) 1390 av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb)); 1391// get_bits1(&s->gb); 1392av_log(s->avctx, AV_LOG_DEBUG, "END\n"); 1393return -1; 1394} 1395#endif 1396 1397 if(s->msmpeg4_version==1){ 1398 int start_code; 1399 start_code = (get_bits(&s->gb, 16)<<16) | get_bits(&s->gb, 16); 1400 if(start_code!=0x00000100){ 1401 av_log(s->avctx, AV_LOG_ERROR, "invalid startcode\n"); 1402 return -1; 1403 } 1404 1405 skip_bits(&s->gb, 5); // frame number */ 1406 } 1407 1408 s->pict_type = get_bits(&s->gb, 2) + 1; 1409 if (s->pict_type != FF_I_TYPE && 1410 s->pict_type != FF_P_TYPE){ 1411 av_log(s->avctx, AV_LOG_ERROR, "invalid picture type\n"); 1412 return -1; 1413 } 1414#if 0 1415{ 1416 static int had_i=0; 1417 if(s->pict_type == FF_I_TYPE) had_i=1; 1418 if(!had_i) return -1; 1419} 1420#endif 1421 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5); 1422 if(s->qscale==0){ 1423 av_log(s->avctx, AV_LOG_ERROR, "invalid qscale\n"); 1424 return -1; 1425 } 1426 1427 if (s->pict_type == FF_I_TYPE) { 1428 code = get_bits(&s->gb, 5); 1429 if(s->msmpeg4_version==1){ 1430 if(code==0 || code>s->mb_height){ 1431 av_log(s->avctx, AV_LOG_ERROR, "invalid slice height %d\n", code); 1432 return -1; 1433 } 1434 1435 s->slice_height = code; 1436 }else{ 1437 /* 0x17: one slice, 0x18: two slices, ... */ 1438 if (code < 0x17){ 1439 av_log(s->avctx, AV_LOG_ERROR, "error, slice code was %X\n", code); 1440 return -1; 1441 } 1442 1443 s->slice_height = s->mb_height / (code - 0x16); 1444 } 1445 1446 switch(s->msmpeg4_version){ 1447 case 1: 1448 case 2: 1449 s->rl_chroma_table_index = 2; 1450 s->rl_table_index = 2; 1451 1452 s->dc_table_index = 0; //not used 1453 break; 1454 case 3: 1455 s->rl_chroma_table_index = decode012(&s->gb); 1456 s->rl_table_index = decode012(&s->gb); 1457 1458 s->dc_table_index = get_bits1(&s->gb); 1459 break; 1460 case 4: 1461 msmpeg4_decode_ext_header(s, (2+5+5+17+7)/8); 1462 1463 if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb); 1464 else s->per_mb_rl_table= 0; 1465 1466 if(!s->per_mb_rl_table){ 1467 s->rl_chroma_table_index = decode012(&s->gb); 1468 s->rl_table_index = decode012(&s->gb); 1469 } 1470 1471 s->dc_table_index = get_bits1(&s->gb); 1472 s->inter_intra_pred= 0; 1473 break; 1474 } 1475 s->no_rounding = 1; 1476 if(s->avctx->debug&FF_DEBUG_PICT_INFO) 1477 av_log(s->avctx, AV_LOG_DEBUG, "qscale:%d rlc:%d rl:%d dc:%d mbrl:%d slice:%d \n", 1478 s->qscale, 1479 s->rl_chroma_table_index, 1480 s->rl_table_index, 1481 s->dc_table_index, 1482 s->per_mb_rl_table, 1483 s->slice_height); 1484 } else { 1485 switch(s->msmpeg4_version){ 1486 case 1: 1487 case 2: 1488 if(s->msmpeg4_version==1) 1489 s->use_skip_mb_code = 1; 1490 else 1491 s->use_skip_mb_code = get_bits1(&s->gb); 1492 s->rl_table_index = 2; 1493 s->rl_chroma_table_index = s->rl_table_index; 1494 s->dc_table_index = 0; //not used 1495 s->mv_table_index = 0; 1496 break; 1497 case 3: 1498 s->use_skip_mb_code = get_bits1(&s->gb); 1499 s->rl_table_index = decode012(&s->gb); 1500 s->rl_chroma_table_index = s->rl_table_index; 1501 1502 s->dc_table_index = get_bits1(&s->gb); 1503 1504 s->mv_table_index = get_bits1(&s->gb); 1505 break; 1506 case 4: 1507 s->use_skip_mb_code = get_bits1(&s->gb); 1508 1509 if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb); 1510 else s->per_mb_rl_table= 0; 1511 1512 if(!s->per_mb_rl_table){ 1513 s->rl_table_index = decode012(&s->gb); 1514 s->rl_chroma_table_index = s->rl_table_index; 1515 } 1516 1517 s->dc_table_index = get_bits1(&s->gb); 1518 1519 s->mv_table_index = get_bits1(&s->gb); 1520 s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE); 1521 break; 1522 } 1523 1524 if(s->avctx->debug&FF_DEBUG_PICT_INFO) 1525 av_log(s->avctx, AV_LOG_DEBUG, "skip:%d rl:%d rlc:%d dc:%d mv:%d mbrl:%d qp:%d \n", 1526 s->use_skip_mb_code, 1527 s->rl_table_index, 1528 s->rl_chroma_table_index, 1529 s->dc_table_index, 1530 s->mv_table_index, 1531 s->per_mb_rl_table, 1532 s->qscale); 1533 1534 if(s->flipflop_rounding){ 1535 s->no_rounding ^= 1; 1536 }else{ 1537 s->no_rounding = 0; 1538 } 1539 } 1540//printf("%d %d %d %d %d\n", s->pict_type, s->bit_rate, s->inter_intra_pred, s->width, s->height); 1541 1542 s->esc3_level_length= 0; 1543 s->esc3_run_length= 0; 1544 1545 return 0; 1546} 1547 1548int msmpeg4_decode_ext_header(MpegEncContext * s, int buf_size) 1549{ 1550 int left= buf_size*8 - get_bits_count(&s->gb); 1551 int length= s->msmpeg4_version>=3 ? 17 : 16; 1552 /* the alt_bitstream reader could read over the end so we need to check it */ 1553 if(left>=length && left<length+8) 1554 { 1555 int fps; 1556 1557 fps= get_bits(&s->gb, 5); 1558 s->bit_rate= get_bits(&s->gb, 11)*1024; 1559 if(s->msmpeg4_version>=3) 1560 s->flipflop_rounding= get_bits1(&s->gb); 1561 else 1562 s->flipflop_rounding= 0; 1563 1564// printf("fps:%2d bps:%2d roundingType:%1d\n", fps, s->bit_rate/1024, s->flipflop_rounding); 1565 } 1566 else if(left<length+8) 1567 { 1568 s->flipflop_rounding= 0; 1569 if(s->msmpeg4_version != 2) 1570 av_log(s->avctx, AV_LOG_ERROR, "ext header missing, %d left\n", left); 1571 } 1572 else 1573 { 1574 av_log(s->avctx, AV_LOG_ERROR, "I frame too long, ignoring ext header\n"); 1575 } 1576 1577 return 0; 1578} 1579 1580static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr) 1581{ 1582 int level, pred; 1583 1584 if(s->msmpeg4_version<=2){ 1585 if (n < 4) { 1586 level = get_vlc2(&s->gb, v2_dc_lum_vlc.table, DC_VLC_BITS, 3); 1587 } else { 1588 level = get_vlc2(&s->gb, v2_dc_chroma_vlc.table, DC_VLC_BITS, 3); 1589 } 1590 if (level < 0) 1591 return -1; 1592 level-=256; 1593 }else{ //FIXME optimize use unified tables & index 1594 if (n < 4) { 1595 level = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3); 1596 } else { 1597 level = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3); 1598 } 1599 if (level < 0){ 1600 av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n"); 1601 return -1; 1602 } 1603 1604 if (level == DC_MAX) { 1605 level = get_bits(&s->gb, 8); 1606 if (get_bits1(&s->gb)) 1607 level = -level; 1608 } else if (level != 0) { 1609 if (get_bits1(&s->gb)) 1610 level = -level; 1611 } 1612 } 1613 1614 if(s->msmpeg4_version==1){ 1615 int32_t *dc_val; 1616 pred = msmpeg4v1_pred_dc(s, n, &dc_val); 1617 level += pred; 1618 1619 /* update predictor */ 1620 *dc_val= level; 1621 }else{ 1622 int16_t *dc_val; 1623 pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr); 1624 level += pred; 1625 1626 /* update predictor */ 1627 if (n < 4) { 1628 *dc_val = level * s->y_dc_scale; 1629 } else { 1630 *dc_val = level * s->c_dc_scale; 1631 } 1632 } 1633 1634 return level; 1635} 1636 1637//#define ERROR_DETAILS 1638int ff_msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block, 1639 int n, int coded, const uint8_t *scan_table) 1640{ 1641 int level, i, last, run, run_diff; 1642 int av_uninit(dc_pred_dir); 1643 RLTable *rl; 1644 RL_VLC_ELEM *rl_vlc; 1645 int qmul, qadd; 1646 1647 if (s->mb_intra) { 1648 qmul=1; 1649 qadd=0; 1650 1651 /* DC coef */ 1652 level = msmpeg4_decode_dc(s, n, &dc_pred_dir); 1653 1654 if (level < 0){ 1655 av_log(s->avctx, AV_LOG_ERROR, "dc overflow- block: %d qscale: %d//\n", n, s->qscale); 1656 if(s->inter_intra_pred) level=0; 1657 else return -1; 1658 } 1659 if (n < 4) { 1660 rl = &rl_table[s->rl_table_index]; 1661 if(level > 256*s->y_dc_scale){ 1662 av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ L qscale: %d//\n", s->qscale); 1663 if(!s->inter_intra_pred) return -1; 1664 } 1665 } else { 1666 rl = &rl_table[3 + s->rl_chroma_table_index]; 1667 if(level > 256*s->c_dc_scale){ 1668 av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ C qscale: %d//\n", s->qscale); 1669 if(!s->inter_intra_pred) return -1; 1670 } 1671 } 1672 block[0] = level; 1673 1674 run_diff = s->msmpeg4_version >= 4; 1675 i = 0; 1676 if (!coded) { 1677 goto not_coded; 1678 } 1679 if (s->ac_pred) { 1680 if (dc_pred_dir == 0) 1681 scan_table = s->intra_v_scantable.permutated; /* left */ 1682 else 1683 scan_table = s->intra_h_scantable.permutated; /* top */ 1684 } else { 1685 scan_table = s->intra_scantable.permutated; 1686 } 1687 rl_vlc= rl->rl_vlc[0]; 1688 } else { 1689 qmul = s->qscale << 1; 1690 qadd = (s->qscale - 1) | 1; 1691 i = -1; 1692 rl = &rl_table[3 + s->rl_table_index]; 1693 1694 if(s->msmpeg4_version==2) 1695 run_diff = 0; 1696 else 1697 run_diff = 1; 1698 1699 if (!coded) { 1700 s->block_last_index[n] = i; 1701 return 0; 1702 } 1703 if(!scan_table) 1704 scan_table = s->inter_scantable.permutated; 1705 rl_vlc= rl->rl_vlc[s->qscale]; 1706 } 1707 { 1708 OPEN_READER(re, &s->gb); 1709 for(;;) { 1710 UPDATE_CACHE(re, &s->gb); 1711 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0); 1712 if (level==0) { 1713 int cache; 1714 cache= GET_CACHE(re, &s->gb); 1715 /* escape */ 1716 if (s->msmpeg4_version==1 || (cache&0x80000000)==0) { 1717 if (s->msmpeg4_version==1 || (cache&0x40000000)==0) { 1718 /* third escape */ 1719 if(s->msmpeg4_version!=1) LAST_SKIP_BITS(re, &s->gb, 2); 1720 UPDATE_CACHE(re, &s->gb); 1721 if(s->msmpeg4_version<=3){ 1722 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1); 1723 run= SHOW_UBITS(re, &s->gb, 6); SKIP_CACHE(re, &s->gb, 6); 1724 level= SHOW_SBITS(re, &s->gb, 8); LAST_SKIP_CACHE(re, &s->gb, 8); 1725 SKIP_COUNTER(re, &s->gb, 1+6+8); 1726 }else{ 1727 int sign; 1728 last= SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1); 1729 if(!s->esc3_level_length){ 1730 int ll; 1731 //printf("ESC-3 %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y); 1732 if(s->qscale<8){ 1733 ll= SHOW_UBITS(re, &s->gb, 3); SKIP_BITS(re, &s->gb, 3); 1734 if(ll==0){ 1735 ll= 8+SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1); 1736 } 1737 }else{ 1738 ll=2; 1739 while(ll<8 && SHOW_UBITS(re, &s->gb, 1)==0){ 1740 ll++; 1741 SKIP_BITS(re, &s->gb, 1); 1742 } 1743 if(ll<8) SKIP_BITS(re, &s->gb, 1); 1744 } 1745 1746 s->esc3_level_length= ll; 1747 s->esc3_run_length= SHOW_UBITS(re, &s->gb, 2) + 3; SKIP_BITS(re, &s->gb, 2); 1748//printf("level length:%d, run length: %d\n", ll, s->esc3_run_length); 1749 UPDATE_CACHE(re, &s->gb); 1750 } 1751 run= SHOW_UBITS(re, &s->gb, s->esc3_run_length); 1752 SKIP_BITS(re, &s->gb, s->esc3_run_length); 1753 1754 sign= SHOW_UBITS(re, &s->gb, 1); 1755 SKIP_BITS(re, &s->gb, 1); 1756 1757 level= SHOW_UBITS(re, &s->gb, s->esc3_level_length); 1758 SKIP_BITS(re, &s->gb, s->esc3_level_length); 1759 if(sign) level= -level; 1760 } 1761//printf("level: %d, run: %d at %d %d\n", level, run, s->mb_x, s->mb_y); 1762#if 0 // waste of time / this will detect very few errors 1763 { 1764 const int abs_level= FFABS(level); 1765 const int run1= run - rl->max_run[last][abs_level] - run_diff; 1766 if(abs_level<=MAX_LEVEL && run<=MAX_RUN){ 1767 if(abs_level <= rl->max_level[last][run]){ 1768 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n"); 1769 return DECODING_AC_LOST; 1770 } 1771 if(abs_level <= rl->max_level[last][run]*2){ 1772 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\n"); 1773 return DECODING_AC_LOST; 1774 } 1775 if(run1>=0 && abs_level <= rl->max_level[last][run1]){ 1776 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\n"); 1777 return DECODING_AC_LOST; 1778 } 1779 } 1780 } 1781#endif 1782 //level = level * qmul + (level>0) * qadd - (level<=0) * qadd ; 1783 if (level>0) level= level * qmul + qadd; 1784 else level= level * qmul - qadd; 1785#if 0 // waste of time too :( 1786 if(level>2048 || level<-2048){ 1787 av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc\n"); 1788 return DECODING_AC_LOST; 1789 } 1790#endif 1791 i+= run + 1; 1792 if(last) i+=192; 1793#ifdef ERROR_DETAILS 1794 if(run==66) 1795 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC3 level=%d\n", level); 1796 else if((i>62 && i<192) || i>192+63) 1797 av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC3 i=%d run=%d level=%d\n", i, run, level); 1798#endif 1799 } else { 1800 /* second escape */ 1801#if MIN_CACHE_BITS < 23 1802 LAST_SKIP_BITS(re, &s->gb, 2); 1803 UPDATE_CACHE(re, &s->gb); 1804#else 1805 SKIP_BITS(re, &s->gb, 2); 1806#endif 1807 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1); 1808 i+= run + rl->max_run[run>>7][level/qmul] + run_diff; //FIXME opt indexing 1809 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); 1810 LAST_SKIP_BITS(re, &s->gb, 1); 1811#ifdef ERROR_DETAILS 1812 if(run==66) 1813 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC2 level=%d\n", level); 1814 else if((i>62 && i<192) || i>192+63) 1815 av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC2 i=%d run=%d level=%d\n", i, run, level); 1816#endif 1817 } 1818 } else { 1819 /* first escape */ 1820#if MIN_CACHE_BITS < 22 1821 LAST_SKIP_BITS(re, &s->gb, 1); 1822 UPDATE_CACHE(re, &s->gb); 1823#else 1824 SKIP_BITS(re, &s->gb, 1); 1825#endif 1826 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1); 1827 i+= run; 1828 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing 1829 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); 1830 LAST_SKIP_BITS(re, &s->gb, 1); 1831#ifdef ERROR_DETAILS 1832 if(run==66) 1833 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC1 level=%d\n", level); 1834 else if((i>62 && i<192) || i>192+63) 1835 av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC1 i=%d run=%d level=%d\n", i, run, level); 1836#endif 1837 } 1838 } else { 1839 i+= run; 1840 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); 1841 LAST_SKIP_BITS(re, &s->gb, 1); 1842#ifdef ERROR_DETAILS 1843 if(run==66) 1844 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code level=%d\n", level); 1845 else if((i>62 && i<192) || i>192+63) 1846 av_log(s->avctx, AV_LOG_ERROR, "run overflow i=%d run=%d level=%d\n", i, run, level); 1847#endif 1848 } 1849 if (i > 62){ 1850 i-= 192; 1851 if(i&(~63)){ 1852 const int left= get_bits_left(&s->gb); 1853 if(((i+192 == 64 && level/qmul==-1) || s->error_recognition<=1) && left>=0){ 1854 av_log(s->avctx, AV_LOG_ERROR, "ignoring overflow at %d %d\n", s->mb_x, s->mb_y); 1855 break; 1856 }else{ 1857 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y); 1858 return -1; 1859 } 1860 } 1861 1862 block[scan_table[i]] = level; 1863 break; 1864 } 1865 1866 block[scan_table[i]] = level; 1867 } 1868 CLOSE_READER(re, &s->gb); 1869 } 1870 not_coded: 1871 if (s->mb_intra) { 1872 mpeg4_pred_ac(s, block, n, dc_pred_dir); 1873 if (s->ac_pred) { 1874 i = 63; /* XXX: not optimal */ 1875 } 1876 } 1877 if(s->msmpeg4_version>=4 && i>0) i=63; //FIXME/XXX optimize 1878 s->block_last_index[n] = i; 1879 1880 return 0; 1881} 1882 1883int ff_msmpeg4_decode_motion(MpegEncContext * s, 1884 int *mx_ptr, int *my_ptr) 1885{ 1886 MVTable *mv; 1887 int code, mx, my; 1888 1889 mv = &mv_tables[s->mv_table_index]; 1890 1891 code = get_vlc2(&s->gb, mv->vlc.table, MV_VLC_BITS, 2); 1892 if (code < 0){ 1893 av_log(s->avctx, AV_LOG_ERROR, "illegal MV code at %d %d\n", s->mb_x, s->mb_y); 1894 return -1; 1895 } 1896 if (code == mv->n) { 1897//printf("MV ESC %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y); 1898 mx = get_bits(&s->gb, 6); 1899 my = get_bits(&s->gb, 6); 1900 } else { 1901 mx = mv->table_mvx[code]; 1902 my = mv->table_mvy[code]; 1903 } 1904 1905 mx += *mx_ptr - 32; 1906 my += *my_ptr - 32; 1907 /* WARNING : they do not do exactly modulo encoding */ 1908 if (mx <= -64) 1909 mx += 64; 1910 else if (mx >= 64) 1911 mx -= 64; 1912 1913 if (my <= -64) 1914 my += 64; 1915 else if (my >= 64) 1916 my -= 64; 1917 *mx_ptr = mx; 1918 *my_ptr = my; 1919 return 0; 1920} 1921 1922AVCodec msmpeg4v1_decoder = { 1923 "msmpeg4v1", 1924 AVMEDIA_TYPE_VIDEO, 1925 CODEC_ID_MSMPEG4V1, 1926 sizeof(MpegEncContext), 1927 ff_msmpeg4_decode_init, 1928 NULL, 1929 ff_h263_decode_end, 1930 ff_h263_decode_frame, 1931 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1, 1932 .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 1"), 1933 .pix_fmts= ff_pixfmt_list_420, 1934}; 1935 1936AVCodec msmpeg4v2_decoder = { 1937 "msmpeg4v2", 1938 AVMEDIA_TYPE_VIDEO, 1939 CODEC_ID_MSMPEG4V2, 1940 sizeof(MpegEncContext), 1941 ff_msmpeg4_decode_init, 1942 NULL, 1943 ff_h263_decode_end, 1944 ff_h263_decode_frame, 1945 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1, 1946 .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"), 1947 .pix_fmts= ff_pixfmt_list_420, 1948}; 1949 1950AVCodec msmpeg4v3_decoder = { 1951 "msmpeg4", 1952 AVMEDIA_TYPE_VIDEO, 1953 CODEC_ID_MSMPEG4V3, 1954 sizeof(MpegEncContext), 1955 ff_msmpeg4_decode_init, 1956 NULL, 1957 ff_h263_decode_end, 1958 ff_h263_decode_frame, 1959 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1, 1960 .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"), 1961 .pix_fmts= ff_pixfmt_list_420, 1962}; 1963 1964AVCodec wmv1_decoder = { 1965 "wmv1", 1966 AVMEDIA_TYPE_VIDEO, 1967 CODEC_ID_WMV1, 1968 sizeof(MpegEncContext), 1969 ff_msmpeg4_decode_init, 1970 NULL, 1971 ff_h263_decode_end, 1972 ff_h263_decode_frame, 1973 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1, 1974 .long_name= NULL_IF_CONFIG_SMALL("Windows Media Video 7"), 1975 .pix_fmts= ff_pixfmt_list_420, 1976}; 1977