FFmpeg: libavcodec/ituh263dec.c Source File

FFmpeg

[フレーム]

libavcodec

ituh263dec.c

Go to the documentation of this file.

1 /*

2 * ITU H.263 bitstream decoder

4 * H.263+ support.

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

26 * @file

27 * H.263 decoder.

28 */

30 #define UNCHECKED_BITSTREAM_READER 1

32 #include "config_components.h"

34 #include "libavutil/attributes.h"

35 #include "libavutil/imgutils.h"

36 #include "libavutil/internal.h"

37 #include "libavutil/mathematics.h"

38 #include "libavutil/mem_internal.h"

39 #include "libavutil/thread.h"

40 #include "avcodec.h"

41 #include "mpegvideo.h"

42 #include "h263.h"

43 #include "h263data.h"

44 #include "h263dec.h"

45 #include "mathops.h"

46 #include "mpegutils.h"

47 #include "unary.h"

48 #include "rv10dec.h"

49 #include "mpeg4video.h"

50 #include "mpegvideodata.h"

51 #include "mpegvideodec.h"

52 #include "mpeg4videodec.h"

53 #include "mpeg4videodefs.h"

55 // The defines below define the number of bits that are read at once for

56 // reading vlc values. Changing these may improve speed and data cache needs

57 // be aware though that decreasing them may need the number of stages that is

58 // passed to get_vlc* to be increased.

59 #define H263_MBTYPE_B_VLC_BITS 6

60 #define CBPC_B_VLC_BITS 3

62 static const int h263_mb_type_b_map[15]= {

63 MB_TYPE_DIRECT2 | MB_TYPE_L0L1,

64 MB_TYPE_DIRECT2 | MB_TYPE_L0L1 | MB_TYPE_CBP,

65 MB_TYPE_DIRECT2 | MB_TYPE_L0L1 | MB_TYPE_CBP | MB_TYPE_QUANT,

66 MB_TYPE_L0 | MB_TYPE_16x16,

67 MB_TYPE_L0 | MB_TYPE_CBP | MB_TYPE_16x16,

68 MB_TYPE_L0 | MB_TYPE_CBP | MB_TYPE_QUANT | MB_TYPE_16x16,

69 MB_TYPE_L1 | MB_TYPE_16x16,

70 MB_TYPE_L1 | MB_TYPE_CBP | MB_TYPE_16x16,

71 MB_TYPE_L1 | MB_TYPE_CBP | MB_TYPE_QUANT | MB_TYPE_16x16,

72 MB_TYPE_L0L1 | MB_TYPE_16x16,

73 MB_TYPE_L0L1 | MB_TYPE_CBP | MB_TYPE_16x16,

74 MB_TYPE_L0L1 | MB_TYPE_CBP | MB_TYPE_QUANT | MB_TYPE_16x16,

75 0, //stuffing

76 MB_TYPE_INTRA4x4 | MB_TYPE_CBP,

77 MB_TYPE_INTRA4x4 | MB_TYPE_CBP | MB_TYPE_QUANT,

78 };

80 void ff_h263_show_pict_info(MpegEncContext *s){

81 if(s->avctx->debug&FF_DEBUG_PICT_INFO){

82 av_log(s->avctx, AV_LOG_DEBUG, "qp:%d %c size:%d rnd:%d%s%s%s%s%s%s%s%s%s %d/%d\n",

83 s->qscale, av_get_picture_type_char(s->pict_type),

84 s->gb.size_in_bits, 1-s->no_rounding,

85 s->obmc ? " AP" : "",

86 s->umvplus ? " UMV" : "",

87 s->h263_long_vectors ? " LONG" : "",

88 s->h263_plus ? " +" : "",

89 s->h263_aic ? " AIC" : "",

90 s->alt_inter_vlc ? " AIV" : "",

91 s->modified_quant ? " MQ" : "",

92 s->loop_filter ? " LOOP" : "",

93 s->h263_slice_structured ? " SS" : "",

94 s->avctx->framerate.num, s->avctx->framerate.den

95 );

96 }

97 }

99 /***********************************************/

100 /* decoding */

101

102 VLC ff_h263_intra_MCBPC_vlc;

103 VLC ff_h263_inter_MCBPC_vlc;

104 VLC ff_h263_cbpy_vlc;

105 VLC ff_h263_mv_vlc;

106 static VLC h263_mbtype_b_vlc;

107 static VLC cbpc_b_vlc;

108

109 /* init vlcs */

110

111 static av_cold void h263_decode_init_vlc(void)

