FFmpeg: libavcodec/msmpeg4dec.c Source File

FFmpeg

[フレーム]

libavcodec

msmpeg4dec.c

Go to the documentation of this file.

1 /*

2 * MSMPEG4 backend for encoder and decoder

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 */

25 #include "avcodec.h"

26 #include "dsputil.h"

27 #include "mpegvideo.h"

28 #include "msmpeg4.h"

29 #include "libavutil/imgutils.h"

30 #include "libavutil/x86/asm.h"

31 #include "h263.h"

32 #include "mpeg4video.h"

33 #include "msmpeg4data.h"

34 #include "vc1data.h"

36 #define DC_VLC_BITS 9

37 #define V2_INTRA_CBPC_VLC_BITS 3

38 #define V2_MB_TYPE_VLC_BITS 7

39 #define MV_VLC_BITS 9

40 #define V2_MV_VLC_BITS 9

41 #define TEX_VLC_BITS 9

43 #define DEFAULT_INTER_INDEX 3

45 static inline int msmpeg4v1_pred_dc(MpegEncContext * s, int n,

46 int32_t **dc_val_ptr)

47 {

48 int i;

50 if (n < 4) {

51 i= 0;

52 } else {

53 i= n-3;

54 }

56 *dc_val_ptr= &s->last_dc[i];

57 return s->last_dc[i];

58 }

60 /****************************************/

61 /* decoding stuff */

63 VLC ff_mb_non_intra_vlc[4];

64 static VLC v2_dc_lum_vlc;

65 static VLC v2_dc_chroma_vlc;

66 static VLC v2_intra_cbpc_vlc;

67 static VLC v2_mb_type_vlc;

68 static VLC v2_mv_vlc;

69 VLC ff_inter_intra_vlc;

71 /* This is identical to h263 except that its range is multiplied by 2. */

72 static int msmpeg4v2_decode_motion(MpegEncContext * s, int pred, int f_code)

73 {

74 int code, val, sign, shift;

76 code = get_vlc2(&s->gb, v2_mv_vlc.table, V2_MV_VLC_BITS, 2);

77 av_dlog(s, "MV code %d at %d %d pred: %d\n", code, s->mb_x,s->mb_y, pred);

78 if (code < 0)

79 return 0xffff;

81 if (code == 0)

82 return pred;

83 sign = get_bits1(&s->gb);

84 shift = f_code - 1;

85 val = code;

86 if (shift) {

87 val = (val - 1) << shift;

88 val |= get_bits(&s->gb, shift);

89 val++;

90 }

91 if (sign)

92 val = -val;

94 val += pred;

95 if (val <= -64)

96 val += 64;

97 else if (val >= 64)

98 val -= 64;

100 return val;

101 }

102

103 static int msmpeg4v12_decode_mb(MpegEncContext *s, int16_t block[6][64])

104 {

105 int cbp, code, i;

106 uint32_t * const mb_type_ptr = &s->current_picture.mb_type[s->mb_x + s->mb_y*s->mb_stride];

107

108 if (s->pict_type == AV_PICTURE_TYPE_P) {

109 if (s->use_skip_mb_code) {

110 if (get_bits1(&s->gb)) {

111 /* skip mb */

112 s->mb_intra = 0;

113 for(i=0;i<6;i++)

114 s->block_last_index[i] = -1;

115 s->mv_dir = MV_DIR_FORWARD;

116 s->mv_type = MV_TYPE_16X16;

117 s->mv[0][0][0] = 0;

118 s->mv[0][0][1] = 0;

119 s->mb_skipped = 1;

120 *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;

121 return 0;

122 }

123 }

124

125 if(s->msmpeg4_version==2)

126 code = get_vlc2(&s->gb, v2_mb_type_vlc.table, V2_MB_TYPE_VLC_BITS, 1);

127 else

128 code = get_vlc2(&s->gb, ff_h263_inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);

129 if(code<0 || code>7){

130 av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", code, s->mb_x, s->mb_y);

131 return -1;

132 }

133

134 s->mb_intra = code >>2;

135

136 cbp = code & 0x3;

137 } else {

138 s->mb_intra = 1;

139 if(s->msmpeg4_version==2)

140 cbp= get_vlc2(&s->gb, v2_intra_cbpc_vlc.table, V2_INTRA_CBPC_VLC_BITS, 1);

141 else

142 cbp= get_vlc2(&s->gb, ff_h263_intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 1);

143 if(cbp<0 || cbp>3){

144 av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);

145 return -1;

146 }

147 }

148

149 if (!s->mb_intra) {

150 int mx, my, cbpy;

151

152 cbpy= get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);

