1/* 2 * MSMPEG4 backend for encoder and decoder 3 * Copyright (c) 2001 Fabrice Bellard 4 * Copyright (c) 2002-2013 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#include "config_components.h" 26 27#include "libavutil/thread.h" 28 29#include "avcodec.h" 30#include "codec_internal.h" 31#include "mpegutils.h" 32#include "mpegvideo.h" 33#include "msmpeg4.h" 34#include "msmpeg4dec.h" 35#include "libavutil/imgutils.h" 36#include "h263.h" 37#include "h263data.h" 38#include "h263dec.h" 39#include "mpeg4videodec.h" 40#include "msmpeg4data.h" 41#include "wmv2dec.h" 42 43#define DC_VLC_BITS 9 44#define V2_INTRA_CBPC_VLC_BITS 3 45#define V2_MB_TYPE_VLC_BITS 7 46#define MV_VLC_BITS 9 47#define TEX_VLC_BITS 9 48 49#define DEFAULT_INTER_INDEX 3 50 51static inline int msmpeg4v1_pred_dc(MpegEncContext * s, int n, 52 int32_t **dc_val_ptr) 53{ 54 int i; 55 56 if (n < 4) { 57 i= 0; 58 } else { 59 i= n-3; 60 } 61 62 *dc_val_ptr= &s->last_dc[i]; 63 return s->last_dc[i]; 64} 65 66/****************************************/ 67/* decoding stuff */ 68 69VLC ff_mb_non_intra_vlc[4]; 70static VLC v2_dc_lum_vlc; 71static VLC v2_dc_chroma_vlc; 72static VLC v2_intra_cbpc_vlc; 73static VLC v2_mb_type_vlc; 74VLC ff_inter_intra_vlc; 75 76/* This is identical to H.263 except that its range is multiplied by 2. */ 77static int msmpeg4v2_decode_motion(MpegEncContext * s, int pred, int f_code) 78{ 79 int code, val, sign, shift; 80 81 code = get_vlc2(&s->gb, ff_h263_mv_vlc.table, H263_MV_VLC_BITS, 2); 82 ff_dlog(s, "MV code %d at %d %d pred: %d\n", code, s->mb_x,s->mb_y, pred); 83 if (code < 0) 84 return 0xffff; 85 86 if (code == 0) 87 return pred; 88 sign = get_bits1(&s->gb); 89 shift = f_code - 1; 90 val = code; 91 if (shift) { 92 val = (val - 1) << shift; 93 val |= get_bits(&s->gb, shift); 94 val++; 95 } 96 if (sign) 97 val = -val; 98 99 val += pred; 100 if (val <= -64) 101 val += 64; 102 else if (val >= 64) 103 val -= 64; 104 105 return val; 106} 107 108static int msmpeg4v12_decode_mb(MpegEncContext *s, int16_t block[6][64]) 109{ 110 int cbp, code, i; 111 uint32_t * const mb_type_ptr = &s->current_picture.mb_type[s->mb_x + s->mb_y*s->mb_stride]; 112 113 if (s->pict_type == AV_PICTURE_TYPE_P) { 114 if (s->use_skip_mb_code) { 115 if (get_bits1(&s->gb)) { 116 /* skip mb */ 117 s->mb_intra = 0; 118 for(i=0;i<6;i++) 119 s->block_last_index[i] = -1; 120 s->mv_dir = MV_DIR_FORWARD; 121 s->mv_type = MV_TYPE_16X16; 122 s->mv[0][0][0] = 0; 123 s->mv[0][0][1] = 0; 124 s->mb_skipped = 1; 125 *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16; 126 return 0; 127 } 128 } 129 130 if(s->msmpeg4_version==2) 131 code = get_vlc2(&s->gb, v2_mb_type_vlc.table, V2_MB_TYPE_VLC_BITS, 1); 132 else 133 code = get_vlc2(&s->gb, ff_h263_inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2); 134 if(code<0 || code>7){ 135 av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", code, s->mb_x, s->mb_y); 136 return -1; 137 } 138 139 s->mb_intra = code >>2; 140 141 cbp = code & 0x3; 142 } else { 143 s->mb_intra = 1; 144 if(s->msmpeg4_version==2) 145 cbp= get_vlc2(&s->gb, v2_intra_cbpc_vlc.table, V2_INTRA_CBPC_VLC_BITS, 1); 146 else 147 cbp= get_vlc2(&s->gb, ff_h263_intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2); 148 if(cbp<0 || cbp>3){ 149 av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y); 150 return -1; 151 } 152 } 153 154 if (!s->mb_intra) { 155 int mx, my, cbpy; 156 157 cbpy= get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1); 158 if(cbpy<0){ 159 av_log(s->avctx, AV_LOG_ERROR, "cbpy %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y); 160 return -1; 161 } 162 163 cbp|= cbpy<<2; 164 if(s->msmpeg4_version==1 || (cbp&3) != 3) cbp^= 0x3C; 165 166 ff_h263_pred_motion(s, 0, 0, &mx, &my); 167 mx= msmpeg4v2_decode_motion(s, mx, 1); 168 my= msmpeg4v2_decode_motion(s, my, 1); 169 170 s->mv_dir = MV_DIR_FORWARD; 171 s->mv_type = MV_TYPE_16X16; 172 s->mv[0][0][0] = mx; 173 s->mv[0][0][1] = my; 174 *mb_type_ptr = MB_TYPE_L0 | MB_TYPE_16x16; 175 } else { 176 int v; 177 if(s->msmpeg4_version==2){ 178 s->ac_pred = get_bits1(&s->gb); 179 v = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1); 180 if (v < 0) { 181 av_log(s->avctx, AV_LOG_ERROR, "cbpy vlc invalid\n"); 182 return -1; 183 } 184 cbp|= v<<2; 185 } else{ 186 s->ac_pred = 0; 187 v = get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1); 188 if (v < 0) { 189 av_log(s->avctx, AV_LOG_ERROR, "cbpy vlc invalid\n"); 190 return -1; 191 } 192 cbp|= v<<2; 193 if(s->pict_type==AV_PICTURE_TYPE_P) cbp^=0x3C; 194 } 195 *mb_type_ptr = MB_TYPE_INTRA; 196 } 197 198 s->bdsp.clear_blocks(s->block[0]); 199 for (i = 0; i < 6; i++) { 200 if (ff_msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0) 201 { 202 av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i); 203 return -1; 204 } 205 } 206 return 0; 207} 208 209static int msmpeg4v34_decode_mb(MpegEncContext *s, int16_t block[6][64]) 210{ 211 int cbp, code, i; 212 uint8_t *coded_val; 213 uint32_t * const mb_type_ptr = &s->current_picture.mb_type[s->mb_x + s->mb_y*s->mb_stride]; 214 215 if (get_bits_left(&s->gb) <= 0) 216 return AVERROR_INVALIDDATA; 217 218 if (s->pict_type == AV_PICTURE_TYPE_P) { 219 if (s->use_skip_mb_code) { 220 if (get_bits1(&s->gb)) { 221 /* skip mb */ 222 s->mb_intra = 0; 223 for(i=0;i<6;i++) 224 s->block_last_index[i] = -1; 225 s->mv_dir = MV_DIR_FORWARD; 226 s->mv_type = MV_TYPE_16X16; 227 s->mv[0][0][0] = 0; 228 s->mv[0][0][1] = 0; 229 s->mb_skipped = 1; 230 *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16; 231 232 return 0; 233 } 234 } 235 236 code = get_vlc2(&s->gb, ff_mb_non_intra_vlc[DEFAULT_INTER_INDEX].table, MB_NON_INTRA_VLC_BITS, 3); 237 //s->mb_intra = (code & 0x40) ? 0 : 1; 238 s->mb_intra = (~code & 0x40) >> 6; 239 240 cbp = code & 0x3f; 241 } else { 242 s->mb_intra = 1; 243 code = get_vlc2(&s->gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2); 244 /* predict coded block pattern */ 245 cbp = 0; 246 for(i=0;i<6;i++) { 247 int val = ((code >> (5 - i)) & 1); 248 if (i < 4) { 249 int pred = ff_msmpeg4_coded_block_pred(s, i, &coded_val); 250 val = val ^ pred; 251 *coded_val = val; 252 } 253 cbp |= val << (5 - i); 254 } 255 } 256 257 if (!s->mb_intra) { 258 int mx, my; 259 if(s->per_mb_rl_table && cbp){ 260 s->rl_table_index = decode012(&s->gb); 261 s->rl_chroma_table_index = s->rl_table_index; 262 } 263 ff_h263_pred_motion(s, 0, 0, &mx, &my); 264 ff_msmpeg4_decode_motion(s, &mx, &my); 265 s->mv_dir = MV_DIR_FORWARD; 266 s->mv_type = MV_TYPE_16X16; 267 s->mv[0][0][0] = mx; 268 s->mv[0][0][1] = my; 269 *mb_type_ptr = MB_TYPE_L0 | MB_TYPE_16x16; 270 } else { 271 ff_dlog(s, "I at %d %d %d %06X\n", s->mb_x, s->mb_y, 272 ((cbp & 3) ? 1 : 0) +((cbp & 0x3C)? 2 : 0), 273 show_bits(&s->gb, 24)); 274 s->ac_pred = get_bits1(&s->gb); 275 *mb_type_ptr = MB_TYPE_INTRA; 276 if(s->inter_intra_pred){ 277 s->h263_aic_dir= get_vlc2(&s->gb, ff_inter_intra_vlc.table, INTER_INTRA_VLC_BITS, 1); 278 ff_dlog(s, "%d%d %d %d/", 279 s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y); 280 } 281 if(s->per_mb_rl_table && cbp){ 282 s->rl_table_index = decode012(&s->gb); 283 s->rl_chroma_table_index = s->rl_table_index; 284 } 285 } 286 287 s->bdsp.clear_blocks(s->block[0]); 288 for (i = 0; i < 6; i++) { 289 if (ff_msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0) 290 { 291 av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i); 292 return -1; 293 } 294 } 295 296 return 0; 297} 298 299/* init all vlc decoding tables */ 300static av_cold void msmpeg4_decode_init_static(void) 301{ 302 MVTable *mv; 303 304 INIT_FIRST_VLC_RL(ff_rl_table[0], 642); 305 INIT_FIRST_VLC_RL(ff_rl_table[1], 1104); 306 INIT_FIRST_VLC_RL(ff_rl_table[2], 554); 307 INIT_VLC_RL(ff_rl_table[3], 940); 308 INIT_VLC_RL(ff_rl_table[4], 962); 309 /* ff_rl_table[5] coincides with ff_h263_rl_inter which has just been 310 * initialized in ff_h263_decode_init() earlier. So just copy the VLCs. */ 311 av_assert1(ff_h263_rl_inter.rl_vlc[0]); 312 memcpy(ff_rl_table[5].rl_vlc, ff_h263_rl_inter.rl_vlc, sizeof(ff_rl_table[5].rl_vlc)); 313 314 mv = &ff_mv_tables[0]; 315 INIT_VLC_STATIC(&mv->vlc, MV_VLC_BITS, MSMPEG4_MV_TABLES_NB_ELEMS + 1, 316 mv->table_mv_bits, 1, 1, 317 mv->table_mv_code, 2, 2, 3714); 318 mv = &ff_mv_tables[1]; 319 INIT_VLC_STATIC(&mv->vlc, MV_VLC_BITS, MSMPEG4_MV_TABLES_NB_ELEMS + 1, 320 mv->table_mv_bits, 1, 1, 321 mv->table_mv_code, 2, 2, 2694); 322 323 INIT_VLC_STATIC(&ff_msmp4_dc_luma_vlc[0], DC_VLC_BITS, 120, 324 &ff_table0_dc_lum[0][1], 8, 4, 325 &ff_table0_dc_lum[0][0], 8, 4, 1158); 326 INIT_VLC_STATIC(&ff_msmp4_dc_chroma_vlc[0], DC_VLC_BITS, 120, 327 &ff_table0_dc_chroma[0][1], 8, 4, 328 &ff_table0_dc_chroma[0][0], 8, 4, 1118); 329 INIT_VLC_STATIC(&ff_msmp4_dc_luma_vlc[1], DC_VLC_BITS, 120, 330 &ff_table1_dc_lum[0][1], 8, 4, 331 &ff_table1_dc_lum[0][0], 8, 4, 1476); 332 INIT_VLC_STATIC(&ff_msmp4_dc_chroma_vlc[1], DC_VLC_BITS, 120, 333 &ff_table1_dc_chroma[0][1], 8, 4, 334 &ff_table1_dc_chroma[0][0], 8, 4, 1216); 335 336 INIT_VLC_STATIC(&v2_dc_lum_vlc, DC_VLC_BITS, 512, 337 &ff_v2_dc_lum_table[0][1], 8, 4, 338 &ff_v2_dc_lum_table[0][0], 8, 4, 1472); 339 INIT_VLC_STATIC(&v2_dc_chroma_vlc, DC_VLC_BITS, 512, 340 &ff_v2_dc_chroma_table[0][1], 8, 4, 341 &ff_v2_dc_chroma_table[0][0], 8, 4, 1506); 342 343 INIT_VLC_STATIC(&v2_intra_cbpc_vlc, V2_INTRA_CBPC_VLC_BITS, 4, 344 &ff_v2_intra_cbpc[0][1], 2, 1, 345 &ff_v2_intra_cbpc[0][0], 2, 1, 8); 346 INIT_VLC_STATIC(&v2_mb_type_vlc, V2_MB_TYPE_VLC_BITS, 8, 347 &ff_v2_mb_type[0][1], 2, 1, 348 &ff_v2_mb_type[0][0], 2, 1, 128); 349 350 for (unsigned i = 0, offset = 0; i < 4; i++) { 351 static VLCElem vlc_buf[1636 + 2648 + 1532 + 2488]; 352 ff_mb_non_intra_vlc[i].table = &vlc_buf[offset]; 353 ff_mb_non_intra_vlc[i].table_allocated = FF_ARRAY_ELEMS(vlc_buf) - offset; 354 init_vlc(&ff_mb_non_intra_vlc[i], MB_NON_INTRA_VLC_BITS, 128, 355 &ff_wmv2_inter_table[i][0][1], 8, 4, 356 &ff_wmv2_inter_table[i][0][0], 8, 4, 357 INIT_VLC_STATIC_OVERLONG); 358 offset += ff_mb_non_intra_vlc[i].table_size; 359 } 360 361 INIT_VLC_STATIC(&ff_msmp4_mb_i_vlc, MB_INTRA_VLC_BITS, 64, 362 &ff_msmp4_mb_i_table[0][1], 4, 2, 363 &ff_msmp4_mb_i_table[0][0], 4, 2, 536); 364 365 INIT_VLC_STATIC(&ff_inter_intra_vlc, INTER_INTRA_VLC_BITS, 4, 366 &ff_table_inter_intra[0][1], 2, 1, 367 &ff_table_inter_intra[0][0], 2, 1, 8); 368} 369 370av_cold int ff_msmpeg4_decode_init(AVCodecContext *avctx) 371{ 372 static AVOnce init_static_once = AV_ONCE_INIT; 373 MpegEncContext *s = avctx->priv_data; 374 int ret; 375 376 if ((ret = av_image_check_size(avctx->width, avctx->height, 0, avctx)) < 0) 377 return ret; 378 379 if (ff_h263_decode_init(avctx) < 0) 380 return -1; 381 382 ff_msmpeg4_common_init(s); 383 384 switch(s->msmpeg4_version){ 385 case 1: 386 case 2: 387 s->decode_mb= msmpeg4v12_decode_mb; 388 break; 389 case 3: 390 case 4: 391 s->decode_mb= msmpeg4v34_decode_mb; 392 break; 393 case 5: 394 if (CONFIG_WMV2_DECODER) 395 s->decode_mb= ff_wmv2_decode_mb; 396 case 6: 397 //FIXME + TODO VC1 decode mb 398 break; 399 } 400 401 s->slice_height= s->mb_height; //to avoid 1/0 if the first frame is not a keyframe 402 403 ff_thread_once(&init_static_once, msmpeg4_decode_init_static); 404 405 return 0; 406} 407 408int ff_msmpeg4_decode_picture_header(MpegEncContext * s) 409{ 410 int code; 411 412 // at minimum one bit per macroblock is required at least in a valid frame, 413 // we discard frames much smaller than this. Frames smaller than 1/8 of the 414 // smallest "black/skip" frame generally contain not much recoverable content 415 // while at the same time they have the highest computational requirements 416 // per byte 417 if (get_bits_left(&s->gb) * 8LL < (s->width+15)/16 * ((s->height+15)/16)) 418 return AVERROR_INVALIDDATA; 419 420 if(s->msmpeg4_version==1){ 421 int start_code = get_bits_long(&s->gb, 32); 422 if(start_code!=0x00000100){ 423 av_log(s->avctx, AV_LOG_ERROR, "invalid startcode\n"); 424 return -1; 425 } 426 427 skip_bits(&s->gb, 5); // frame number */ 428 } 429 430 s->pict_type = get_bits(&s->gb, 2) + 1; 431 if (s->pict_type != AV_PICTURE_TYPE_I && 432 s->pict_type != AV_PICTURE_TYPE_P){ 433 av_log(s->avctx, AV_LOG_ERROR, "invalid picture type\n"); 434 return -1; 435 } 436 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5); 437 if(s->qscale==0){ 438 av_log(s->avctx, AV_LOG_ERROR, "invalid qscale\n"); 439 return -1; 440 } 441 442 if (s->pict_type == AV_PICTURE_TYPE_I) { 443 code = get_bits(&s->gb, 5); 444 if(s->msmpeg4_version==1){ 445 if(code==0 || code>s->mb_height){ 446 av_log(s->avctx, AV_LOG_ERROR, "invalid slice height %d\n", code); 447 return -1; 448 } 449 450 s->slice_height = code; 451 }else{ 452 /* 0x17: one slice, 0x18: two slices, ... */ 453 if (code < 0x17){ 454 av_log(s->avctx, AV_LOG_ERROR, "error, slice code was %X\n", code); 455 return -1; 456 } 457 458 s->slice_height = s->mb_height / (code - 0x16); 459 } 460 461 switch(s->msmpeg4_version){ 462 case 1: 463 case 2: 464 s->rl_chroma_table_index = 2; 465 s->rl_table_index = 2; 466 467 s->dc_table_index = 0; //not used 468 break; 469 case 3: 470 s->rl_chroma_table_index = decode012(&s->gb); 471 s->rl_table_index = decode012(&s->gb); 472 473 s->dc_table_index = get_bits1(&s->gb); 474 break; 475 case 4: 476 ff_msmpeg4_decode_ext_header(s, (2+5+5+17+7)/8); 477 478 if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb); 479 else s->per_mb_rl_table= 0; 480 481 if(!s->per_mb_rl_table){ 482 s->rl_chroma_table_index = decode012(&s->gb); 483 s->rl_table_index = decode012(&s->gb); 484 } 485 486 s->dc_table_index = get_bits1(&s->gb); 487 s->inter_intra_pred= 0; 488 break; 489 } 490 s->no_rounding = 1; 491 if(s->avctx->debug&FF_DEBUG_PICT_INFO) 492 av_log(s->avctx, AV_LOG_DEBUG, "qscale:%d rlc:%d rl:%d dc:%d mbrl:%d slice:%d \n", 493 s->qscale, 494 s->rl_chroma_table_index, 495 s->rl_table_index, 496 s->dc_table_index, 497 s->per_mb_rl_table, 498 s->slice_height); 499 } else { 500 switch(s->msmpeg4_version){ 501 case 1: 502 case 2: 503 if(s->msmpeg4_version==1) 504 s->use_skip_mb_code = 1; 505 else 506 s->use_skip_mb_code = get_bits1(&s->gb); 507 s->rl_table_index = 2; 508 s->rl_chroma_table_index = s->rl_table_index; 509 s->dc_table_index = 0; //not used 510 s->mv_table_index = 0; 511 break; 512 case 3: 513 s->use_skip_mb_code = get_bits1(&s->gb); 514 s->rl_table_index = decode012(&s->gb); 515 s->rl_chroma_table_index = s->rl_table_index; 516 517 s->dc_table_index = get_bits1(&s->gb); 518 519 s->mv_table_index = get_bits1(&s->gb); 520 break; 521 case 4: 522 s->use_skip_mb_code = get_bits1(&s->gb); 523 524 if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb); 525 else s->per_mb_rl_table= 0; 526 527 if(!s->per_mb_rl_table){ 528 s->rl_table_index = decode012(&s->gb); 529 s->rl_chroma_table_index = s->rl_table_index; 530 } 531 532 s->dc_table_index = get_bits1(&s->gb); 533 534 s->mv_table_index = get_bits1(&s->gb); 535 s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE); 536 break; 537 } 538 539 if(s->avctx->debug&FF_DEBUG_PICT_INFO) 540 av_log(s->avctx, AV_LOG_DEBUG, "skip:%d rl:%d rlc:%d dc:%d mv:%d mbrl:%d qp:%d \n", 541 s->use_skip_mb_code, 542 s->rl_table_index, 543 s->rl_chroma_table_index, 544 s->dc_table_index, 545 s->mv_table_index, 546 s->per_mb_rl_table, 547 s->qscale); 548 549 if(s->flipflop_rounding){ 550 s->no_rounding ^= 1; 551 }else{ 552 s->no_rounding = 0; 553 } 554 } 555 ff_dlog(s->avctx, "%d %"PRId64" %d %d %d\n", s->pict_type, s->bit_rate, 556 s->inter_intra_pred, s->width, s->height); 557 558 s->esc3_level_length= 0; 559 s->esc3_run_length= 0; 560 561 return 0; 562} 563 564int ff_msmpeg4_decode_ext_header(MpegEncContext * s, int buf_size) 565{ 566 int left= buf_size*8 - get_bits_count(&s->gb); 567 int length= s->msmpeg4_version>=3 ? 17 : 16; 568 /* the alt_bitstream reader could read over the end so we need to check it */ 569 if(left>=length && left<length+8) 570 { 571 skip_bits(&s->gb, 5); /* fps */ 572 s->bit_rate= get_bits(&s->gb, 11)*1024; 573 if(s->msmpeg4_version>=3) 574 s->flipflop_rounding= get_bits1(&s->gb); 575 else 576 s->flipflop_rounding= 0; 577 } 578 else if(left<length+8) 579 { 580 s->flipflop_rounding= 0; 581 if(s->msmpeg4_version != 2) 582 av_log(s->avctx, AV_LOG_ERROR, "ext header missing, %d left\n", left); 583 } 584 else 585 { 586 av_log(s->avctx, AV_LOG_ERROR, "I-frame too long, ignoring ext header\n"); 587 } 588 589 return 0; 590} 591 592static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr) 593{ 594 int level, pred; 595 596 if(s->msmpeg4_version<=2){ 597 if (n < 4) { 598 level = get_vlc2(&s->gb, v2_dc_lum_vlc.table, DC_VLC_BITS, 3); 599 } else { 600 level = get_vlc2(&s->gb, v2_dc_chroma_vlc.table, DC_VLC_BITS, 3); 601 } 602 if (level < 0) { 603 av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n"); 604 *dir_ptr = 0; 605 return -1; 606 } 607 level-=256; 608 }else{ //FIXME optimize use unified tables & index 609 if (n < 4) { 610 level = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3); 611 } else { 612 level = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3); 613 } 614 615 if (level == DC_MAX) { 616 level = get_bits(&s->gb, 8); 617 if (get_bits1(&s->gb)) 618 level = -level; 619 } else if (level != 0) { 620 if (get_bits1(&s->gb)) 621 level = -level; 622 } 623 } 624 625 if(s->msmpeg4_version==1){ 626 int32_t *dc_val; 627 pred = msmpeg4v1_pred_dc(s, n, &dc_val); 628 level += pred; 629 630 /* update predictor */ 631 *dc_val= level; 632 }else{ 633 int16_t *dc_val; 634 pred = ff_msmpeg4_pred_dc(s, n, &dc_val, dir_ptr); 635 level += pred; 636 637 /* update predictor */ 638 if (n < 4) { 639 *dc_val = level * s->y_dc_scale; 640 } else { 641 *dc_val = level * s->c_dc_scale; 642 } 643 } 644 645 return level; 646} 647 648int ff_msmpeg4_decode_block(MpegEncContext * s, int16_t * block, 649 int n, int coded, const uint8_t *scan_table) 650{ 651 int level, i, last, run, run_diff; 652 int av_uninit(dc_pred_dir); 653 RLTable *rl; 654 RL_VLC_ELEM *rl_vlc; 655 int qmul, qadd; 656 657 if (s->mb_intra) { 658 qmul=1; 659 qadd=0; 660 661 /* DC coef */ 662 level = msmpeg4_decode_dc(s, n, &dc_pred_dir); 663 664 if (level < 0){ 665 av_log(s->avctx, AV_LOG_ERROR, "dc overflow- block: %d qscale: %d//\n", n, s->qscale); 666 if(s->inter_intra_pred) level=0; 667 } 668 if (n < 4) { 669 rl = &ff_rl_table[s->rl_table_index]; 670 if(level > 256*s->y_dc_scale){ 671 av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ L qscale: %d//\n", s->qscale); 672 if(!s->inter_intra_pred) return -1; 673 } 674 } else { 675 rl = &ff_rl_table[3 + s->rl_chroma_table_index]; 676 if(level > 256*s->c_dc_scale){ 677 av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ C qscale: %d//\n", s->qscale); 678 if(!s->inter_intra_pred) return -1; 679 } 680 } 681 block[0] = level; 682 683 run_diff = s->msmpeg4_version >= 4; 684 i = 0; 685 if (!coded) { 686 goto not_coded; 687 } 688 if (s->ac_pred) { 689 if (dc_pred_dir == 0) 690 scan_table = s->intra_v_scantable.permutated; /* left */ 691 else 692 scan_table = s->intra_h_scantable.permutated; /* top */ 693 } else { 694 scan_table = s->intra_scantable.permutated; 695 } 696 rl_vlc= rl->rl_vlc[0]; 697 } else { 698 qmul = s->qscale << 1; 699 qadd = (s->qscale - 1) | 1; 700 i = -1; 701 rl = &ff_rl_table[3 + s->rl_table_index]; 702 703 if(s->msmpeg4_version==2) 704 run_diff = 0; 705 else 706 run_diff = 1; 707 708 if (!coded) { 709 s->block_last_index[n] = i; 710 return 0; 711 } 712 if(!scan_table) 713 scan_table = s->inter_scantable.permutated; 714 rl_vlc= rl->rl_vlc[s->qscale]; 715 } 716 { 717 OPEN_READER(re, &s->gb); 718 for(;;) { 719 UPDATE_CACHE(re, &s->gb); 720 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0); 721 if (level==0) { 722 int cache; 723 cache= GET_CACHE(re, &s->gb); 724 /* escape */ 725 if (s->msmpeg4_version==1 || (cache&0x80000000)==0) { 726 if (s->msmpeg4_version==1 || (cache&0x40000000)==0) { 727 /* third escape */ 728 if(s->msmpeg4_version!=1) LAST_SKIP_BITS(re, &s->gb, 2); 729 UPDATE_CACHE(re, &s->gb); 730 if(s->msmpeg4_version<=3){ 731 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1); 732 run= SHOW_UBITS(re, &s->gb, 6); SKIP_CACHE(re, &s->gb, 6); 733 level= SHOW_SBITS(re, &s->gb, 8); 734 SKIP_COUNTER(re, &s->gb, 1+6+8); 735 }else{ 736 int sign; 737 last= SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1); 738 if(!s->esc3_level_length){ 739 int ll; 740 ff_dlog(s->avctx, "ESC-3 %X at %d %d\n", 741 show_bits(&s->gb, 24), s->mb_x, s->mb_y); 742 if(s->qscale<8){ 743 ll= SHOW_UBITS(re, &s->gb, 3); SKIP_BITS(re, &s->gb, 3); 744 if(ll==0){ 745 ll= 8+SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1); 746 } 747 }else{ 748 ll=2; 749 while(ll<8 && SHOW_UBITS(re, &s->gb, 1)==0){ 750 ll++; 751 SKIP_BITS(re, &s->gb, 1); 752 } 753 if(ll<8) SKIP_BITS(re, &s->gb, 1); 754 } 755 756 s->esc3_level_length= ll; 757 s->esc3_run_length= SHOW_UBITS(re, &s->gb, 2) + 3; SKIP_BITS(re, &s->gb, 2); 758 UPDATE_CACHE(re, &s->gb); 759 } 760 run= SHOW_UBITS(re, &s->gb, s->esc3_run_length); 761 SKIP_BITS(re, &s->gb, s->esc3_run_length); 762 763 sign= SHOW_UBITS(re, &s->gb, 1); 764 SKIP_BITS(re, &s->gb, 1); 765 766 level= SHOW_UBITS(re, &s->gb, s->esc3_level_length); 767 SKIP_BITS(re, &s->gb, s->esc3_level_length); 768 if(sign) level= -level; 769 } 770 771 //level = level * qmul + (level>0) * qadd - (level<=0) * qadd ; 772 if (level>0) level= level * qmul + qadd; 773 else level= level * qmul - qadd; 774 i+= run + 1; 775 if(last) i+=192; 776 } else { 777 /* second escape */ 778 SKIP_BITS(re, &s->gb, 2); 779 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1); 780 i+= run + rl->max_run[run>>7][level/qmul] + run_diff; //FIXME opt indexing 781 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); 782 LAST_SKIP_BITS(re, &s->gb, 1); 783 } 784 } else { 785 /* first escape */ 786 SKIP_BITS(re, &s->gb, 1); 787 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1); 788 i+= run; 789 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing 790 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); 791 LAST_SKIP_BITS(re, &s->gb, 1); 792 } 793 } else { 794 i+= run; 795 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); 796 LAST_SKIP_BITS(re, &s->gb, 1); 797 } 798 if (i > 62){ 799 i-= 192; 800 if(i&(~63)){ 801 const int left= get_bits_left(&s->gb); 802 if (((i + 192 == 64 && level / qmul == -1) || 803 !(s->avctx->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT))) && 804 left >= 0) { 805 av_log(s->avctx, AV_LOG_ERROR, "ignoring overflow at %d %d\n", s->mb_x, s->mb_y); 806 i = 63; 807 break; 808 }else{ 809 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y); 810 return -1; 811 } 812 } 813 814 block[scan_table[i]] = level; 815 break; 816 } 817 818 block[scan_table[i]] = level; 819 } 820 CLOSE_READER(re, &s->gb); 821 } 822 not_coded: 823 if (s->mb_intra) { 824 ff_mpeg4_pred_ac(s, block, n, dc_pred_dir); 825 if (s->ac_pred) { 826 i = 63; /* XXX: not optimal */ 827 } 828 } 829 if(s->msmpeg4_version>=4 && i>0) i=63; //FIXME/XXX optimize 830 s->block_last_index[n] = i; 831 832 return 0; 833} 834 835void ff_msmpeg4_decode_motion(MpegEncContext *s, int *mx_ptr, int *my_ptr) 836{ 837 MVTable *mv; 838 int code, mx, my; 839 840 mv = &ff_mv_tables[s->mv_table_index]; 841 842 code = get_vlc2(&s->gb, mv->vlc.table, MV_VLC_BITS, 2); 843 if (code == MSMPEG4_MV_TABLES_NB_ELEMS) { 844 mx = get_bits(&s->gb, 6); 845 my = get_bits(&s->gb, 6); 846 } else { 847 mx = mv->table_mvx[code]; 848 my = mv->table_mvy[code]; 849 } 850 851 mx += *mx_ptr - 32; 852 my += *my_ptr - 32; 853 /* WARNING : they do not do exactly modulo encoding */ 854 if (mx <= -64) 855 mx += 64; 856 else if (mx >= 64) 857 mx -= 64; 858 859 if (my <= -64) 860 my += 64; 861 else if (my >= 64) 862 my -= 64; 863 *mx_ptr = mx; 864 *my_ptr = my; 865} 866 867const FFCodec ff_msmpeg4v1_decoder = { 868 .p.name = "msmpeg4v1", 869 .p.long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 1"), 870 .p.type = AVMEDIA_TYPE_VIDEO, 871 .p.id = AV_CODEC_ID_MSMPEG4V1, 872 .priv_data_size = sizeof(MpegEncContext), 873 .init = ff_msmpeg4_decode_init, 874 .close = ff_h263_decode_end, 875 FF_CODEC_DECODE_CB(ff_h263_decode_frame), 876 .p.capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1, 877 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | 878 FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM, 879 .p.max_lowres = 3, 880 .p.pix_fmts = (const enum AVPixelFormat[]) { 881 AV_PIX_FMT_YUV420P, 882 AV_PIX_FMT_NONE 883 }, 884}; 885 886const FFCodec ff_msmpeg4v2_decoder = { 887 .p.name = "msmpeg4v2", 888 .p.long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"), 889 .p.type = AVMEDIA_TYPE_VIDEO, 890 .p.id = AV_CODEC_ID_MSMPEG4V2, 891 .priv_data_size = sizeof(MpegEncContext), 892 .init = ff_msmpeg4_decode_init, 893 .close = ff_h263_decode_end, 894 FF_CODEC_DECODE_CB(ff_h263_decode_frame), 895 .p.capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1, 896 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | 897 FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM, 898 .p.max_lowres = 3, 899 .p.pix_fmts = (const enum AVPixelFormat[]) { 900 AV_PIX_FMT_YUV420P, 901 AV_PIX_FMT_NONE 902 }, 903}; 904 905const FFCodec ff_msmpeg4v3_decoder = { 906 .p.name = "msmpeg4", 907 .p.long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"), 908 .p.type = AVMEDIA_TYPE_VIDEO, 909 .p.id = AV_CODEC_ID_MSMPEG4V3, 910 .priv_data_size = sizeof(MpegEncContext), 911 .init = ff_msmpeg4_decode_init, 912 .close = ff_h263_decode_end, 913 FF_CODEC_DECODE_CB(ff_h263_decode_frame), 914 .p.capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1, 915 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | 916 FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM, 917 .p.max_lowres = 3, 918 .p.pix_fmts = (const enum AVPixelFormat[]) { 919 AV_PIX_FMT_YUV420P, 920 AV_PIX_FMT_NONE 921 }, 922}; 923 924const FFCodec ff_wmv1_decoder = { 925 .p.name = "wmv1", 926 .p.long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 7"), 927 .p.type = AVMEDIA_TYPE_VIDEO, 928 .p.id = AV_CODEC_ID_WMV1, 929 .priv_data_size = sizeof(MpegEncContext), 930 .init = ff_msmpeg4_decode_init, 931 .close = ff_h263_decode_end, 932 FF_CODEC_DECODE_CB(ff_h263_decode_frame), 933 .p.capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1, 934 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | 935 FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM, 936 .p.max_lowres = 3, 937 .p.pix_fmts = (const enum AVPixelFormat[]) { 938 AV_PIX_FMT_YUV420P, 939 AV_PIX_FMT_NONE 940 }, 941}; 942