112 {

113 INIT_VLC_STATIC(&ff_h263_intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 9,

114 ff_h263_intra_MCBPC_bits, 1, 1,

115 ff_h263_intra_MCBPC_code, 1, 1, 72);

116 INIT_VLC_STATIC(&ff_h263_inter_MCBPC_vlc, INTER_MCBPC_VLC_BITS, 28,

117 ff_h263_inter_MCBPC_bits, 1, 1,

118 ff_h263_inter_MCBPC_code, 1, 1, 198);

119 INIT_VLC_STATIC(&ff_h263_cbpy_vlc, CBPY_VLC_BITS, 16,

120 &ff_h263_cbpy_tab[0][1], 2, 1,

121 &ff_h263_cbpy_tab[0][0], 2, 1, 64);

122 INIT_VLC_STATIC(&ff_h263_mv_vlc, H263_MV_VLC_BITS, 33,

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

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

125 ff_h263_init_rl_inter();

126 INIT_VLC_RL(ff_h263_rl_inter, 554);

127 INIT_FIRST_VLC_RL(ff_rl_intra_aic, 554);

128 INIT_VLC_STATIC(&h263_mbtype_b_vlc, H263_MBTYPE_B_VLC_BITS, 15,

129 &ff_h263_mbtype_b_tab[0][1], 2, 1,

130 &ff_h263_mbtype_b_tab[0][0], 2, 1, 80);

131 INIT_VLC_STATIC(&cbpc_b_vlc, CBPC_B_VLC_BITS, 4,

132 &ff_cbpc_b_tab[0][1], 2, 1,

133 &ff_cbpc_b_tab[0][0], 2, 1, 8);

134 }

135

136 av_cold void ff_h263_decode_init_vlc(void)

137 {

138 static AVOnce init_static_once = AV_ONCE_INIT;

139 ff_thread_once(&init_static_once, h263_decode_init_vlc);

140 }

141

142 int ff_h263_decode_mba(MpegEncContext *s)

143 {

144 int i, mb_pos;

145

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

147 if (s->mb_num - 1 <= ff_mba_max[i])

148 break;

149 mb_pos = get_bits(&s->gb, ff_mba_length[i]);

150 s->mb_x = mb_pos % s->mb_width;

151 s->mb_y = mb_pos / s->mb_width;

152

153 return mb_pos;

154 }

155

156 /**

157 * Decode the group of blocks header or slice header.

158 * @return <0 if an error occurred

159 */

160 static int h263_decode_gob_header(MpegEncContext *s)

161 {

162 unsigned int val, gob_number;

163 int left;

164

165 /* Check for GOB Start Code */

166 val = show_bits(&s->gb, 16);

167 if(val)

168 return -1;

169

170 /* We have a GBSC probably with GSTUFF */

171 skip_bits(&s->gb, 16); /* Drop the zeros */

172 left= get_bits_left(&s->gb);

173 left = FFMIN(left, 32);

174 //MN: we must check the bits left or we might end in an infinite loop (or segfault)

175 for(;left>13; left--){

176 if(get_bits1(&s->gb)) break; /* Seek the '1' bit */

177 }

178 if(left<=13)

179 return -1;

180

181 if(s->h263_slice_structured){

182 if(check_marker(s->avctx, &s->gb, "before MBA")==0)

183 return -1;

184

185 ff_h263_decode_mba(s);

186

187 if(s->mb_num > 1583)

188 if(check_marker(s->avctx, &s->gb, "after MBA")==0)

189 return -1;

190

191 s->qscale = get_bits(&s->gb, 5); /* SQUANT */

192 if(check_marker(s->avctx, &s->gb, "after SQUANT")==0)

193 return -1;

194 skip_bits(&s->gb, 2); /* GFID */

195 }else{

196 gob_number = get_bits(&s->gb, 5); /* GN */

197 s->mb_x= 0;

198 s->mb_y= s->gob_index* gob_number;

199 skip_bits(&s->gb, 2); /* GFID */

200 s->qscale = get_bits(&s->gb, 5); /* GQUANT */

201 }

202

203 if(s->mb_y >= s->mb_height)

204 return -1;

205

206 if(s->qscale==0)

207 return -1;

208

209 return 0;

210 }

211

212 /**

213 * Decode the group of blocks / video packet header / slice header (MPEG-4 Studio).

214 * @return bit position of the resync_marker, or <0 if none was found

215 */

216 int ff_h263_resync(MpegEncContext *s){

217 int left, pos, ret;

218

219 /* In MPEG-4 studio mode look for a new slice startcode

220 * and decode slice header */

221 if(s->codec_id==AV_CODEC_ID_MPEG4 && s->studio_profile) {

222 align_get_bits(&s->gb);

223

224 while (get_bits_left(&s->gb) >= 32 && show_bits_long(&s->gb, 32) != SLICE_STARTCODE) {

225 get_bits(&s->gb, 8);

226 }

227

228 if (get_bits_left(&s->gb) >= 32 && show_bits_long(&s->gb, 32) == SLICE_STARTCODE)

229 return get_bits_count(&s->gb);

230 else

231 return -1;

232 }

233

234 if(s->codec_id==AV_CODEC_ID_MPEG4){

235 skip_bits1(&s->gb);

236 align_get_bits(&s->gb);

237 }

238

239 if(show_bits(&s->gb, 16)==0){

240 pos= get_bits_count(&s->gb);

241 if(CONFIG_MPEG4_DECODER && s->codec_id==AV_CODEC_ID_MPEG4)

242 ret= ff_mpeg4_decode_video_packet_header(s->avctx->priv_data);

243 else

244 ret= h263_decode_gob_header(s);

245 if(ret>=0)

246 return pos;

247 }

248 //OK, it's not where it is supposed to be ...

249 s->gb= s->last_resync_gb;

250 align_get_bits(&s->gb);

251 left= get_bits_left(&s->gb);

252

253 for(;left>16+1+5+5; left-=8){

254 if(show_bits(&s->gb, 16)==0){

255 GetBitContext bak= s->gb;

256

257 pos= get_bits_count(&s->gb);

258 if(CONFIG_MPEG4_DECODER && s->codec_id==AV_CODEC_ID_MPEG4)

259 ret= ff_mpeg4_decode_video_packet_header(s->avctx->priv_data);

260 else

261 ret= h263_decode_gob_header(s);

262 if(ret>=0)

263 return pos;

264

265 s->gb= bak;

266 }

267 skip_bits(&s->gb, 8);

268 }

269

270 return -1;

271 }

272

273 int ff_h263_decode_motion(MpegEncContext * s, int pred, int f_code)

274 {

275 int code, val, sign, shift;

276 code = get_vlc2(&s->gb, ff_h263_mv_vlc.table, H263_MV_VLC_BITS, 2);

277

278 if (code == 0)

279 return pred;

280 if (code < 0)

281 return 0xffff;

282

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

284 shift = f_code - 1;

285 val = code;

286 if (shift) {

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

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

289 val++;

290 }

291 if (sign)

292 val = -val;

293 val += pred;

294

295 /* modulo decoding */

296 if (!s->h263_long_vectors) {

297 val = sign_extend(val, 5 + f_code);

298 } else {

299 /* horrible H.263 long vector mode */

300 if (pred < -31 && val < -63)

301 val += 64;

302 if (pred > 32 && val > 63)

303 val -= 64;

304

305 }

306 return val;

307 }

308

309

310 /* Decode RVLC of H.263+ UMV */

311 static int h263p_decode_umotion(MpegEncContext * s, int pred)

312 {

313 int code = 0, sign;

314

315 if (get_bits1(&s->gb)) /* Motion difference = 0 */

316 return pred;

317

318 code = 2 + get_bits1(&s->gb);

319

320 while (get_bits1(&s->gb))

321 {

322 code <<= 1;

323 code += get_bits1(&s->gb);

324 if (code >= 32768) {

325 avpriv_request_sample(s->avctx, "Huge DMV");

326 return 0xffff;

327 }

328 }

329 sign = code & 1;

330 code >>= 1;

331

332 code = (sign) ? (pred - code) : (pred + code);

333 ff_tlog(s->avctx,"H.263+ UMV Motion = %d\n", code);

334 return code;

335

336 }

337

338 /**

339 * read the next MVs for OBMC. yes this is an ugly hack, feel free to send a patch :)

340 */

341 static void preview_obmc(MpegEncContext *s){

342 GetBitContext gb= s->gb;

343

344 int cbpc, i, pred_x, pred_y, mx, my;

345 int16_t *mot_val;

346 const int xy= s->mb_x + 1 + s->mb_y * s->mb_stride;

347 const int stride= s->b8_stride*2;

348

349 for(i=0; i<4; i++)

350 s->block_index[i]+= 2;

351 for(i=4; i<6; i++)

352 s->block_index[i]+= 1;

353 s->mb_x++;

354

355 av_assert2(s->pict_type == AV_PICTURE_TYPE_P);

356

357 do{

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

359 /* skip mb */

360 mot_val = s->current_picture.motion_val[0][s->block_index[0]];

361 mot_val[0 ]= mot_val[2 ]=

362 mot_val[0+stride]= mot_val[2+stride]= 0;

363 mot_val[1 ]= mot_val[3 ]=

364 mot_val[1+stride]= mot_val[3+stride]= 0;

365

366 s->current_picture.mb_type[xy] = MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;

367 goto end;

368 }

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

370 }while(cbpc == 20);

371

372 if(cbpc & 4){

373 s->current_picture.mb_type[xy] = MB_TYPE_INTRA;

374 }else{

375 get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);

376 if (cbpc & 8) {

377 if(s->modified_quant){

378 if(get_bits1(&s->gb)) skip_bits(&s->gb, 1);

379 else skip_bits(&s->gb, 5);

380 }else

381 skip_bits(&s->gb, 2);

382 }

383

384 if ((cbpc & 16) == 0) {

385 s->current_picture.mb_type[xy] = MB_TYPE_16x16 | MB_TYPE_L0;

386 /* 16x16 motion prediction */

387 mot_val= ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);

388 if (s->umvplus)

389 mx = h263p_decode_umotion(s, pred_x);

390 else

391 mx = ff_h263_decode_motion(s, pred_x, 1);

392

393 if (s->umvplus)

394 my = h263p_decode_umotion(s, pred_y);

395 else

396 my = ff_h263_decode_motion(s, pred_y, 1);

397

398 mot_val[0 ]= mot_val[2 ]=

399 mot_val[0+stride]= mot_val[2+stride]= mx;

400 mot_val[1 ]= mot_val[3 ]=

401 mot_val[1+stride]= mot_val[3+stride]= my;

402 } else {

403 s->current_picture.mb_type[xy] = MB_TYPE_8x8 | MB_TYPE_L0;

404 for(i=0;i<4;i++) {

405 mot_val = ff_h263_pred_motion(s, i, 0, &pred_x, &pred_y);

406 if (s->umvplus)

407 mx = h263p_decode_umotion(s, pred_x);

408 else

409 mx = ff_h263_decode_motion(s, pred_x, 1);

410

411 if (s->umvplus)

412 my = h263p_decode_umotion(s, pred_y);

413 else

414 my = ff_h263_decode_motion(s, pred_y, 1);

415 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)

416 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */

417 mot_val[0] = mx;

418 mot_val[1] = my;

419 }

420 }

421 }

422 end:

423

424 for(i=0; i<4; i++)

425 s->block_index[i]-= 2;

426 for(i=4; i<6; i++)

427 s->block_index[i]-= 1;

428 s->mb_x--;

429

430 s->gb= gb;

431 }

432

433 static void h263_decode_dquant(MpegEncContext *s){

434 static const int8_t quant_tab[4] = { -1, -2, 1, 2 };

435

436 if(s->modified_quant){

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

438 s->qscale= ff_modified_quant_tab[get_bits1(&s->gb)][ s->qscale ];

439 else

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

441 }else

442 s->qscale += quant_tab[get_bits(&s->gb, 2)];

443 ff_set_qscale(s, s->qscale);

444 }

445

446 static void h263_pred_acdc(MpegEncContext * s, int16_t *block, int n)