153 if(cbpy<0){

154 av_log(s->avctx, AV_LOG_ERROR, "cbpy %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);

155 return -1;

156 }

157

158 cbp|= cbpy<<2;

159 if(s->msmpeg4_version==1 || (cbp&3) != 3) cbp^= 0x3C;

160

161 ff_h263_pred_motion(s, 0, 0, &mx, &my);

162 mx= msmpeg4v2_decode_motion(s, mx, 1);

163 my= msmpeg4v2_decode_motion(s, my, 1);

164

165 s->mv_dir = MV_DIR_FORWARD;

166 s->mv_type = MV_TYPE_16X16;

167 s->mv[0][0][0] = mx;

168 s->mv[0][0][1] = my;

169 *mb_type_ptr = MB_TYPE_L0 | MB_TYPE_16x16;

170 } else {

171 if(s->msmpeg4_version==2){

172 s->ac_pred = get_bits1(&s->gb);

173 cbp|= get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors

174 } else{

175 s->ac_pred = 0;

176 cbp|= get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors

177 if(s->pict_type==AV_PICTURE_TYPE_P) cbp^=0x3C;

178 }

179 *mb_type_ptr = MB_TYPE_INTRA;

180 }

181

182 s->dsp.clear_blocks(s->block[0]);

183 for (i = 0; i < 6; i++) {

184 if (ff_msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)

185 {

186 av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);

187 return -1;

188 }

189 }

190 return 0;

191 }

192

193 static int msmpeg4v34_decode_mb(MpegEncContext *s, int16_t block[6][64])

194 {

195 int cbp, code, i;

196 uint8_t *coded_val;

197 uint32_t * const mb_type_ptr = &s->current_picture.mb_type[s->mb_x + s->mb_y*s->mb_stride];

198

199 if (s->pict_type == AV_PICTURE_TYPE_P) {

200 if (s->use_skip_mb_code) {

201 if (get_bits1(&s->gb)) {

202 /* skip mb */

203 s->mb_intra = 0;

204 for(i=0;i<6;i++)

205 s->block_last_index[i] = -1;

206 s->mv_dir = MV_DIR_FORWARD;

207 s->mv_type = MV_TYPE_16X16;

208 s->mv[0][0][0] = 0;

209 s->mv[0][0][1] = 0;

210 s->mb_skipped = 1;

211 *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;

212

213 return 0;

214 }

215 }

216

217 code = get_vlc2(&s->gb, ff_mb_non_intra_vlc[DEFAULT_INTER_INDEX].table, MB_NON_INTRA_VLC_BITS, 3);

218 if (code < 0)

219 return -1;

220 //s->mb_intra = (code & 0x40) ? 0 : 1;

221 s->mb_intra = (~code & 0x40) >> 6;

222

223 cbp = code & 0x3f;

224 } else {

225 s->mb_intra = 1;

226 code = get_vlc2(&s->gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);

227 if (code < 0)

228 return -1;

229 /* predict coded block pattern */

230 cbp = 0;

231 for(i=0;i<6;i++) {

232 int val = ((code >> (5 - i)) & 1);

233 if (i < 4) {

234 int pred = ff_msmpeg4_coded_block_pred(s, i, &coded_val);

235 val = val ^ pred;

236 *coded_val = val;

237 }

238 cbp |= val << (5 - i);

239 }

240 }

241

242 if (!s->mb_intra) {

243 int mx, my;

244 if(s->per_mb_rl_table && cbp){

245 s->rl_table_index = decode012(&s->gb);

246 s->rl_chroma_table_index = s->rl_table_index;

247 }

248 ff_h263_pred_motion(s, 0, 0, &mx, &my);

249 if (ff_msmpeg4_decode_motion(s, &mx, &my) < 0)

250 return -1;

251 s->mv_dir = MV_DIR_FORWARD;

252 s->mv_type = MV_TYPE_16X16;

253 s->mv[0][0][0] = mx;

254 s->mv[0][0][1] = my;

255 *mb_type_ptr = MB_TYPE_L0 | MB_TYPE_16x16;

256 } else {

257 av_dlog(s, "I at %d %d %d %06X\n", s->mb_x, s->mb_y,

258 ((cbp & 3) ? 1 : 0) +((cbp & 0x3C)? 2 : 0),

259 show_bits(&s->gb, 24));

260 s->ac_pred = get_bits1(&s->gb);

261 *mb_type_ptr = MB_TYPE_INTRA;

262 if(s->inter_intra_pred){

263 s->h263_aic_dir= get_vlc2(&s->gb, ff_inter_intra_vlc.table, INTER_INTRA_VLC_BITS, 1);

264 av_dlog(s, "%d%d %d %d/",

265 s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y);

266 }

267 if(s->per_mb_rl_table && cbp){

268 s->rl_table_index = decode012(&s->gb);

269 s->rl_chroma_table_index = s->rl_table_index;

270 }

271 }

272

273 s->dsp.clear_blocks(s->block[0]);

274 for (i = 0; i < 6; i++) {

275 if (ff_msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)

276 {

277 av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);

278 return -1;

279 }

280 }