447 {

448 int x, y, wrap, a, c, pred_dc, scale;

449 int16_t *dc_val, *ac_val, *ac_val1;

450

451 /* find prediction */

452 if (n < 4) {

453 x = 2 * s->mb_x + (n & 1);

454 y = 2 * s->mb_y + (n>> 1);

455 wrap = s->b8_stride;

456 dc_val = s->dc_val[0];

457 ac_val = s->ac_val[0][0];

458 scale = s->y_dc_scale;

459 } else {

460 x = s->mb_x;

461 y = s->mb_y;

462 wrap = s->mb_stride;

463 dc_val = s->dc_val[n - 4 + 1];

464 ac_val = s->ac_val[n - 4 + 1][0];

465 scale = s->c_dc_scale;

466 }

467

468 ac_val += ((y) * wrap + (x)) * 16;

469 ac_val1 = ac_val;

470

471 /* B C

472 * A X

473 */

474 a = dc_val[(x - 1) + (y) * wrap];

475 c = dc_val[(x) + (y - 1) * wrap];

476

477 /* No prediction outside GOB boundary */

478 if (s->first_slice_line && n != 3) {

479 if (n != 2) c= 1024;

480 if (n != 1 && s->mb_x == s->resync_mb_x) a= 1024;

481 }

482

483 if (s->ac_pred) {

484 pred_dc = 1024;

485 if (s->h263_aic_dir) {

486 /* left prediction */

487 if (a != 1024) {

488 ac_val -= 16;

489 for (int i = 1; i < 8; i++) {

490 block[s->idsp.idct_permutation[i << 3]] += ac_val[i];

491 }

492 pred_dc = a;

493 }

494 } else {

495 /* top prediction */

496 if (c != 1024) {

497 ac_val -= 16 * wrap;

498 for (int i = 1; i < 8; i++) {

499 block[s->idsp.idct_permutation[i]] += ac_val[i + 8];

500 }

501 pred_dc = c;

502 }

503 }

504 } else {

505 /* just DC prediction */

506 if (a != 1024 && c != 1024)

507 pred_dc = (a + c) >> 1;

508 else if (a != 1024)

509 pred_dc = a;

510 else

511 pred_dc = c;

512 }

513

514 /* we assume pred is positive */

515 block[0] = block[0] * scale + pred_dc;

516

517 if (block[0] < 0)

518 block[0] = 0;

519 else

520 block[0] |= 1;

521

522 /* Update AC/DC tables */

523 dc_val[(x) + (y) * wrap] = block[0];

524

525 /* left copy */

526 for (int i = 1; i < 8; i++)

527 ac_val1[i] = block[s->idsp.idct_permutation[i << 3]];

528 /* top copy */

529 for (int i = 1; i < 8; i++)

530 ac_val1[8 + i] = block[s->idsp.idct_permutation[i]];

531 }

532

533 static int h263_decode_block(MpegEncContext * s, int16_t * block,

534 int n, int coded)

535 {

536 int level, i, j, run;

537 RLTable *rl = &ff_h263_rl_inter;

538 const uint8_t *scan_table;

539 GetBitContext gb= s->gb;

540

541 scan_table = s->intra_scantable.permutated;

542 if (s->h263_aic && s->mb_intra) {

543 rl = &ff_rl_intra_aic;

544 i = 0;

545 if (s->ac_pred) {

546 if (s->h263_aic_dir)

547 scan_table = s->permutated_intra_v_scantable; /* left */

548 else

549 scan_table = s->permutated_intra_h_scantable; /* top */

550 }

551 } else if (s->mb_intra) {

552 /* DC coef */

553 if (CONFIG_RV10_DECODER && s->codec_id == AV_CODEC_ID_RV10) {

554 if (s->rv10_version == 3 && s->pict_type == AV_PICTURE_TYPE_I) {

555 int component, diff;

556 component = (n <= 3 ? 0 : n - 4 + 1);

557 level = s->last_dc[component];

558 if (s->rv10_first_dc_coded[component]) {

559 diff = ff_rv_decode_dc(s, n);

560 if (diff < 0)

561 return -1;

562 level += diff;

563 level = level & 0xff; /* handle wrap round */

564 s->last_dc[component] = level;

565 } else {

566 s->rv10_first_dc_coded[component] = 1;

567 }

568 } else {

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

570 if (level == 255)

571 level = 128;

572 }

573 }else{

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

575 if((level&0x7F) == 0){

576 av_log(s->avctx, AV_LOG_ERROR, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y);

577 if (s->avctx->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT))

578 return -1;

579 }

580 if (level == 255)

581 level = 128;

582 }

583 block[0] = level;

584 i = 1;

585 } else {

586 i = 0;

587 }

588 if (!coded) {

589 if (s->mb_intra && s->h263_aic)

590 goto not_coded;

591 s->block_last_index[n] = i - 1;

592 return 0;

593 }

594 retry:

595 {

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

597 i--; // offset by -1 to allow direct indexing of scan_table

598 for(;;) {

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

600 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);

601 if (run == 66) {

602 if (level){

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

604 av_log(s->avctx, AV_LOG_ERROR, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y);

605 return -1;

606 }

607 /* escape */

608 if (CONFIG_FLV_DECODER && s->h263_flv > 1) {

609 int is11 = SHOW_UBITS(re, &s->gb, 1);

610 SKIP_CACHE(re, &s->gb, 1);

611 run = SHOW_UBITS(re, &s->gb, 7) + 1;

612 if (is11) {

613 SKIP_COUNTER(re, &s->gb, 1 + 7);

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

615 level = SHOW_SBITS(re, &s->gb, 11);

616 SKIP_COUNTER(re, &s->gb, 11);

617 } else {

618 SKIP_CACHE(re, &s->gb, 7);

619 level = SHOW_SBITS(re, &s->gb, 7);

620 SKIP_COUNTER(re, &s->gb, 1 + 7 + 7);

621 }

622 } else {

623 run = SHOW_UBITS(re, &s->gb, 7) + 1;

624 SKIP_CACHE(re, &s->gb, 7);

625 level = (int8_t)SHOW_UBITS(re, &s->gb, 8);

626 SKIP_COUNTER(re, &s->gb, 7 + 8);

627 if(level == -128){

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

629 if (s->codec_id == AV_CODEC_ID_RV10) {

630 /* XXX: should patch encoder too */

631 level = SHOW_SBITS(re, &s->gb, 12);

632 SKIP_COUNTER(re, &s->gb, 12);

633 }else{

634 level = SHOW_UBITS(re, &s->gb, 5);

635 SKIP_CACHE(re, &s->gb, 5);

636 level |= SHOW_SBITS(re, &s->gb, 6) * (1<<5);

637 SKIP_COUNTER(re, &s->gb, 5 + 6);

638 }

639 }

640 }

641 } else {

642 if (SHOW_UBITS(re, &s->gb, 1))

643 level = -level;

644 SKIP_COUNTER(re, &s->gb, 1);

645 }

646 i += run;

647 if (i >= 64){

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

649 // redo update without last flag, revert -1 offset

650 i = i - run + ((run-1)&63) + 1;

651 if (i < 64) {

652 // only last marker, no overrun

653 block[scan_table[i]] = level;

654 break;

655 }

656 if(s->alt_inter_vlc && rl == &ff_h263_rl_inter && !s->mb_intra){

657 //Looks like a hack but no, it's the way it is supposed to work ...

658 rl = &ff_rl_intra_aic;

659 i = 0;

660 s->gb= gb;

661 s->bdsp.clear_block(block);

662 goto retry;

663 }

664 av_log(s->avctx, AV_LOG_ERROR, "run overflow at %dx%d i:%d\n", s->mb_x, s->mb_y, s->mb_intra);

665 return -1;

666 }

667 j = scan_table[i];

668 block[j] = level;

669 }

670 }

671 not_coded:

672 if (s->mb_intra && s->h263_aic) {

673 h263_pred_acdc(s, block, n);

674 i = 63;

675 }

676 s->block_last_index[n] = i;

677 return 0;

678 }

679

680 static int h263_skip_b_part(MpegEncContext *s, int cbp)

681 {

682 LOCAL_ALIGNED_32(int16_t, dblock, [64]);

683 int i, mbi;

684 int bli[6];

685

686 /* we have to set s->mb_intra to zero to decode B-part of PB-frame correctly

687 * but real value should be restored in order to be used later (in OBMC condition)

688 */

689 mbi = s->mb_intra;

690 memcpy(bli, s->block_last_index, sizeof(bli));

691 s->mb_intra = 0;

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

693 if (h263_decode_block(s, dblock, i, cbp&32) < 0)

694 return -1;

695 cbp+=cbp;

696 }

697 s->mb_intra = mbi;

698 memcpy(s->block_last_index, bli, sizeof(bli));

699 return 0;

700 }

701

702 static int h263_get_modb(GetBitContext *gb, int pb_frame, int *cbpb)