281

282 return 0;

283 }

284

285 /* init all vlc decoding tables */

286 av_cold int ff_msmpeg4_decode_init(AVCodecContext *avctx)

287 {

288 MpegEncContext *s = avctx->priv_data;

289 static volatile int done = 0;

290 int i, ret;

291 MVTable *mv;

292

293 if ((ret = av_image_check_size(avctx->width, avctx->height, 0, avctx)) < 0)

294 return ret;

295

296 if (ff_h263_decode_init(avctx) < 0)

297 return -1;

298

299 ff_msmpeg4_common_init(s);

300

301 if (!done) {

302 for(i=0;i<NB_RL_TABLES;i++) {

303 ff_init_rl(&ff_rl_table[i], ff_static_rl_table_store[i]);

304 }

305 INIT_VLC_RL(ff_rl_table[0], 642);

306 INIT_VLC_RL(ff_rl_table[1], 1104);

307 INIT_VLC_RL(ff_rl_table[2], 554);

308 INIT_VLC_RL(ff_rl_table[3], 940);

309 INIT_VLC_RL(ff_rl_table[4], 962);

310 INIT_VLC_RL(ff_rl_table[5], 554);

311

312 mv = &ff_mv_tables[0];

313 INIT_VLC_STATIC(&mv->vlc, MV_VLC_BITS, mv->n + 1,

314 mv->table_mv_bits, 1, 1,

315 mv->table_mv_code, 2, 2, 3714);

316 mv = &ff_mv_tables[1];

317 INIT_VLC_STATIC(&mv->vlc, MV_VLC_BITS, mv->n + 1,

318 mv->table_mv_bits, 1, 1,

319 mv->table_mv_code, 2, 2, 2694);

320

321 INIT_VLC_STATIC(&ff_msmp4_dc_luma_vlc[0], DC_VLC_BITS, 120,

322 &ff_table0_dc_lum[0][1], 8, 4,

323 &ff_table0_dc_lum[0][0], 8, 4, 1158);

324 INIT_VLC_STATIC(&ff_msmp4_dc_chroma_vlc[0], DC_VLC_BITS, 120,

325 &ff_table0_dc_chroma[0][1], 8, 4,

326 &ff_table0_dc_chroma[0][0], 8, 4, 1118);

327 INIT_VLC_STATIC(&ff_msmp4_dc_luma_vlc[1], DC_VLC_BITS, 120,

328 &ff_table1_dc_lum[0][1], 8, 4,

329 &ff_table1_dc_lum[0][0], 8, 4, 1476);

330 INIT_VLC_STATIC(&ff_msmp4_dc_chroma_vlc[1], DC_VLC_BITS, 120,

331 &ff_table1_dc_chroma[0][1], 8, 4,

332 &ff_table1_dc_chroma[0][0], 8, 4, 1216);

333

334 INIT_VLC_STATIC(&v2_dc_lum_vlc, DC_VLC_BITS, 512,

335 &ff_v2_dc_lum_table[0][1], 8, 4,

336 &ff_v2_dc_lum_table[0][0], 8, 4, 1472);

337 INIT_VLC_STATIC(&v2_dc_chroma_vlc, DC_VLC_BITS, 512,

338 &ff_v2_dc_chroma_table[0][1], 8, 4,

339 &ff_v2_dc_chroma_table[0][0], 8, 4, 1506);

340

341 INIT_VLC_STATIC(&v2_intra_cbpc_vlc, V2_INTRA_CBPC_VLC_BITS, 4,

342 &ff_v2_intra_cbpc[0][1], 2, 1,

343 &ff_v2_intra_cbpc[0][0], 2, 1, 8);

344 INIT_VLC_STATIC(&v2_mb_type_vlc, V2_MB_TYPE_VLC_BITS, 8,

345 &ff_v2_mb_type[0][1], 2, 1,

346 &ff_v2_mb_type[0][0], 2, 1, 128);

347 INIT_VLC_STATIC(&v2_mv_vlc, V2_MV_VLC_BITS, 33,

348 &ff_mvtab[0][1], 2, 1,

349 &ff_mvtab[0][0], 2, 1, 538);

350

351 INIT_VLC_STATIC(&ff_mb_non_intra_vlc[0], MB_NON_INTRA_VLC_BITS, 128,

352 &ff_wmv2_inter_table[0][0][1], 8, 4,

353 &ff_wmv2_inter_table[0][0][0], 8, 4, 1636);

354 INIT_VLC_STATIC(&ff_mb_non_intra_vlc[1], MB_NON_INTRA_VLC_BITS, 128,

355 &ff_wmv2_inter_table[1][0][1], 8, 4,

356 &ff_wmv2_inter_table[1][0][0], 8, 4, 2648);

357 INIT_VLC_STATIC(&ff_mb_non_intra_vlc[2], MB_NON_INTRA_VLC_BITS, 128,

358 &ff_wmv2_inter_table[2][0][1], 8, 4,

359 &ff_wmv2_inter_table[2][0][0], 8, 4, 1532);

360 INIT_VLC_STATIC(&ff_mb_non_intra_vlc[3], MB_NON_INTRA_VLC_BITS, 128,

361 &ff_wmv2_inter_table[3][0][1], 8, 4,

362 &ff_wmv2_inter_table[3][0][0], 8, 4, 2488);

363

364 INIT_VLC_STATIC(&ff_msmp4_mb_i_vlc, MB_INTRA_VLC_BITS, 64,

365 &ff_msmp4_mb_i_table[0][1], 4, 2,

366 &ff_msmp4_mb_i_table[0][0], 4, 2, 536);

367

368 INIT_VLC_STATIC(&ff_inter_intra_vlc, INTER_INTRA_VLC_BITS, 4,

369 &ff_table_inter_intra[0][1], 2, 1,

370 &ff_table_inter_intra[0][0], 2, 1, 8);

371 done = 1;

372 }

373

374 switch(s->msmpeg4_version){

375 case 1:

376 case 2:

377 s->decode_mb= msmpeg4v12_decode_mb;

378 break;

379 case 3:

380 case 4:

381 s->decode_mb= msmpeg4v34_decode_mb;

382 break;

383 case 5:

384 if (CONFIG_WMV2_DECODER)

385 s->decode_mb= ff_wmv2_decode_mb;

386 case 6:

387 //FIXME + TODO VC1 decode mb

388 break;

389 }

390

391 s->slice_height= s->mb_height; //to avoid 1/0 if the first frame is not a keyframe

392

393 return 0;

394 }