703 {

704 int c, mv = 1;

705

706 if (pb_frame < 3) { // h.263 Annex G and i263 PB-frame

707 c = get_bits1(gb);

708 if (pb_frame == 2 && c)

709 mv = !get_bits1(gb);

710 } else { // h.263 Annex M improved PB-frame

711 mv = get_unary(gb, 0, 4) + 1;

712 c = mv & 1;

713 mv = !!(mv & 2);

714 }

715 if(c)

716 *cbpb = get_bits(gb, 6);

717 return mv;

718 }

719

720 #define tab_size ((signed)FF_ARRAY_ELEMS(s->direct_scale_mv[0]))

721 #define tab_bias (tab_size / 2)

722 static inline void set_one_direct_mv(MpegEncContext *s, Picture *p, int i)

723 {

724 int xy = s->block_index[i];

725 uint16_t time_pp = s->pp_time;

726 uint16_t time_pb = s->pb_time;

727 int p_mx, p_my;

728

729 p_mx = p->motion_val[0][xy][0];

730 if ((unsigned)(p_mx + tab_bias) < tab_size) {

731 s->mv[0][i][0] = s->direct_scale_mv[0][p_mx + tab_bias];

732 s->mv[1][i][0] = s->direct_scale_mv[1][p_mx + tab_bias];

733 } else {

734 s->mv[0][i][0] = p_mx * time_pb / time_pp;

735 s->mv[1][i][0] = p_mx * (time_pb - time_pp) / time_pp;

736 }

737 p_my = p->motion_val[0][xy][1];

738 if ((unsigned)(p_my + tab_bias) < tab_size) {

739 s->mv[0][i][1] = s->direct_scale_mv[0][p_my + tab_bias];

740 s->mv[1][i][1] = s->direct_scale_mv[1][p_my + tab_bias];

741 } else {

742 s->mv[0][i][1] = p_my * time_pb / time_pp;

743 s->mv[1][i][1] = p_my * (time_pb - time_pp) / time_pp;

744 }

745 }

746

747 /**

748 * @return the mb_type

749 */

750 static int set_direct_mv(MpegEncContext *s)

751 {

752 const int mb_index = s->mb_x + s->mb_y * s->mb_stride;

753 Picture *p = &s->next_picture;

754 int colocated_mb_type = p->mb_type[mb_index];

755 int i;

756

757 if (s->codec_tag == AV_RL32("U263") && p->f->pict_type == AV_PICTURE_TYPE_I) {

758 p = &s->last_picture;

759 colocated_mb_type = p->mb_type[mb_index];

760 }

761

762 if (IS_8X8(colocated_mb_type)) {

763 s->mv_type = MV_TYPE_8X8;

764 for (i = 0; i < 4; i++)

765 set_one_direct_mv(s, p, i);

766 return MB_TYPE_DIRECT2 | MB_TYPE_8x8 | MB_TYPE_L0L1;

767 } else {

768 set_one_direct_mv(s, p, 0);

769 s->mv[0][1][0] =

770 s->mv[0][2][0] =

771 s->mv[0][3][0] = s->mv[0][0][0];

772 s->mv[0][1][1] =

773 s->mv[0][2][1] =

774 s->mv[0][3][1] = s->mv[0][0][1];

775 s->mv[1][1][0] =

776 s->mv[1][2][0] =

777 s->mv[1][3][0] = s->mv[1][0][0];

778 s->mv[1][1][1] =

779 s->mv[1][2][1] =

780 s->mv[1][3][1] = s->mv[1][0][1];

781 s->mv_type = MV_TYPE_8X8;

782 // Note see prev line

783 return MB_TYPE_DIRECT2 | MB_TYPE_16x16 | MB_TYPE_L0L1;

784 }

785 }

786

787 int ff_h263_decode_mb(MpegEncContext *s,

788 int16_t block[6][64])

789 {

790 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;

791 int16_t *mot_val;

792 const int xy= s->mb_x + s->mb_y * s->mb_stride;

793 int cbpb = 0, pb_mv_count = 0;

794

795 av_assert2(!s->h263_pred);

796

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

798 do{

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

800 /* skip mb */

801 s->mb_intra = 0;

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

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

804 s->mv_dir = MV_DIR_FORWARD;

805 s->mv_type = MV_TYPE_16X16;

806 s->current_picture.mb_type[xy] = MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;

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

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

809 s->mb_skipped = !(s->obmc | s->loop_filter);

810 goto end;

811 }

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

813 if (cbpc < 0){

814 av_log(s->avctx, AV_LOG_ERROR, "cbpc damaged at %d %d\n", s->mb_x, s->mb_y);

815 return SLICE_ERROR;

816 }

817 }while(cbpc == 20);

818

819 s->bdsp.clear_blocks(s->block[0]);

820

821 dquant = cbpc & 8;

822 s->mb_intra = ((cbpc & 4) != 0);

823 if (s->mb_intra) goto intra;

824

825 if(s->pb_frame && get_bits1(&s->gb))

826 pb_mv_count = h263_get_modb(&s->gb, s->pb_frame, &cbpb);

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

828

829 if (cbpy < 0) {

830 av_log(s->avctx, AV_LOG_ERROR, "cbpy damaged at %d %d\n", s->mb_x, s->mb_y);

831 return SLICE_ERROR;

832 }

833

834 if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)

835 cbpy ^= 0xF;

836

837 cbp = (cbpc & 3) | (cbpy << 2);

838 if (dquant) {

839 h263_decode_dquant(s);

840 }

841

842 s->mv_dir = MV_DIR_FORWARD;

843 if ((cbpc & 16) == 0) {

844 s->current_picture.mb_type[xy] = MB_TYPE_16x16 | MB_TYPE_L0;

845 /* 16x16 motion prediction */

846 s->mv_type = MV_TYPE_16X16;

847 ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);

848 if (s->umvplus)

849 mx = h263p_decode_umotion(s, pred_x);

850 else

851 mx = ff_h263_decode_motion(s, pred_x, 1);

852

853 if (mx >= 0xffff)

854 return SLICE_ERROR;

855

856 if (s->umvplus)

857 my = h263p_decode_umotion(s, pred_y);

858 else

859 my = ff_h263_decode_motion(s, pred_y, 1);

860

861 if (my >= 0xffff)

862 return SLICE_ERROR;

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

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

865

866 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)

867 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */

868 } else {

869 s->current_picture.mb_type[xy] = MB_TYPE_8x8 | MB_TYPE_L0;

870 s->mv_type = MV_TYPE_8X8;

871 for(i=0;i<4;i++) {

872 mot_val = ff_h263_pred_motion(s, i, 0, &pred_x, &pred_y);

873 if (s->umvplus)

874 mx = h263p_decode_umotion(s, pred_x);

875 else

876 mx = ff_h263_decode_motion(s, pred_x, 1);

877 if (mx >= 0xffff)

878 return SLICE_ERROR;

879

880 if (s->umvplus)

881 my = h263p_decode_umotion(s, pred_y);

882 else

883 my = ff_h263_decode_motion(s, pred_y, 1);

884 if (my >= 0xffff)

885 return SLICE_ERROR;

886 s->mv[0][i][0] = mx;

887 s->mv[0][i][1] = my;

888 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)

889 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */

890 mot_val[0] = mx;

891 mot_val[1] = my;

892 }

893 }