395

396 int ff_msmpeg4_decode_picture_header(MpegEncContext * s)

397 {

398 int code;

399

400 if(s->msmpeg4_version==1){

401 int start_code = get_bits_long(&s->gb, 32);

402 if(start_code!=0x00000100){

403 av_log(s->avctx, AV_LOG_ERROR, "invalid startcode\n");

404 return -1;

405 }

406

407 skip_bits(&s->gb, 5); // frame number */

408 }

409

410 s->pict_type = get_bits(&s->gb, 2) + 1;

411 if (s->pict_type != AV_PICTURE_TYPE_I &&

412 s->pict_type != AV_PICTURE_TYPE_P){

413 av_log(s->avctx, AV_LOG_ERROR, "invalid picture type\n");

414 return -1;

415 }

416 #if 0

417 {

418 static int had_i=0;

419 if(s->pict_type == AV_PICTURE_TYPE_I) had_i=1;

420 if(!had_i) return -1;

421 }

422 #endif

423 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);

424 if(s->qscale==0){

425 av_log(s->avctx, AV_LOG_ERROR, "invalid qscale\n");

426 return -1;

427 }

428

429 if (s->pict_type == AV_PICTURE_TYPE_I) {

430 code = get_bits(&s->gb, 5);

431 if(s->msmpeg4_version==1){

432 if(code==0 || code>s->mb_height){

433 av_log(s->avctx, AV_LOG_ERROR, "invalid slice height %d\n", code);

434 return -1;

435 }

436

437 s->slice_height = code;

438 }else{

439 /* 0x17: one slice, 0x18: two slices, ... */

440 if (code < 0x17){

441 av_log(s->avctx, AV_LOG_ERROR, "error, slice code was %X\n", code);

442 return -1;

443 }

444

445 s->slice_height = s->mb_height / (code - 0x16);

446 }

447

448 switch(s->msmpeg4_version){

449 case 1:

450 case 2:

451 s->rl_chroma_table_index = 2;

452 s->rl_table_index = 2;

453

454 s->dc_table_index = 0; //not used

455 break;

456 case 3:

457 s->rl_chroma_table_index = decode012(&s->gb);

458 s->rl_table_index = decode012(&s->gb);

459

460 s->dc_table_index = get_bits1(&s->gb);

461 break;

462 case 4:

463 ff_msmpeg4_decode_ext_header(s, (2+5+5+17+7)/8);

464

465 if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);

466 else s->per_mb_rl_table= 0;

467

468 if(!s->per_mb_rl_table){

469 s->rl_chroma_table_index = decode012(&s->gb);

470 s->rl_table_index = decode012(&s->gb);

471 }

472

473 s->dc_table_index = get_bits1(&s->gb);

474 s->inter_intra_pred= 0;

475 break;

476 }