894 } else if(s->pict_type==AV_PICTURE_TYPE_B) {

895 int mb_type;

896 const int stride= s->b8_stride;

897 int16_t *mot_val0 = s->current_picture.motion_val[0][2 * (s->mb_x + s->mb_y * stride)];

898 int16_t *mot_val1 = s->current_picture.motion_val[1][2 * (s->mb_x + s->mb_y * stride)];

899 // const int mv_xy= s->mb_x + 1 + s->mb_y * s->mb_stride;

900

901 //FIXME ugly

902 mot_val0[0 ]= mot_val0[2 ]= mot_val0[0+2*stride]= mot_val0[2+2*stride]=

903 mot_val0[1 ]= mot_val0[3 ]= mot_val0[1+2*stride]= mot_val0[3+2*stride]=

904 mot_val1[0 ]= mot_val1[2 ]= mot_val1[0+2*stride]= mot_val1[2+2*stride]=

905 mot_val1[1 ]= mot_val1[3 ]= mot_val1[1+2*stride]= mot_val1[3+2*stride]= 0;

906

907 do{

908 mb_type= get_vlc2(&s->gb, h263_mbtype_b_vlc.table, H263_MBTYPE_B_VLC_BITS, 2);

909 if (mb_type < 0){

910 av_log(s->avctx, AV_LOG_ERROR, "b mb_type damaged at %d %d\n", s->mb_x, s->mb_y);

911 return SLICE_ERROR;

912 }

913

914 mb_type= h263_mb_type_b_map[ mb_type ];

915 }while(!mb_type);

916

917 s->mb_intra = IS_INTRA(mb_type);

918 if(HAS_CBP(mb_type)){

919 s->bdsp.clear_blocks(s->block[0]);

920 cbpc = get_vlc2(&s->gb, cbpc_b_vlc.table, CBPC_B_VLC_BITS, 1);

921 if(s->mb_intra){

922 dquant = IS_QUANT(mb_type);

923 goto intra;

924 }

925

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

927

928 if (cbpy < 0){

929 av_log(s->avctx, AV_LOG_ERROR, "b cbpy damaged at %d %d\n", s->mb_x, s->mb_y);

930 return SLICE_ERROR;

931 }

932

933 if(s->alt_inter_vlc==0 || (cbpc & 3)!=3)

934 cbpy ^= 0xF;

935

936 cbp = (cbpc & 3) | (cbpy << 2);

937 }else

938 cbp=0;

939

940 av_assert2(!s->mb_intra);

941

942 if(IS_QUANT(mb_type)){

943 h263_decode_dquant(s);

944 }

945

946 if(IS_DIRECT(mb_type)){

947 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;

948 mb_type |= set_direct_mv(s);

949 }else{

950 s->mv_dir = 0;

951 s->mv_type= MV_TYPE_16X16;

952 //FIXME UMV

953

954 if(USES_LIST(mb_type, 0)){

955 int16_t *mot_val= ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);

956 s->mv_dir = MV_DIR_FORWARD;

957

958 if (s->umvplus)

959 mx = h263p_decode_umotion(s, pred_x);

960 else

961 mx = ff_h263_decode_motion(s, pred_x, 1);

962 if (mx >= 0xffff)

963 return SLICE_ERROR;

964

965 if (s->umvplus)

966 my = h263p_decode_umotion(s, pred_y);

967 else

968 my = ff_h263_decode_motion(s, pred_y, 1);

969 if (my >= 0xffff)

970 return SLICE_ERROR;

971

972 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)

973 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */

974

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

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

977 mot_val[0 ]= mot_val[2 ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;

978 mot_val[1 ]= mot_val[3 ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;

979 }

980

981 if(USES_LIST(mb_type, 1)){

982 int16_t *mot_val= ff_h263_pred_motion(s, 0, 1, &pred_x, &pred_y);

983 s->mv_dir |= MV_DIR_BACKWARD;

984

985 if (s->umvplus)

986 mx = h263p_decode_umotion(s, pred_x);

987 else

988 mx = ff_h263_decode_motion(s, pred_x, 1);

989 if (mx >= 0xffff)

990 return SLICE_ERROR;

991

992 if (s->umvplus)

993 my = h263p_decode_umotion(s, pred_y);

994 else

995 my = ff_h263_decode_motion(s, pred_y, 1);

996 if (my >= 0xffff)

997 return SLICE_ERROR;

998

999 if (s->umvplus && (mx - pred_x) == 1 && (my - pred_y) == 1)

1000 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */

1001

1002 s->mv[1][0][0] = mx;

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

1004 mot_val[0 ]= mot_val[2 ]= mot_val[0+2*stride]= mot_val[2+2*stride]= mx;

1005 mot_val[1 ]= mot_val[3 ]= mot_val[1+2*stride]= mot_val[3+2*stride]= my;

1006 }

1007 }

1008

1009 s->current_picture.mb_type[xy] = mb_type;

1010 } else { /* I-Frame */

1011 do{

1012 cbpc = get_vlc2(&s->gb, ff_h263_intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 2);

1013 if (cbpc < 0){

1014 av_log(s->avctx, AV_LOG_ERROR, "I cbpc damaged at %d %d\n", s->mb_x, s->mb_y);

1015 return SLICE_ERROR;

1016 }

1017 }while(cbpc == 8);

1018

1019 s->bdsp.clear_blocks(s->block[0]);

1020

1021 dquant = cbpc & 4;

1022 s->mb_intra = 1;

1023 intra:

1024 s->current_picture.mb_type[xy] = MB_TYPE_INTRA;

1025 if (s->h263_aic) {

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

1027 if(s->ac_pred){

1028 s->current_picture.mb_type[xy] = MB_TYPE_INTRA | MB_TYPE_ACPRED;

1029

1030 s->h263_aic_dir = get_bits1(&s->gb);

1031 }

1032 }else

1033 s->ac_pred = 0;

1034

1035 if(s->pb_frame && get_bits1(&s->gb))

1036 pb_mv_count = h263_get_modb(&s->gb, s->pb_frame, &cbpb);

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

1038 if(cbpy<0){

1039 av_log(s->avctx, AV_LOG_ERROR, "I cbpy damaged at %d %d\n", s->mb_x, s->mb_y);

1040 return SLICE_ERROR;

1041 }

1042 cbp = (cbpc & 3) | (cbpy << 2);

1043 if (dquant) {

1044 h263_decode_dquant(s);

1045 }

1046

1047 pb_mv_count += !!s->pb_frame;

1048 }

1049

1050 while(pb_mv_count--){

1051 ff_h263_decode_motion(s, 0, 1);

1052 ff_h263_decode_motion(s, 0, 1);

1053 }

1054

1055 /* decode each block */

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

1057 if (h263_decode_block(s, block[i], i, cbp&32) < 0)

1058 return -1;

1059 cbp+=cbp;

1060 }

1061

1062 if(s->pb_frame && h263_skip_b_part(s, cbpb) < 0)

1063 return -1;

1064 if(s->obmc && !s->mb_intra){

1065 if(s->pict_type == AV_PICTURE_TYPE_P && s->mb_x+1<s->mb_width && s->mb_num_left != 1)

1066 preview_obmc(s);

1067 }

1068 end:

1069

1070 if (get_bits_left(&s->gb) < 0)

1071 return AVERROR_INVALIDDATA;

1072

1073 /* per-MB end of slice check */

1074 {

1075 int v= show_bits(&s->gb, 16);

1076

1077 if (get_bits_left(&s->gb) < 16) {

1078 v >>= 16 - get_bits_left(&s->gb);

1079 }

1080

1081 if(v==0)

1082 return SLICE_END;

1083 }

1084

1085 return SLICE_OK;

1086 }

1087

1088 /* Most is hardcoded; should extend to handle all H.263 streams. */

1089 int ff_h263_decode_picture_header(MpegEncContext *s)

1090 {

1091 int format, width, height, i, ret;

1092 uint32_t startcode;

1093

1094 align_get_bits(&s->gb);

1095

1096 if (show_bits(&s->gb, 2) == 2 && s->avctx->frame_num == 0) {

1097 av_log(s->avctx, AV_LOG_WARNING, "Header looks like RTP instead of H.263\n");

1098 }

1099

1100 startcode= get_bits(&s->gb, 22-8);

1101

1102 for(i= get_bits_left(&s->gb); i>24; i-=8) {

1103 startcode = ((startcode << 8) | get_bits(&s->gb, 8)) & 0x003FFFFF;

1104

1105 if(startcode == 0x20)

1106 break;

1107 }

1108

1109 if (startcode != 0x20) {

1110 av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");

1111 return -1;

1112 }

1113 /* temporal reference */

1114 i = get_bits(&s->gb, 8); /* picture timestamp */

1115

1116 i -= (i - (s->picture_number & 0xFF) + 128) & ~0xFF;

1117

1118 s->picture_number= (s->picture_number&~0xFF) + i;

1119

1120 /* PTYPE starts here */

1121 if (check_marker(s->avctx, &s->gb, "in PTYPE") != 1) {

1122 return -1;

1123 }

1124 if (get_bits1(&s->gb) != 0) {

1125 av_log(s->avctx, AV_LOG_ERROR, "Bad H.263 id\n");

1126 return -1; /* H.263 id */

1127 }

1128 skip_bits1(&s->gb); /* split screen off */

1129 skip_bits1(&s->gb); /* camera off */

1130 skip_bits1(&s->gb); /* freeze picture release off */

1131

1132 format = get_bits(&s->gb, 3);

1133 /*

1134 0 forbidden

1135 1 sub-QCIF

1136 10 QCIF

1137 7 extended PTYPE (PLUSPTYPE)

1138 */

1139

1140 if (format != 7 && format != 6) {

1141 s->h263_plus = 0;

1142 /* H.263v1 */

1143 width = ff_h263_format[format][0];

1144 height = ff_h263_format[format][1];

1145 if (!width)

1146 return -1;

1147

1148 s->pict_type = AV_PICTURE_TYPE_I + get_bits1(&s->gb);

1149

1150 s->h263_long_vectors = get_bits1(&s->gb);

1151

1152 if (get_bits1(&s->gb) != 0) {

1153 av_log(s->avctx, AV_LOG_ERROR, "H.263 SAC not supported\n");

1154 return -1; /* SAC: off */

1155 }

1156 s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */

1157

1158 s->pb_frame = get_bits1(&s->gb);

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

1160 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */

1161

1162 s->width = width;

1163 s->height = height;

1164 s->avctx->sample_aspect_ratio= (AVRational){12,11};

1165 s->avctx->framerate = (AVRational){ 30000, 1001 };

1166 } else {

1167 int ufep;

1168

1169 /* H.263v2 */

1170 s->h263_plus = 1;

1171 ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */

1172

1173 /* ufep other than 0 and 1 are reserved */

1174 if (ufep == 1) {

1175 /* OPPTYPE */

1176 format = get_bits(&s->gb, 3);

1177 ff_dlog(s->avctx, "ufep=1, format: %d\n", format);

1178 s->custom_pcf= get_bits1(&s->gb);

1179 s->umvplus = get_bits1(&s->gb); /* Unrestricted Motion Vector */

1180 if (get_bits1(&s->gb) != 0) {

1181 av_log(s->avctx, AV_LOG_ERROR, "Syntax-based Arithmetic Coding (SAC) not supported\n");

1182 }

1183 s->obmc= get_bits1(&s->gb); /* Advanced prediction mode */

1184 s->h263_aic = get_bits1(&s->gb); /* Advanced Intra Coding (AIC) */

1185 s->loop_filter= get_bits1(&s->gb);

1186 if(s->avctx->lowres)

1187 s->loop_filter = 0;

1188

1189 s->h263_slice_structured= get_bits1(&s->gb);

1190 if (get_bits1(&s->gb) != 0) {

1191 av_log(s->avctx, AV_LOG_ERROR, "Reference Picture Selection not supported\n");

1192 }

1193 if (get_bits1(&s->gb) != 0) {

1194 av_log(s->avctx, AV_LOG_ERROR, "Independent Segment Decoding not supported\n");

1195 }

1196 s->alt_inter_vlc= get_bits1(&s->gb);

1197 s->modified_quant= get_bits1(&s->gb);

1198 if(s->modified_quant)

1199 s->chroma_qscale_table= ff_h263_chroma_qscale_table;

1200

1201 skip_bits(&s->gb, 1); /* Prevent start code emulation */

1202

1203 skip_bits(&s->gb, 3); /* Reserved */

1204 } else if (ufep != 0) {

1205 av_log(s->avctx, AV_LOG_ERROR, "Bad UFEP type (%d)\n", ufep);

1206 return -1;

1207 }

1208

1209 /* MPPTYPE */

1210 s->pict_type = get_bits(&s->gb, 3);

1211 switch(s->pict_type){

1212 case 0: s->pict_type= AV_PICTURE_TYPE_I;break;

1213 case 1: s->pict_type= AV_PICTURE_TYPE_P;break;

1214 case 2: s->pict_type= AV_PICTURE_TYPE_P;s->pb_frame = 3;break;

1215 case 3: s->pict_type= AV_PICTURE_TYPE_B;break;

1216 case 7: s->pict_type= AV_PICTURE_TYPE_I;break; //ZYGO

1217 default:

1218 return -1;

1219 }

1220 skip_bits(&s->gb, 2);

1221 s->no_rounding = get_bits1(&s->gb);

1222 skip_bits(&s->gb, 4);

1223

1224 /* Get the picture dimensions */

1225 if (ufep) {

1226 if (format == 6) {

1227 /* Custom Picture Format (CPFMT) */

1228 int aspect_ratio_info = get_bits(&s->gb, 4);

1229 ff_dlog(s->avctx, "aspect: %d\n", aspect_ratio_info);

1230 /* aspect ratios:

1231 0 - forbidden

1232 1 - 1:1

1233 2 - 12:11 (CIF 4:3)

1234 3 - 10:11 (525-type 4:3)

1235 4 - 16:11 (CIF 16:9)

1236 5 - 40:33 (525-type 16:9)

1237 6-14 - reserved

1238 */

1239 width = (get_bits(&s->gb, 9) + 1) * 4;

1240 check_marker(s->avctx, &s->gb, "in dimensions");

1241 height = get_bits(&s->gb, 9) * 4;

1242 ff_dlog(s->avctx, "\nH.263+ Custom picture: %dx%d\n",width,height);

1243 if (aspect_ratio_info == FF_ASPECT_EXTENDED) {

1244 /* expected dimensions */

1245 s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 8);

1246 s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 8);

1247 }else{

1248 s->avctx->sample_aspect_ratio= ff_h263_pixel_aspect[aspect_ratio_info];

1249 }

1250 } else {

1251 width = ff_h263_format[format][0];

1252 height = ff_h263_format[format][1];

1253 s->avctx->sample_aspect_ratio= (AVRational){12,11};

1254 }

1255 s->avctx->sample_aspect_ratio.den <<= s->ehc_mode;

1256 if ((width == 0) || (height == 0))

1257 return -1;

1258 s->width = width;

1259 s->height = height;

1260

1261 if(s->custom_pcf){

1262 int gcd;

1263 s->avctx->framerate.num = 1800000;

1264 s->avctx->framerate.den = 1000 + get_bits1(&s->gb);

1265 s->avctx->framerate.den *= get_bits(&s->gb, 7);

1266 if(s->avctx->framerate.den == 0){

1267 av_log(s, AV_LOG_ERROR, "zero framerate\n");

1268 return -1;

1269 }

1270 gcd= av_gcd(s->avctx->framerate.den, s->avctx->framerate.num);

1271 s->avctx->framerate.den /= gcd;

1272 s->avctx->framerate.num /= gcd;

1273 }else{

1274 s->avctx->framerate = (AVRational){ 30000, 1001 };

1275 }

1276 }

1277

1278 if(s->custom_pcf){

1279 skip_bits(&s->gb, 2); //extended Temporal reference

1280 }

1281

1282 if (ufep) {

1283 if (s->umvplus) {

1284 if(get_bits1(&s->gb)==0) /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */

1285 skip_bits1(&s->gb);

1286 }

1287 if(s->h263_slice_structured){

1288 if (get_bits1(&s->gb) != 0) {

1289 av_log(s->avctx, AV_LOG_ERROR, "rectangular slices not supported\n");

1290 }

1291 if (get_bits1(&s->gb) != 0) {

1292 av_log(s->avctx, AV_LOG_ERROR, "unordered slices not supported\n");

1293 }

1294 }

1295 if (s->pict_type == AV_PICTURE_TYPE_B) {

1296 skip_bits(&s->gb, 4); //ELNUM

1297 if (ufep == 1) {

1298 skip_bits(&s->gb, 4); // RLNUM

1299 }

1300 }

1301 }

1302

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

1304 }

1305

1306 if ((ret = av_image_check_size(s->width, s->height, 0, s)) < 0)

1307 return ret;

1308

1309 if (!(s->avctx->flags2 & AV_CODEC_FLAG2_CHUNKS)) {

1310 if ((s->width * s->height / 256 / 8) > get_bits_left(&s->gb))

1311 return AVERROR_INVALIDDATA;

1312 }

1313

1314 s->mb_width = (s->width + 15) / 16;

1315 s->mb_height = (s->height + 15) / 16;

1316 s->mb_num = s->mb_width * s->mb_height;

1317

1318 if (s->pb_frame) {

1319 skip_bits(&s->gb, 3); /* Temporal reference for B-pictures */

1320 if (s->custom_pcf)

1321 skip_bits(&s->gb, 2); //extended Temporal reference

1322 skip_bits(&s->gb, 2); /* Quantization information for B-pictures */

1323 }

1324

1325 if (s->pict_type!=AV_PICTURE_TYPE_B) {

1326 s->time = s->picture_number;

1327 s->pp_time = s->time - s->last_non_b_time;

1328 s->last_non_b_time = s->time;

1329 }else{

1330 s->time = s->picture_number;

1331 s->pb_time = s->pp_time - (s->last_non_b_time - s->time);

1332 if (s->pp_time <=s->pb_time ||

1333 s->pp_time <= s->pp_time - s->pb_time ||

1334 s->pp_time <= 0){

1335 s->pp_time = 2;

1336 s->pb_time = 1;

1337 }

1338 ff_mpeg4_init_direct_mv(s);

1339 }

1340