477 s->no_rounding = 1;

478 if(s->avctx->debug&FF_DEBUG_PICT_INFO)

479 av_log(s->avctx, AV_LOG_DEBUG, "qscale:%d rlc:%d rl:%d dc:%d mbrl:%d slice:%d \n",

480 s->qscale,

481 s->rl_chroma_table_index,

482 s->rl_table_index,

483 s->dc_table_index,

484 s->per_mb_rl_table,

485 s->slice_height);

486 } else {

487 switch(s->msmpeg4_version){

488 case 1:

489 case 2:

490 if(s->msmpeg4_version==1)

491 s->use_skip_mb_code = 1;

492 else

493 s->use_skip_mb_code = get_bits1(&s->gb);

494 s->rl_table_index = 2;

495 s->rl_chroma_table_index = s->rl_table_index;

496 s->dc_table_index = 0; //not used

497 s->mv_table_index = 0;

498 break;

499 case 3:

500 s->use_skip_mb_code = get_bits1(&s->gb);

501 s->rl_table_index = decode012(&s->gb);

502 s->rl_chroma_table_index = s->rl_table_index;

503

504 s->dc_table_index = get_bits1(&s->gb);

505

506 s->mv_table_index = get_bits1(&s->gb);

507 break;

508 case 4:

509 s->use_skip_mb_code = get_bits1(&s->gb);

510

511 if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);

512 else s->per_mb_rl_table= 0;

513

514 if(!s->per_mb_rl_table){

515 s->rl_table_index = decode012(&s->gb);

516 s->rl_chroma_table_index = s->rl_table_index;

517 }

518

519 s->dc_table_index = get_bits1(&s->gb);

520

521 s->mv_table_index = get_bits1(&s->gb);

522 s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE);

523 break;

524 }

525

526 if(s->avctx->debug&FF_DEBUG_PICT_INFO)

527 av_log(s->avctx, AV_LOG_DEBUG, "skip:%d rl:%d rlc:%d dc:%d mv:%d mbrl:%d qp:%d \n",

528 s->use_skip_mb_code,

529 s->rl_table_index,

530 s->rl_chroma_table_index,

531 s->dc_table_index,

532 s->mv_table_index,

533 s->per_mb_rl_table,

534 s->qscale);

535

536 if(s->flipflop_rounding){

537 s->no_rounding ^= 1;

538 }else{

539 s->no_rounding = 0;

540 }

541 }

542 av_dlog(s->avctx, "%d %d %d %d %d\n", s->pict_type, s->bit_rate,

543 s->inter_intra_pred, s->width, s->height);

544

545 s->esc3_level_length= 0;

546 s->esc3_run_length= 0;

547

548 return 0;

549 }

550

551 int ff_msmpeg4_decode_ext_header(MpegEncContext * s, int buf_size)

552 {

553 int left= buf_size*8 - get_bits_count(&s->gb);

554 int length= s->msmpeg4_version>=3 ? 17 : 16;

555 /* the alt_bitstream reader could read over the end so we need to check it */

556 if(left>=length && left<length+8)

557 {

558 skip_bits(&s->gb, 5); /* fps */

559 s->bit_rate= get_bits(&s->gb, 11)*1024;

560 if(s->msmpeg4_version>=3)

561 s->flipflop_rounding= get_bits1(&s->gb);

562 else

563 s->flipflop_rounding= 0;

564 }

565 else if(left<length+8)

566 {

567 s->flipflop_rounding= 0;

568 if(s->msmpeg4_version != 2)

569 av_log(s->avctx, AV_LOG_ERROR, "ext header missing, %d left\n", left);

570 }

571 else

572 {

573 av_log(s->avctx, AV_LOG_ERROR, "I frame too long, ignoring ext header\n");

574 }

575

576 return 0;

577 }

578

579 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)

580 {

581 int level, pred;

582

583 if(s->msmpeg4_version<=2){

584 if (n < 4) {

585 level = get_vlc2(&s->gb, v2_dc_lum_vlc.table, DC_VLC_BITS, 3);

586 } else {

587 level = get_vlc2(&s->gb, v2_dc_chroma_vlc.table, DC_VLC_BITS, 3);

588 }

589 if (level < 0)

590 return -1;

591 level-=256;

592 }else{ //FIXME optimize use unified tables & index

593 if (n < 4) {

594 level = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);

595 } else {

596 level = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);

597 }

598 if (level < 0){

599 av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");

600 return -1;

601 }

602

603 if (level == DC_MAX) {

604 level = get_bits(&s->gb, 8);

605 if (get_bits1(&s->gb))

606 level = -level;

607 } else if (level != 0) {

608 if (get_bits1(&s->gb))

609 level = -level;

610 }

611 }

612

613 if(s->msmpeg4_version==1){

614 int32_t *dc_val;

615 pred = msmpeg4v1_pred_dc(s, n, &dc_val);

616 level += pred;

617

618 /* update predictor */

619 *dc_val= level;

620 }else{

621 int16_t *dc_val;

622 pred = ff_msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);

623 level += pred;

624

625 /* update predictor */

626 if (n < 4) {

627 *dc_val = level * s->y_dc_scale;

628 } else {

629 *dc_val = level * s->c_dc_scale;

630 }

631 }

632

633 return level;

634 }

635

636 //#define ERROR_DETAILS

637 int ff_msmpeg4_decode_block(MpegEncContext * s, int16_t * block,

638 int n, int coded, const uint8_t *scan_table)

639 {

640 int level, i, last, run, run_diff;

641 int av_uninit(dc_pred_dir);

642 RLTable *rl;

643 RL_VLC_ELEM *rl_vlc;

644 int qmul, qadd;

645

646 if (s->mb_intra) {

647 qmul=1;

648 qadd=0;

649

650 /* DC coef */

651 level = msmpeg4_decode_dc(s, n, &dc_pred_dir);

652

653 if (level < 0){

654 av_log(s->avctx, AV_LOG_ERROR, "dc overflow- block: %d qscale: %d//\n", n, s->qscale);

655 if(s->inter_intra_pred) level=0;

656 }

657 if (n < 4) {

658 rl = &ff_rl_table[s->rl_table_index];

659 if(level > 256*s->y_dc_scale){

660 av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ L qscale: %d//\n", s->qscale);

661 if(!s->inter_intra_pred) return -1;

662 }

663 } else {

664 rl = &ff_rl_table[3 + s->rl_chroma_table_index];

665 if(level > 256*s->c_dc_scale){

666 av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ C qscale: %d//\n", s->qscale);

667 if(!s->inter_intra_pred) return -1;

668 }

669 }

670 block[0] = level;

671

672 run_diff = s->msmpeg4_version >= 4;

673 i = 0;

674 if (!coded) {

675 goto not_coded;

676 }

677 if (s->ac_pred) {

678 if (dc_pred_dir == 0)

679 scan_table = s->intra_v_scantable.permutated; /* left */

680 else

681 scan_table = s->intra_h_scantable.permutated; /* top */

682 } else {

683 scan_table = s->intra_scantable.permutated;

684 }

685 rl_vlc= rl->rl_vlc[0];

686 } else {

687 qmul = s->qscale << 1;

688 qadd = (s->qscale - 1) | 1;

689 i = -1;

690 rl = &ff_rl_table[3 + s->rl_table_index];

691

692 if(s->msmpeg4_version==2)

693 run_diff = 0;

694 else

695 run_diff = 1;

696

697 if (!coded) {

698 s->block_last_index[n] = i;

699 return 0;

700 }

701 if(!scan_table)

702 scan_table = s->inter_scantable.permutated;

703 rl_vlc= rl->rl_vlc[s->qscale];

704 }

705 {

706 OPEN_READER(re, &s->gb);

707 for(;;) {

708 UPDATE_CACHE(re, &s->gb);

709 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);

710 if (level==0) {

711 int cache;

712 cache= GET_CACHE(re, &s->gb);

713 /* escape */

714 if (s->msmpeg4_version==1 || (cache&0x80000000)==0) {

715 if (s->msmpeg4_version==1 || (cache&0x40000000)==0) {

716 /* third escape */

717 if(s->msmpeg4_version!=1) LAST_SKIP_BITS(re, &s->gb, 2);

718 UPDATE_CACHE(re, &s->gb);

719 if(s->msmpeg4_version<=3){

720 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);

721 run= SHOW_UBITS(re, &s->gb, 6); SKIP_CACHE(re, &s->gb, 6);

722 level= SHOW_SBITS(re, &s->gb, 8);

723 SKIP_COUNTER(re, &s->gb, 1+6+8);

724 }else{

725 int sign;

726 last= SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);

727 if(!s->esc3_level_length){

728 int ll;

729 av_dlog(s->avctx, "ESC-3 %X at %d %d\n",

730 show_bits(&s->gb, 24), s->mb_x, s->mb_y);

731 if(s->qscale<8){

732 ll= SHOW_UBITS(re, &s->gb, 3); SKIP_BITS(re, &s->gb, 3);

733 if(ll==0){

734 ll= 8+SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);

735 }

736 }else{

737 ll=2;

738 while(ll<8 && SHOW_UBITS(re, &s->gb, 1)==0){

739 ll++;

740 SKIP_BITS(re, &s->gb, 1);

741 }

742 if(ll<8) SKIP_BITS(re, &s->gb, 1);

743 }

744

745 s->esc3_level_length= ll;

746 s->esc3_run_length= SHOW_UBITS(re, &s->gb, 2) + 3; SKIP_BITS(re, &s->gb, 2);

747 UPDATE_CACHE(re, &s->gb);

748 }

749 run= SHOW_UBITS(re, &s->gb, s->esc3_run_length);

750 SKIP_BITS(re, &s->gb, s->esc3_run_length);

751

752 sign= SHOW_UBITS(re, &s->gb, 1);

753 SKIP_BITS(re, &s->gb, 1);

754

755 level= SHOW_UBITS(re, &s->gb, s->esc3_level_length);

756 SKIP_BITS(re, &s->gb, s->esc3_level_length);

757 if(sign) level= -level;

758 }

759

760 #if 0 // waste of time / this will detect very few errors

761 {

762 const int abs_level= FFABS(level);

763 const int run1= run - rl->max_run[last][abs_level] - run_diff;

764 if(abs_level<=MAX_LEVEL && run<=MAX_RUN){

765 if(abs_level <= rl->max_level[last][run]){

766 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n");

767 return DECODING_AC_LOST;

768 }

769 if(abs_level <= rl->max_level[last][run]*2){

770 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\n");

771 return DECODING_AC_LOST;

772 }

773 if(run1>=0 && abs_level <= rl->max_level[last][run1]){

774 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\n");

775 return DECODING_AC_LOST;

776 }

777 }

778 }

779 #endif

780 //level = level * qmul + (level>0) * qadd - (level<=0) * qadd ;

781 if (level>0) level= level * qmul + qadd;

782 else level= level * qmul - qadd;

783 #if 0 // waste of time too :(

784 if(level>2048 || level<-2048){

785 av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc\n");

786 return DECODING_AC_LOST;

787 }

788 #endif

789 i+= run + 1;

790 if(last) i+=192;

791 #ifdef ERROR_DETAILS

792 if(run==66)

793 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC3 level=%d\n", level);

794 else if((i>62 && i<192) || i>192+63)

795 av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC3 i=%d run=%d level=%d\n", i, run, level);

796 #endif

797 } else {

798 /* second escape */

799 SKIP_BITS(re, &s->gb, 2);

800 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);

801 i+= run + rl->max_run[run>>7][level/qmul] + run_diff; //FIXME opt indexing

802 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);