1341 /* PEI */

1342 if (skip_1stop_8data_bits(&s->gb) < 0)

1343 return AVERROR_INVALIDDATA;

1344

1345 if(s->h263_slice_structured){

1346 if (check_marker(s->avctx, &s->gb, "SEPB1") != 1) {

1347 return -1;

1348 }

1349

1350 ff_h263_decode_mba(s);

1351

1352 if (check_marker(s->avctx, &s->gb, "SEPB2") != 1) {

1353 return -1;

1354 }

1355 }

1356 s->f_code = 1;

1357

1358 if (s->pict_type == AV_PICTURE_TYPE_B)

1359 s->low_delay = 0;

1360

1361 if(s->h263_aic){

1362 s->y_dc_scale_table=

1363 s->c_dc_scale_table= ff_aic_dc_scale_table;

1364 }else{

1365 s->y_dc_scale_table=

1366 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;

1367 }

1368

1369 ff_h263_show_pict_info(s);

1370 if (s->pict_type == AV_PICTURE_TYPE_I && s->codec_tag == AV_RL32("ZYGO") && get_bits_left(&s->gb) >= 85 + 13*3*16 + 50){

1371 int i,j;

1372 for(i=0; i<85; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));

1373 av_log(s->avctx, AV_LOG_DEBUG, "\n");

1374 for(i=0; i<13; i++){

1375 for(j=0; j<3; j++){

1376 int v= get_bits(&s->gb, 8);

1377 v |= get_sbits(&s->gb, 8) * (1 << 8);

1378 av_log(s->avctx, AV_LOG_DEBUG, " %5d", v);

1379 }

1380 av_log(s->avctx, AV_LOG_DEBUG, "\n");

1381 }

1382 for(i=0; i<50; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));

1383 }

1384

1385 return 0;

1386 }

IS_8X8

#define IS_8X8(a)

Definition: mpegutils.h:82

MB_TYPE_L0

#define MB_TYPE_L0

Definition: mpegutils.h:60

MV_TYPE_16X16

#define MV_TYPE_16X16

1 vector for the whole mb

Definition: mpegvideo.h:262

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:186

h263data.h

FF_ASPECT_EXTENDED

#define FF_ASPECT_EXTENDED

Definition: h263.h:26

level

uint8_t level

Definition: svq3.c:204

show_bits_long

static unsigned int show_bits_long(GetBitContext *s, int n)

Show 0-32 bits.

Definition: get_bits.h:474

get_bits_left

static int get_bits_left(GetBitContext *gb)

Definition: get_bits.h:664

h263_pred_acdc

static void h263_pred_acdc(MpegEncContext *s, int16_t *block, int n)

Definition: ituh263dec.c:446

ff_h263_show_pict_info

void ff_h263_show_pict_info(MpegEncContext *s)

Print picture info if FF_DEBUG_PICT_INFO is set.

Definition: ituh263dec.c:80

mem_internal.h

AV_EF_COMPLIANT

#define AV_EF_COMPLIANT

consider all spec non compliances as errors

Definition: defs.h:55

thread.h

mpeg4videodec.h

INIT_VLC_STATIC

#define INIT_VLC_STATIC(vlc, bits, a, b, c, d, e, f, g, static_size)

Definition: vlc.h:125

static const int8_t mv[256][2]

Definition: 4xm.c:80

get_bits_count

static int get_bits_count(const GetBitContext *s)

Definition: get_bits.h:256

MV_DIRECT

#define MV_DIRECT

bidirectional mode where the difference equals the MV of the last P/S/I-Frame (MPEG-4)

Definition: mpegvideo.h:260

AV_CODEC_ID_MPEG4

@ AV_CODEC_ID_MPEG4

Definition: codec_id.h:64

h263_decode_init_vlc

static av_cold void h263_decode_init_vlc(void)

Definition: ituh263dec.c:111

MB_TYPE_INTRA4x4

#define MB_TYPE_INTRA4x4

Definition: mpegutils.h:44

MB_TYPE_16x16

#define MB_TYPE_16x16

Definition: mpegutils.h:47

h263_decode_dquant

static void h263_decode_dquant(MpegEncContext *s)

Definition: ituh263dec.c:433

h263_mb_type_b_map

static const int h263_mb_type_b_map[15]

Definition: ituh263dec.c:62

mpegvideo.h

mathematics.h

MB_TYPE_L1

#define MB_TYPE_L1

Definition: mpegutils.h:61

UPDATE_CACHE

#define UPDATE_CACHE(name, gb)

Definition: get_bits.h:216

Picture

Picture.

Definition: mpegpicture.h:46

h263_decode_block

static int h263_decode_block(MpegEncContext *s, int16_t *block, int n, int coded)

Definition: ituh263dec.c:533

ff_h263_decode_mba

int ff_h263_decode_mba(MpegEncContext *s)

Definition: ituh263dec.c:142

mpegutils.h

SLICE_STARTCODE

#define SLICE_STARTCODE

Definition: mpeg4videodefs.h:60

FF_DEBUG_PICT_INFO

#define FF_DEBUG_PICT_INFO

Definition: avcodec.h:1359

MV_DIR_BACKWARD

#define MV_DIR_BACKWARD

Definition: mpegvideo.h:259

av_gcd

int64_t av_gcd(int64_t a, int64_t b)

Compute the greatest common divisor of two integer operands.

Definition: mathematics.c:37

skip_bits

static void skip_bits(GetBitContext *s, int n)

Definition: get_bits.h:371

get_bits

static unsigned int get_bits(GetBitContext *s, int n)

Read 1-25 bits.

Definition: get_bits.h:325

SKIP_CACHE

#define SKIP_CACHE(name, gb, num)

Definition: get_bits.h:218

ff_h263_decode_mb

int ff_h263_decode_mb(MpegEncContext *s, int16_t block[6][64])

Definition: ituh263dec.c:787

ff_h263_pred_motion

int16_t * ff_h263_pred_motion(MpegEncContext *s, int block, int dir, int *px, int *py)

Definition: h263.c:190

wrap

#define wrap(func)

Definition: neontest.h:65

ff_h263_pixel_aspect

const AVRational ff_h263_pixel_aspect[16]

Definition: h263data.c:273

preview_obmc

static void preview_obmc(MpegEncContext *s)

read the next MVs for OBMC.

Definition: ituh263dec.c:341

RLTable

RLTable.

Definition: rl.h:39

GetBitContext

Definition: get_bits.h:107

AV_EF_BITSTREAM

#define AV_EF_BITSTREAM

detect bitstream specification deviations

Definition: defs.h:49

USES_LIST

#define USES_LIST(a, list)

Definition: mpegutils.h:92

MB_TYPE_CBP

#define MB_TYPE_CBP

Definition: mpegutils.h:64

val

static double val(void *priv, double ch)

Definition: aeval.c:77

scale

static av_always_inline float scale(float x, float s)

Definition: vf_v360.c:1389

SLICE_END

#define SLICE_END

end marker found

Definition: mpegvideo.h:474

HAS_CBP

#define HAS_CBP(a)

Definition: mpegutils.h:94

ff_cbpc_b_tab

const uint8_t ff_cbpc_b_tab[4][2]

Definition: h263data.c:75

ff_thread_once

static int ff_thread_once(char *control, void(*routine)(void))

Definition: thread.h:184

mpegvideodec.h

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:180

INIT_FIRST_VLC_RL

#define INIT_FIRST_VLC_RL(rl, static_size)

Definition: rl.h:93

h263dec.h

av_cold

#define av_cold

Definition: attributes.h:90

cbpc_b_vlc

static VLC cbpc_b_vlc

Definition: ituh263dec.c:107

MB_TYPE_ACPRED

#define MB_TYPE_ACPRED

Definition: mpegutils.h:53

h263_decode_gob_header

static int h263_decode_gob_header(MpegEncContext *s)

Decode the group of blocks header or slice header.

Definition: ituh263dec.c:160

CLOSE_READER

#define CLOSE_READER(name, gb)

Definition: get_bits.h:187

ff_h263_decode_init_vlc

av_cold void ff_h263_decode_init_vlc(void)

Definition: ituh263dec.c:136

width

#define width

ff_h263_chroma_qscale_table

const uint8_t ff_h263_chroma_qscale_table[32]

Definition: h263data.c:260

#define s(width, name)

Definition: cbs_vp9.c:256

format

Filter the word "frame" indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample format(the sample packing is implied by the sample format) and sample rate. The lists are not just lists

SHOW_SBITS

#define SHOW_SBITS(name, gb, num)

Definition: get_bits.h:250