803 LAST_SKIP_BITS(re, &s->gb, 1);

804 #ifdef ERROR_DETAILS

805 if(run==66)

806 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC2 level=%d\n", level);

807 else if((i>62 && i<192) || i>192+63)

808 av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC2 i=%d run=%d level=%d\n", i, run, level);

809 #endif

810 }

811 } else {

812 /* first escape */

813 SKIP_BITS(re, &s->gb, 1);

814 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);

815 i+= run;

816 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing

817 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);

818 LAST_SKIP_BITS(re, &s->gb, 1);

819 #ifdef ERROR_DETAILS

820 if(run==66)

821 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC1 level=%d\n", level);

822 else if((i>62 && i<192) || i>192+63)

823 av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC1 i=%d run=%d level=%d\n", i, run, level);

824 #endif

825 }

826 } else {

827 i+= run;

828 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);

829 LAST_SKIP_BITS(re, &s->gb, 1);

830 #ifdef ERROR_DETAILS

831 if(run==66)

832 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code level=%d\n", level);

833 else if((i>62 && i<192) || i>192+63)

834 av_log(s->avctx, AV_LOG_ERROR, "run overflow i=%d run=%d level=%d\n", i, run, level);

835 #endif

836 }

837 if (i > 62){

838 i-= 192;

839 if(i&(~63)){

840 const int left= get_bits_left(&s->gb);

841 if(((i+192 == 64 && level/qmul==-1) || !(s->err_recognition&(AV_EF_BITSTREAM|AV_EF_COMPLIANT))) && left>=0){

842 av_log(s->avctx, AV_LOG_ERROR, "ignoring overflow at %d %d\n", s->mb_x, s->mb_y);

843 i = 63;

844 break;

845 }else{

846 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);

847 return -1;

848 }

849 }

850

851 block[scan_table[i]] = level;

852 break;

853 }

854

855 block[scan_table[i]] = level;

856 }

857 CLOSE_READER(re, &s->gb);

858 }

859 not_coded:

860 if (s->mb_intra) {

861 ff_mpeg4_pred_ac(s, block, n, dc_pred_dir);

862 if (s->ac_pred) {

863 i = 63; /* XXX: not optimal */

864 }

865 }

866 if(s->msmpeg4_version>=4 && i>0) i=63; //FIXME/XXX optimize

867 s->block_last_index[n] = i;

868

869 return 0;

870 }

871

872 int ff_msmpeg4_decode_motion(MpegEncContext * s,

873 int *mx_ptr, int *my_ptr)

874 {

875 MVTable *mv;

876 int code, mx, my;

877

878 mv = &ff_mv_tables[s->mv_table_index];

879

880 code = get_vlc2(&s->gb, mv->vlc.table, MV_VLC_BITS, 2);

881 if (code < 0){

882 av_log(s->avctx, AV_LOG_ERROR, "illegal MV code at %d %d\n", s->mb_x, s->mb_y);

883 return -1;

884 }

885 if (code == mv->n) {

886 mx = get_bits(&s->gb, 6);

887 my = get_bits(&s->gb, 6);

888 } else {

889 mx = mv->table_mvx[code];

890 my = mv->table_mvy[code];

891 }

892

893 mx += *mx_ptr - 32;

894 my += *my_ptr - 32;

895 /* WARNING : they do not do exactly modulo encoding */

896 if (mx <= -64)

897 mx += 64;

898 else if (mx >= 64)

899 mx -= 64;

900

901 if (my <= -64)

902 my += 64;

903 else if (my >= 64)

904 my -= 64;

905 *mx_ptr = mx;

906 *my_ptr = my;

907 return 0;

908 }

909

910 AVCodec ff_msmpeg4v1_decoder = {

911 .name = "msmpeg4v1",

912 .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 1"),

913 .type = AVMEDIA_TYPE_VIDEO,

914 .id = AV_CODEC_ID_MSMPEG4V1,

915 .priv_data_size = sizeof(MpegEncContext),

916 .init = ff_msmpeg4_decode_init,

917 .close = ff_h263_decode_end,

918 .decode = ff_h263_decode_frame,

919 .capabilities = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,

920 .max_lowres = 3,

921 .pix_fmts = ff_pixfmt_list_420,

922 };

923

924 AVCodec ff_msmpeg4v2_decoder = {

925 .name = "msmpeg4v2",

926 .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"),

927 .type = AVMEDIA_TYPE_VIDEO,

928 .id = AV_CODEC_ID_MSMPEG4V2,

929 .priv_data_size = sizeof(MpegEncContext),

930 .init = ff_msmpeg4_decode_init,

931 .close = ff_h263_decode_end,

932 .decode = ff_h263_decode_frame,

933 .capabilities = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,

934 .max_lowres = 3,

935 .pix_fmts = ff_pixfmt_list_420,

936 };

937

938 AVCodec ff_msmpeg4v3_decoder = {

939 .name = "msmpeg4",

940 .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"),

941 .type = AVMEDIA_TYPE_VIDEO,

942 .id = AV_CODEC_ID_MSMPEG4V3,

943 .priv_data_size = sizeof(MpegEncContext),

944 .init = ff_msmpeg4_decode_init,

945 .close = ff_h263_decode_end,

946 .decode = ff_h263_decode_frame,

947 .capabilities = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,

948 .max_lowres = 3,

949 .pix_fmts = ff_pixfmt_list_420,

950 };

951

952 AVCodec ff_wmv1_decoder = {

953 .name = "wmv1",

954 .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 7"),

955 .type = AVMEDIA_TYPE_VIDEO,

956 .id = AV_CODEC_ID_WMV1,

957 .priv_data_size = sizeof(MpegEncContext),

958 .init = ff_msmpeg4_decode_init,

959 .close = ff_h263_decode_end,

960 .decode = ff_h263_decode_frame,

961 .capabilities = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,

962 .max_lowres = 3,

963 .pix_fmts = ff_pixfmt_list_420,

964 };

Generated on Sat Jan 25 2014 19:51:52 for FFmpeg by doxygen 1.8.2