ff_mpeg1_dc_scale_table

static const uint8_t *const ff_mpeg1_dc_scale_table

Definition: mpegvideodata.h:32

set_one_direct_mv

static void set_one_direct_mv(MpegEncContext *s, Picture *p, int i)

Definition: ituh263dec.c:722

get_sbits

static int get_sbits(GetBitContext *s, int n)

Definition: get_bits.h:310

AV_LOG_DEBUG

#define AV_LOG_DEBUG

Stuff which is only useful for libav* developers.

Definition: log.h:201

IS_INTRA

#define IS_INTRA(x, y)

ff_h263_resync

int ff_h263_resync(MpegEncContext *s)

Decode the group of blocks / video packet header / slice header (MPEG-4 Studio).

Definition: ituh263dec.c:216

tab_size

#define tab_size

Definition: ituh263dec.c:720

AV_ONCE_INIT

#define AV_ONCE_INIT

Definition: thread.h:182

LOCAL_ALIGNED_32

#define LOCAL_ALIGNED_32(t, v,...)

Definition: mem_internal.h:135

run

uint8_t run

Definition: svq3.c:203

tab_bias

#define tab_bias

Definition: ituh263dec.c:721

AVRational

Rational number (pair of numerator and denominator).

Definition: rational.h:58

MB_TYPE_8x8

#define MB_TYPE_8x8

Definition: mpegutils.h:50

AV_PICTURE_TYPE_I

@ AV_PICTURE_TYPE_I

Intra.

Definition: avutil.h:274

get_bits1

static unsigned int get_bits1(GetBitContext *s)

Definition: get_bits.h:378

ff_set_qscale

void ff_set_qscale(MpegEncContext *s, int qscale)

set qscale and update qscale dependent variables.

Definition: mpegvideo.c:881

mathops.h

ff_mba_max

const uint16_t ff_mba_max[6]

Definition: h263data.c:265

MB_TYPE_QUANT

#define MB_TYPE_QUANT

Definition: mpegutils.h:63

ff_h263_decode_picture_header

int ff_h263_decode_picture_header(MpegEncContext *s)

Definition: ituh263dec.c:1089

ff_h263_inter_MCBPC_vlc

VLC ff_h263_inter_MCBPC_vlc

Definition: ituh263dec.c:103

get_vlc2

static av_always_inline int get_vlc2(GetBitContext *s, const VLCElem *table, int bits, int max_depth)

Parse a vlc code.

Definition: get_bits.h:631

AVOnce

#define AVOnce

Definition: thread.h:181

Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c

Definition: undefined.txt:32

ff_h263_intra_MCBPC_vlc

VLC ff_h263_intra_MCBPC_vlc

Definition: ituh263dec.c:102

get_unary

static int get_unary(GetBitContext *gb, int stop, int len)

Get unary code of limited length.

Definition: unary.h:46

MV_TYPE_8X8

#define MV_TYPE_8X8

4 vectors (H.263, MPEG-4 4MV)

Definition: mpegvideo.h:263

ff_dlog

#define ff_dlog(a,...)

Definition: tableprint_vlc.h:28

check_marker

static int check_marker(void *logctx, GetBitContext *s, const char *msg)

Definition: mpegvideodec.h:73

AVFrame::pict_type

enum AVPictureType pict_type

Picture type of the frame.

Definition: frame.h:427

ff_h263_rl_inter

RLTable ff_h263_rl_inter

Definition: h263data.c:159

ff_h263_mv_vlc

VLC ff_h263_mv_vlc

Definition: ituh263dec.c:105

shift

static int shift(int a, int b)

Definition: bonk.c:257

for

for(k=2;k<=8;++k)

Definition: h264pred_template.c:425

ff_h263_cbpy_tab

const uint8_t ff_h263_cbpy_tab[16][2]

Definition: h263data.c:82

ff_rl_intra_aic

RLTable ff_rl_intra_aic

Definition: h263data.c:228

CBPY_VLC_BITS

#define CBPY_VLC_BITS

Definition: h263dec.h:33

MB_TYPE_SKIP

#define MB_TYPE_SKIP

Definition: mpegutils.h:55

h263_mbtype_b_vlc

static VLC h263_mbtype_b_vlc

Definition: ituh263dec.c:106

diff

static av_always_inline int diff(const struct color_info *a, const struct color_info *b, const int trans_thresh)

Definition: vf_paletteuse.c:162

OPEN_READER

#define OPEN_READER(name, gb)

Definition: get_bits.h:176

height

#define height

The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a

Definition: undefined.txt:41

mpegvideodata.h

attributes.h

skip_bits1

static void skip_bits1(GetBitContext *s)

Definition: get_bits.h:403

Picture::motion_val

int16_t(*[2] motion_val)[2]

Definition: mpegpicture.h:54

ff_h263_inter_MCBPC_bits

const uint8_t ff_h263_inter_MCBPC_bits[28]

Definition: h263data.c:47

IS_DIRECT

#define IS_DIRECT(a)

Definition: mpegutils.h:77

unary.h

H263_MBTYPE_B_VLC_BITS

#define H263_MBTYPE_B_VLC_BITS

Definition: ituh263dec.c:59

ff_rv_decode_dc

int ff_rv_decode_dc(MpegEncContext *s, int n)

Definition: rv10.c:84

av_get_picture_type_char

char av_get_picture_type_char(enum AVPictureType pict_type)

Return a single letter to describe the given picture type pict_type.

Definition: utils.c:40

MB_TYPE_L0L1

#define MB_TYPE_L0L1

Definition: mpegutils.h:62

av_assert2

#define av_assert2(cond)

assert() equivalent, that does lie in speed critical code.

Definition: avassert.h:64

AV_CODEC_ID_RV10

@ AV_CODEC_ID_RV10

Definition: codec_id.h:57

SKIP_COUNTER

#define SKIP_COUNTER(name, gb, num)

Definition: get_bits.h:223

#define i(width, name, range_min, range_max)

Definition: cbs_h2645.c:269

code

and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code

Definition: filter_design.txt:178

show_bits

static unsigned int show_bits(GetBitContext *s, int n)

Show 1-25 bits.

Definition: get_bits.h:361

internal.h

ff_mpeg4_decode_video_packet_header

int ff_mpeg4_decode_video_packet_header(Mpeg4DecContext *ctx)

Decode the next video packet.

Definition: mpeg4videodec.c:692

INTRA_MCBPC_VLC_BITS

#define INTRA_MCBPC_VLC_BITS

Definition: h263dec.h:31

IS_QUANT

#define IS_QUANT(a)

Definition: mpegutils.h:88

h263_skip_b_part

static int h263_skip_b_part(MpegEncContext *s, int cbp)

Definition: ituh263dec.c:680

FFMIN

#define FFMIN(a, b)

Definition: macros.h:49

ff_h263_format

const uint16_t ff_h263_format[8][2]

Definition: h263data.c:236

CBPC_B_VLC_BITS

#define CBPC_B_VLC_BITS

Definition: ituh263dec.c:60

avcodec.h

stride

#define stride

Definition: h264pred_template.c:537

GET_RL_VLC

#define GET_RL_VLC(level, run, name, gb, table, bits, max_depth, need_update)

Definition: get_bits.h:585

mpeg4videodefs.h

ret

Definition: filter_design.txt:187

SLICE_OK

#define SLICE_OK

Definition: mpegvideo.h:472

pred

static const float pred[4]

Definition: siprdata.h:259

ff_aic_dc_scale_table

const uint8_t ff_aic_dc_scale_table[32]

Definition: h263data.c:245

align_get_bits

static const uint8_t * align_get_bits(GetBitContext *s)

Definition: get_bits.h:540

TEX_VLC_BITS

#define TEX_VLC_BITS

Definition: dvdec.c:146

pos

unsigned int pos

Definition: spdifenc.c:413

ff_mpeg4_init_direct_mv

void ff_mpeg4_init_direct_mv(MpegEncContext *s)

Definition: mpeg4video.c:83

ff_mvtab

const uint8_t ff_mvtab[33][2]

Definition: h263data.c:88

left

Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled left

Definition: snow.txt:386

AV_CODEC_FLAG2_CHUNKS

#define AV_CODEC_FLAG2_CHUNKS

Input bitstream might be truncated at a packet boundaries instead of only at frame boundaries.

Definition: avcodec.h:350

AV_RL32

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32

Definition: bytestream.h:92

ff_h263_intra_MCBPC_bits

const uint8_t ff_h263_intra_MCBPC_bits[9]

Definition: h263data.c:33

skip_1stop_8data_bits