FFmpeg: libavcodec/h263dec.c Source File

FFmpeg

[フレーム]

libavcodec

h263dec.c

Go to the documentation of this file.

1 /*

2 * H.263 decoder

5 *

6 * This file is part of FFmpeg.

7 *

8 * FFmpeg is free software; you can redistribute it and/or

9 * modify it under the terms of the GNU Lesser General Public

10 * License as published by the Free Software Foundation; either

11 * version 2.1 of the License, or (at your option) any later version.

12 *

13 * FFmpeg is distributed in the hope that it will be useful,

14 * but WITHOUT ANY WARRANTY; without even the implied warranty of

15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

16 * Lesser General Public License for more details.

17 *

18 * You should have received a copy of the GNU Lesser General Public

19 * License along with FFmpeg; if not, write to the Free Software

20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

21 */

23 /**

24 * @file

25 * H.263 decoder.

26 */

28 #define UNCHECKED_BITSTREAM_READER 1

30 #include "config_components.h"

32 #include "avcodec.h"

33 #include "codec_internal.h"

34 #include "decode.h"

35 #include "error_resilience.h"

36 #include "flvdec.h"

37 #include "h263.h"

38 #include "h263dec.h"

39 #include "hwconfig.h"

40 #include "mpeg_er.h"

41 #include "mpeg4video.h"

42 #include "mpeg4videodec.h"

43 #include "mpeg4videodefs.h"

44 #include "mpegutils.h"

45 #include "mpegvideo.h"

46 #include "mpegvideodec.h"

47 #include "msmpeg4dec.h"

48 #include "thread.h"

49 #include "wmv2dec.h"

51 static enum AVPixelFormat h263_get_format(AVCodecContext *avctx)

52 {

53 /* MPEG-4 Studio Profile only, not supported by hardware */

54 if (avctx->bits_per_raw_sample > 8) {

55 av_assert1(((MpegEncContext *)avctx->priv_data)->studio_profile);

56 return avctx->pix_fmt;

57 }

59 if (CONFIG_GRAY && (avctx->flags & AV_CODEC_FLAG_GRAY)) {

60 if (avctx->color_range == AVCOL_RANGE_UNSPECIFIED)

61 avctx->color_range = AVCOL_RANGE_MPEG;

62 return AV_PIX_FMT_GRAY8;

63 }

65 return avctx->pix_fmt = ff_get_format(avctx, avctx->codec->pix_fmts);

66 }

68 av_cold int ff_h263_decode_init(AVCodecContext *avctx)

69 {

70 MpegEncContext *s = avctx->priv_data;

71 int ret;

73 s->out_format = FMT_H263;

75 // set defaults

76 ff_mpv_decode_init(s, avctx);

78 s->quant_precision = 5;

79 s->decode_mb = ff_h263_decode_mb;

80 s->low_delay = 1;

82 /* select sub codec */

83 switch (avctx->codec->id) {

84 case AV_CODEC_ID_H263:

85 case AV_CODEC_ID_H263P:

86 avctx->chroma_sample_location = AVCHROMA_LOC_CENTER;

87 break;

88 case AV_CODEC_ID_MPEG4:

89 break;

90 case AV_CODEC_ID_MSMPEG4V1:

91 s->h263_pred = 1;

92 s->msmpeg4_version = 1;

93 break;

94 case AV_CODEC_ID_MSMPEG4V2:

95 s->h263_pred = 1;

96 s->msmpeg4_version = 2;

97 break;

98 case AV_CODEC_ID_MSMPEG4V3:

99 s->h263_pred = 1;

100 s->msmpeg4_version = 3;

101 break;

102 case AV_CODEC_ID_WMV1:

103 s->h263_pred = 1;

104 s->msmpeg4_version = 4;

105 break;

106 case AV_CODEC_ID_WMV2:

107 s->h263_pred = 1;

108 s->msmpeg4_version = 5;

109 break;

110 case AV_CODEC_ID_H263I:

111 break;

112 case AV_CODEC_ID_FLV1:

113 s->h263_flv = 1;

114 break;

115 default:

116 av_log(avctx, AV_LOG_ERROR, "Unsupported codec %d\n",

117 avctx->codec->id);

118 return AVERROR(ENOSYS);

119 }

120

121 if (avctx->codec_tag == AV_RL32("L263") || avctx->codec_tag == AV_RL32("S263"))

122 if (avctx->extradata_size == 56 && avctx->extradata[0] == 1)

123 s->ehc_mode = 1;

124

125 /* for H.263, we allocate the images after having read the header */

126 if (avctx->codec->id != AV_CODEC_ID_H263 &&

127 avctx->codec->id != AV_CODEC_ID_H263P &&

128 avctx->codec->id != AV_CODEC_ID_MPEG4) {

129 avctx->pix_fmt = h263_get_format(avctx);

130 ff_mpv_idct_init(s);

131 if ((ret = ff_mpv_common_init(s)) < 0)

132 return ret;

133 }

134

135 ff_h263dsp_init(&s->h263dsp);

136 ff_h263_decode_init_vlc();

137

138 return 0;

139 }

140

141 av_cold int ff_h263_decode_end(AVCodecContext *avctx)

142 {

143 MpegEncContext *s = avctx->priv_data;

144

145 ff_mpv_common_end(s);

146 return 0;

147 }

148

149 /**

150 * Return the number of bytes consumed for building the current frame.

151 */

152 static int get_consumed_bytes(MpegEncContext *s, int buf_size)

153 {

154 int pos = (get_bits_count(&s->gb) + 7) >> 3;

155

156 if (s->divx_packed || s->avctx->hwaccel) {

157 /* We would have to scan through the whole buf to handle the weird

158 * reordering ... */

159 return buf_size;

160 } else {

161 // avoid infinite loops (maybe not needed...)

162 if (pos == 0)

163 pos = 1;

164 // oops ;)

165 if (pos + 10 > buf_size)

166 pos = buf_size;

167

168 return pos;

169 }

170 }

171

172 static int decode_slice(MpegEncContext *s)

173 {

174 const int part_mask = s->partitioned_frame

175 ? (ER_AC_END | ER_AC_ERROR) : 0x7F;

176 const int mb_size = 16 >> s->avctx->lowres;

177 int ret;

178

179 s->last_resync_gb = s->gb;

180 s->first_slice_line = 1;

181 s->resync_mb_x = s->mb_x;

182 s->resync_mb_y = s->mb_y;

183

184 ff_set_qscale(s, s->qscale);

185

186 if (s->studio_profile) {

187 if ((ret = ff_mpeg4_decode_studio_slice_header(s->avctx->priv_data)) < 0)

188 return ret;

189 }

190

191 if (s->avctx->hwaccel) {

192 const uint8_t *start = s->gb.buffer + get_bits_count(&s->gb) / 8;

193 ret = s->avctx->hwaccel->decode_slice(s->avctx, start, s->gb.buffer_end - start);

194 // ensure we exit decode loop

195 s->mb_y = s->mb_height;

196 return ret;

197 }

198

199 if (s->partitioned_frame) {

200 const int qscale = s->qscale;

201

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

203 if ((ret = ff_mpeg4_decode_partitions(s->avctx->priv_data)) < 0)

204 return ret;

205

206 /* restore variables which were modified */

207 s->first_slice_line = 1;

208 s->mb_x = s->resync_mb_x;

209 s->mb_y = s->resync_mb_y;

210 ff_set_qscale(s, qscale);

211 }

212

213 for (; s->mb_y < s->mb_height; s->mb_y++) {

214 /* per-row end of slice checks */

215 if (s->msmpeg4_version) {

216 if (s->resync_mb_y + s->slice_height == s->mb_y) {

217 ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,

218 s->mb_x - 1, s->mb_y, ER_MB_END);

219

220 return 0;

221 }

222 }

223

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

225 s->last_dc[0] =

226 s->last_dc[1] =

227 s->last_dc[2] = 128;

228 }

229

230 ff_init_block_index(s);

231 for (; s->mb_x < s->mb_width; s->mb_x++) {

232 int ret;

233

234 ff_update_block_index(s, s->avctx->bits_per_raw_sample,

235 s->avctx->lowres, s->chroma_x_shift);

236

237 if (s->resync_mb_x == s->mb_x && s->resync_mb_y + 1 == s->mb_y)

238 s->first_slice_line = 0;

239

240 /* DCT & quantize */

241

242 s->mv_dir = MV_DIR_FORWARD;

243 s->mv_type = MV_TYPE_16X16;

244 ff_dlog(s, "%d %06X\n",

245 get_bits_count(&s->gb), show_bits(&s->gb, 24));

246

247 ff_tlog(NULL, "Decoding MB at %dx%d\n", s->mb_x, s->mb_y);

248 ret = s->decode_mb(s, s->block);

249

250 if (s->pict_type != AV_PICTURE_TYPE_B)

251 ff_h263_update_motion_val(s);

252

253 if (ret < 0) {

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

255 if (ret == SLICE_END) {

256 ff_mpv_reconstruct_mb(s, s->block);

257 if (s->loop_filter)

258 ff_h263_loop_filter(s);

259

260 ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,

261 s->mb_x, s->mb_y, ER_MB_END & part_mask);

262

263 s->padding_bug_score--;

264

265 if (++s->mb_x >= s->mb_width) {

266 s->mb_x = 0;

267 ff_mpeg_draw_horiz_band(s, s->mb_y * mb_size, mb_size);

268 ff_mpv_report_decode_progress(s);

269 s->mb_y++;

270 }

271 return 0;

272 } else if (ret == SLICE_NOEND) {

273 av_log(s->avctx, AV_LOG_ERROR,

274 "Slice mismatch at MB: %d\n", xy);

275 ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,

276 s->mb_x + 1, s->mb_y,

277 ER_MB_END & part_mask);

278 return AVERROR_INVALIDDATA;

279 }

280 av_log(s->avctx, AV_LOG_ERROR, "Error at MB: %d\n", xy);

281 ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,

282 s->mb_x, s->mb_y, ER_MB_ERROR & part_mask);

283

284 if (s->avctx->err_recognition & AV_EF_IGNORE_ERR)

285 continue;

286 return AVERROR_INVALIDDATA;

287 }

288

289 ff_mpv_reconstruct_mb(s, s->block);

290 if (s->loop_filter)

291 ff_h263_loop_filter(s);

292 }

293

294 ff_mpeg_draw_horiz_band(s, s->mb_y * mb_size, mb_size);

295 ff_mpv_report_decode_progress(s);

296

297 s->mb_x = 0;

298 }

299

300 av_assert1(s->mb_x == 0 && s->mb_y == s->mb_height);

301

302 // Detect incorrect padding with wrong stuffing codes used by NEC N-02B

303 if (s->codec_id == AV_CODEC_ID_MPEG4 &&

304 (s->workaround_bugs & FF_BUG_AUTODETECT) &&

305 get_bits_left(&s->gb) >= 48 &&

306 show_bits(&s->gb, 24) == 0x4010 &&

307 !s->data_partitioning)

308 s->padding_bug_score += 32;

309

310 /* try to detect the padding bug */

311 if (s->codec_id == AV_CODEC_ID_MPEG4 &&

312 (s->workaround_bugs & FF_BUG_AUTODETECT) &&

313 get_bits_left(&s->gb) >= 0 &&

314 get_bits_left(&s->gb) < 137 &&

315 !s->data_partitioning) {

316 const int bits_count = get_bits_count(&s->gb);

317 const int bits_left = s->gb.size_in_bits - bits_count;

318

319 if (bits_left == 0) {

320 s->padding_bug_score += 16;

321 } else if (bits_left != 1) {

322 int v = show_bits(&s->gb, 8);

323 v |= 0x7F >> (7 - (bits_count & 7));

324

325 if (v == 0x7F && bits_left <= 8)

326 s->padding_bug_score--;

327 else if (v == 0x7F && ((get_bits_count(&s->gb) + 8) & 8) &&

328 bits_left <= 16)

329 s->padding_bug_score += 4;

330 else

331 s->padding_bug_score++;

332 }

333 }

334

335 if (s->codec_id == AV_CODEC_ID_H263 &&

336 (s->workaround_bugs & FF_BUG_AUTODETECT) &&

337 get_bits_left(&s->gb) >= 8 &&

338 get_bits_left(&s->gb) < 300 &&

339 s->pict_type == AV_PICTURE_TYPE_I &&

340 show_bits(&s->gb, 8) == 0 &&

341 !s->data_partitioning) {

342

343 s->padding_bug_score += 32;

344 }

345

346 if (s->codec_id == AV_CODEC_ID_H263 &&

347 (s->workaround_bugs & FF_BUG_AUTODETECT) &&

348 get_bits_left(&s->gb) >= 64 &&

349 AV_RB64(s->gb.buffer_end - 8) == 0xCDCDCDCDFC7F0000) {

350

351 s->padding_bug_score += 32;

352 }

353

354 if (s->workaround_bugs & FF_BUG_AUTODETECT) {

355 if (

356 (s->padding_bug_score > -2 && !s->data_partitioning))

357 s->workaround_bugs |= FF_BUG_NO_PADDING;

358 else

359 s->workaround_bugs &= ~FF_BUG_NO_PADDING;

360 }

361

362 // handle formats which don't have unique end markers

363 if (s->msmpeg4_version || (s->workaround_bugs & FF_BUG_NO_PADDING)) { // FIXME perhaps solve this more cleanly

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

365 int max_extra = 7;

366

367 /* no markers in M$ crap */

368 if (s->msmpeg4_version && s->pict_type == AV_PICTURE_TYPE_I)

369 max_extra += 17;

370

371 /* buggy padding but the frame should still end approximately at

372 * the bitstream end */

373 if ((s->workaround_bugs & FF_BUG_NO_PADDING) &&

374 (s->avctx->err_recognition & (AV_EF_BUFFER|AV_EF_AGGRESSIVE)))

375 max_extra += 48;

376 else if ((s->workaround_bugs & FF_BUG_NO_PADDING))

377 max_extra += 256 * 256 * 256 * 64;

378

379 if (left > max_extra)

380 av_log(s->avctx, AV_LOG_ERROR,

381 "discarding %d junk bits at end, next would be %X\n",

382 left, show_bits(&s->gb, 24));

383 else if (left < 0)

384 av_log(s->avctx, AV_LOG_ERROR, "overreading %d bits\n", -left);

385 else

386 ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,

387 s->mb_x - 1, s->mb_y, ER_MB_END);

388

389 return 0;

390 }

391

392 av_log(s->avctx, AV_LOG_ERROR,

393 "slice end not reached but screenspace end (%d left %06X, score= %d)\n",

394 get_bits_left(&s->gb), show_bits(&s->gb, 24), s->padding_bug_score);

395

396 ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y,

397 ER_MB_END & part_mask);

398

399 return AVERROR_INVALIDDATA;

400 }

401

402 int ff_h263_decode_frame(AVCodecContext *avctx, AVFrame *pict,

403 int *got_frame, AVPacket *avpkt)

404 {

405 const uint8_t *buf = avpkt->data;

406 int buf_size = avpkt->size;

407 MpegEncContext *s = avctx->priv_data;

408 int ret;

409 int slice_ret = 0;

410

411 /* no supplementary picture */

412 if (buf_size == 0) {

413 /* special case for last picture */

414 if (s->low_delay == 0 && s->next_picture_ptr) {

415 if ((ret = av_frame_ref(pict, s->next_picture_ptr->f)) < 0)

416 return ret;

417 s->next_picture_ptr = NULL;

418

419 *got_frame = 1;

420 } else if (s->skipped_last_frame && s->current_picture_ptr) {

421 /* Output the last picture we decoded again if the stream ended with

422 * an NVOP */

423 if ((ret = av_frame_ref(pict, s->current_picture_ptr->f)) < 0)

424 return ret;

425 /* Copy props from the last input packet. Otherwise, props from the last

426 * returned picture would be reused */

427 if ((ret = ff_decode_frame_props(avctx, pict)) < 0)

428 return ret;

429 s->current_picture_ptr = NULL;

430

431 *got_frame = 1;

432 }

433

434 return 0;

435 }

436

437 retry:

438 if (s->divx_packed && s->bitstream_buffer_size) {

439 int i;

440 for(i=0; i < buf_size-3; i++) {

441 if (buf[i]==0 && buf[i+1]==0 && buf[i+2]==1) {

442 if (buf[i+3]==0xB0) {

443 av_log(s->avctx, AV_LOG_WARNING, "Discarding excessive bitstream in packed xvid\n");

444 s->bitstream_buffer_size = 0;

445 }

446 break;

447 }

448 }

449 }

450

451 if (s->bitstream_buffer_size && (s->divx_packed || buf_size <= MAX_NVOP_SIZE)) // divx 5.01+/xvid frame reorder

452 ret = init_get_bits8(&s->gb, s->bitstream_buffer,

453 s->bitstream_buffer_size);

454 else

455 ret = init_get_bits8(&s->gb, buf, buf_size);

456

457 s->bitstream_buffer_size = 0;

458 if (ret < 0)

459 return ret;

460

461 if (!s->context_initialized)

462 // we need the idct permutation for reading a custom matrix

463 ff_mpv_idct_init(s);

464

465 /* let's go :-) */

466 if (CONFIG_WMV2_DECODER && s->msmpeg4_version == 5) {

467 ret = ff_wmv2_decode_picture_header(s);

468 } else if (CONFIG_MSMPEG4DEC && s->msmpeg4_version) {

469 ret = ff_msmpeg4_decode_picture_header(s);

470 } else if (CONFIG_MPEG4_DECODER && avctx->codec_id == AV_CODEC_ID_MPEG4) {

471 if (s->avctx->extradata_size && !s->extradata_parsed) {

472 GetBitContext gb;

473

474 if (init_get_bits8(&gb, s->avctx->extradata, s->avctx->extradata_size) >= 0 )

475 ff_mpeg4_decode_picture_header(avctx->priv_data, &gb, 1, 0);

476 s->extradata_parsed = 1;

477 }

478 ret = ff_mpeg4_decode_picture_header(avctx->priv_data, &s->gb, 0, 0);

479 s->skipped_last_frame = (ret == FRAME_SKIPPED);

480 } else if (CONFIG_H263I_DECODER && s->codec_id == AV_CODEC_ID_H263I) {

481 ret = ff_intel_h263_decode_picture_header(s);

482 } else if (CONFIG_FLV_DECODER && s->h263_flv) {

483 ret = ff_flv_decode_picture_header(s);

484 } else {

485 ret = ff_h263_decode_picture_header(s);

486 }

487

488 if (ret < 0 || ret == FRAME_SKIPPED) {

489 if ( s->width != avctx->coded_width

490 || s->height != avctx->coded_height) {

491 av_log(s->avctx, AV_LOG_WARNING, "Reverting picture dimensions change due to header decoding failure\n");

492 s->width = avctx->coded_width;

493 s->height= avctx->coded_height;

494 }

495 }

496 if (ret == FRAME_SKIPPED)

497 return get_consumed_bytes(s, buf_size);

498

499 /* skip if the header was thrashed */

500 if (ret < 0) {

501 av_log(s->avctx, AV_LOG_ERROR, "header damaged\n");

502 return ret;

503 }

504

505 if (!s->context_initialized) {

506 avctx->pix_fmt = h263_get_format(avctx);

507 if ((ret = ff_mpv_common_init(s)) < 0)

508 return ret;

509 }

510

511 avctx->has_b_frames = !s->low_delay;

512

513 if (CONFIG_MPEG4_DECODER && avctx->codec_id == AV_CODEC_ID_MPEG4) {

514 if (s->pict_type != AV_PICTURE_TYPE_B && s->mb_num/2 > get_bits_left(&s->gb))

515 return AVERROR_INVALIDDATA;

516 if (ff_mpeg4_workaround_bugs(avctx) == 1)

517 goto retry;

518 if (s->studio_profile != (s->idsp.idct == NULL))

519 ff_mpv_idct_init(s);

520 }

521

522 /* After H.263 & MPEG-4 header decode we have the height, width,

523 * and other parameters. So then we could init the picture.

524 * FIXME: By the way H.263 decoder is evolving it should have

525 * an H263EncContext */

526 if (s->width != avctx->coded_width ||

527 s->height != avctx->coded_height ||

528 s->context_reinit) {

529 /* H.263 could change picture size any time */

530 s->context_reinit = 0;

531

532 ret = ff_set_dimensions(avctx, s->width, s->height);

533 if (ret < 0)

534 return ret;

535

536 ff_set_sar(avctx, avctx->sample_aspect_ratio);

537

538 if ((ret = ff_mpv_common_frame_size_change(s)))

539 return ret;

540

541 if (avctx->pix_fmt != h263_get_format(avctx)) {

542 av_log(avctx, AV_LOG_ERROR, "format change not supported\n");

543 avctx->pix_fmt = AV_PIX_FMT_NONE;

544 return AVERROR_UNKNOWN;

545 }

546 }

547

548 if (s->codec_id == AV_CODEC_ID_H263 ||

549 s->codec_id == AV_CODEC_ID_H263P ||

550 s->codec_id == AV_CODEC_ID_H263I)

551 s->gob_index = H263_GOB_HEIGHT(s->height);

552

553 /* skip B-frames if we don't have reference frames */

554 if (!s->last_picture_ptr &&

555 (s->pict_type == AV_PICTURE_TYPE_B || s->droppable))

556 return get_consumed_bytes(s, buf_size);

557 if ((avctx->skip_frame >= AVDISCARD_NONREF &&

558 s->pict_type == AV_PICTURE_TYPE_B) ||

559 (avctx->skip_frame >= AVDISCARD_NONKEY &&

560 s->pict_type != AV_PICTURE_TYPE_I) ||

561 avctx->skip_frame >= AVDISCARD_ALL)

562 return get_consumed_bytes(s, buf_size);

563

564 if ((ret = ff_mpv_frame_start(s, avctx)) < 0)

565 return ret;

566

567 if (!s->divx_packed && !avctx->hwaccel)

568 ff_thread_finish_setup(avctx);

569

570 if (avctx->hwaccel) {

571 ret = avctx->hwaccel->start_frame(avctx, s->gb.buffer,

572 s->gb.buffer_end - s->gb.buffer);

573 if (ret < 0 )

574 return ret;

575 }

576

577 ff_mpeg_er_frame_start(s);

578

579 /* the second part of the wmv2 header contains the MB skip bits which

580 * are stored in current_picture->mb_type which is not available before

581 * ff_mpv_frame_start() */

582 if (CONFIG_WMV2_DECODER && s->msmpeg4_version == 5) {

583 ret = ff_wmv2_decode_secondary_picture_header(s);

584 if (ret < 0)

585 return ret;

586 if (ret == 1)

587 goto frame_end;

588 }

589

590 /* decode each macroblock */

591 s->mb_x = 0;

592 s->mb_y = 0;

593

594 slice_ret = decode_slice(s);

595 while (s->mb_y < s->mb_height) {

596 if (s->msmpeg4_version) {

597 if (s->slice_height == 0 || s->mb_x != 0 || slice_ret < 0 ||

598 (s->mb_y % s->slice_height) != 0 || get_bits_left(&s->gb) < 0)

599 break;

600 } else {

601 int prev_x = s->mb_x, prev_y = s->mb_y;

602 if (ff_h263_resync(s) < 0)

603 break;

604 if (prev_y * s->mb_width + prev_x < s->mb_y * s->mb_width + s->mb_x)

605 s->er.error_occurred = 1;

606 }

607

608 if (s->msmpeg4_version < 4 && s->h263_pred)

609 ff_mpeg4_clean_buffers(s);

610

611 if (decode_slice(s) < 0)

612 slice_ret = AVERROR_INVALIDDATA;

613 }

614

615 if (s->msmpeg4_version && s->msmpeg4_version < 4 &&

616 s->pict_type == AV_PICTURE_TYPE_I)

617 if (!CONFIG_MSMPEG4DEC ||

618 ff_msmpeg4_decode_ext_header(s, buf_size) < 0)

619 s->er.error_status_table[s->mb_num - 1] = ER_MB_ERROR;

620

621 av_assert1(s->bitstream_buffer_size == 0);

622 frame_end:

623 if (!s->studio_profile)

624 ff_er_frame_end(&s->er);

625

626 if (avctx->hwaccel) {

627 ret = avctx->hwaccel->end_frame(avctx);

628 if (ret < 0)

629 return ret;

630 }

631

632 ff_mpv_frame_end(s);

633

634 if (CONFIG_MPEG4_DECODER && avctx->codec_id == AV_CODEC_ID_MPEG4)

635 ff_mpeg4_frame_end(avctx, buf, buf_size);

636

637 if (!s->divx_packed && avctx->hwaccel)

638 ff_thread_finish_setup(avctx);

639

640 av_assert1(s->current_picture.f->pict_type == s->current_picture_ptr->f->pict_type);

641 av_assert1(s->current_picture.f->pict_type == s->pict_type);

642 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {

643 if ((ret = av_frame_ref(pict, s->current_picture_ptr->f)) < 0)

644 return ret;

645 ff_print_debug_info(s, s->current_picture_ptr, pict);

646 ff_mpv_export_qp_table(s, pict, s->current_picture_ptr, FF_MPV_QSCALE_TYPE_MPEG1);

647 } else if (s->last_picture_ptr) {

648 if ((ret = av_frame_ref(pict, s->last_picture_ptr->f)) < 0)

649 return ret;

650 ff_print_debug_info(s, s->last_picture_ptr, pict);

651 ff_mpv_export_qp_table(s, pict, s->last_picture_ptr, FF_MPV_QSCALE_TYPE_MPEG1);

652 }

653

654 if (s->last_picture_ptr || s->low_delay) {

655 if ( pict->format == AV_PIX_FMT_YUV420P

656 && (s->codec_tag == AV_RL32("GEOV") || s->codec_tag == AV_RL32("GEOX"))) {

657 for (int p = 0; p < 3; p++) {

658 int h = AV_CEIL_RSHIFT(pict->height, !!p);

659

660 pict->data[p] += (h - 1) * pict->linesize[p];

661 pict->linesize[p] *= -1;

662 }

663 }

664 *got_frame = 1;

665 }

666

667 if (slice_ret < 0 && (avctx->err_recognition & AV_EF_EXPLODE))

668 return slice_ret;

669 else

670 return get_consumed_bytes(s, buf_size);

671 }

672

673 const enum AVPixelFormat ff_h263_hwaccel_pixfmt_list_420[] = {

674 #if CONFIG_H263_VAAPI_HWACCEL || CONFIG_MPEG4_VAAPI_HWACCEL

675 AV_PIX_FMT_VAAPI,

676 #endif

677 #if CONFIG_MPEG4_NVDEC_HWACCEL

678 AV_PIX_FMT_CUDA,

679 #endif

680 #if CONFIG_MPEG4_VDPAU_HWACCEL

681 AV_PIX_FMT_VDPAU,

682 #endif

683 #if CONFIG_H263_VIDEOTOOLBOX_HWACCEL || CONFIG_MPEG4_VIDEOTOOLBOX_HWACCEL

684 AV_PIX_FMT_VIDEOTOOLBOX,

685 #endif

686 AV_PIX_FMT_YUV420P,

687 AV_PIX_FMT_NONE

688 };

689

690 static const AVCodecHWConfigInternal *const h263_hw_config_list[] = {

691 #if CONFIG_H263_VAAPI_HWACCEL

692 HWACCEL_VAAPI(h263),

693 #endif

694 #if CONFIG_MPEG4_NVDEC_HWACCEL

695 HWACCEL_NVDEC(mpeg4),

696 #endif

697 #if CONFIG_MPEG4_VDPAU_HWACCEL

698 HWACCEL_VDPAU(mpeg4),

699 #endif

700 #if CONFIG_H263_VIDEOTOOLBOX_HWACCEL

701 HWACCEL_VIDEOTOOLBOX(h263),

702 #endif

703 NULL

704 };

705

706 const FFCodec ff_h263_decoder = {

707 .p.name = "h263",

708 CODEC_LONG_NAME("H.263 / H.263-1996, H.263+ / H.263-1998 / H.263 version 2"),

709 .p.type = AVMEDIA_TYPE_VIDEO,

710 .p.id = AV_CODEC_ID_H263,

711 .priv_data_size = sizeof(MpegEncContext),

712 .init = ff_h263_decode_init,

713 .close = ff_h263_decode_end,

714 FF_CODEC_DECODE_CB(ff_h263_decode_frame),

715 .p.capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 |

716 AV_CODEC_CAP_DELAY,

717 .caps_internal = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,

718 .flush = ff_mpeg_flush,

719 .p.max_lowres = 3,

720 .p.pix_fmts = ff_h263_hwaccel_pixfmt_list_420,

721 .hw_configs = h263_hw_config_list,

722 };

723

724 const FFCodec ff_h263p_decoder = {

725 .p.name = "h263p",

726 CODEC_LONG_NAME("H.263 / H.263-1996, H.263+ / H.263-1998 / H.263 version 2"),

727 .p.type = AVMEDIA_TYPE_VIDEO,

728 .p.id = AV_CODEC_ID_H263P,

729 .priv_data_size = sizeof(MpegEncContext),

730 .init = ff_h263_decode_init,

731 .close = ff_h263_decode_end,

732 FF_CODEC_DECODE_CB(ff_h263_decode_frame),

733 .p.capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 |

734 AV_CODEC_CAP_DELAY,

735 .caps_internal = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,

736 .flush = ff_mpeg_flush,

737 .p.max_lowres = 3,

738 .p.pix_fmts = ff_h263_hwaccel_pixfmt_list_420,

739 .hw_configs = h263_hw_config_list,

740 };

ff_mpv_common_init

av_cold int ff_mpv_common_init(MpegEncContext *s)

init common structure for both encoder and decoder.

Definition: mpegvideo.c:682

hwconfig.h

AVCodecContext::hwaccel

const struct AVHWAccel * hwaccel

Hardware accelerator in use.

Definition: avcodec.h:1405

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

AV_PIX_FMT_CUDA

@ AV_PIX_FMT_CUDA

HW acceleration through CUDA.

Definition: pixfmt.h:253

AVPixelFormat

Pixel format.

Definition: pixfmt.h:64

AV_EF_EXPLODE

#define AV_EF_EXPLODE

abort decoding on minor error detection

Definition: defs.h:51

h263_hw_config_list

static const AVCodecHWConfigInternal *const h263_hw_config_list[]

Definition: h263dec.c:690

H263_GOB_HEIGHT

#define H263_GOB_HEIGHT(h)

Definition: h263.h:28

get_bits_left

static int get_bits_left(GetBitContext *gb)

Definition: get_bits.h:664

AVERROR

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 they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions

ff_mpv_export_qp_table

int ff_mpv_export_qp_table(const MpegEncContext *s, AVFrame *f, const Picture *p, int qp_type)

Definition: mpegvideo_dec.c:506

ff_h263_decode_mb

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

Definition: ituh263dec.c:787

ff_get_format

int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)

Select the (possibly hardware accelerated) pixel format.

Definition: decode.c:1147

mpeg4videodec.h

AVCodecContext::err_recognition

int err_recognition

Error recognition; may misdetect some more or less valid parts as errors.

Definition: avcodec.h:1382

get_bits_count

static int get_bits_count(const GetBitContext *s)

Definition: get_bits.h:256

AVCodec::pix_fmts

enum AVPixelFormat * pix_fmts

array of supported pixel formats, or NULL if unknown, array is terminated by -1

Definition: codec.h:206

AV_CODEC_ID_MPEG4

@ AV_CODEC_ID_MPEG4

Definition: codec_id.h:64

AVFrame

This structure describes decoded (raw) audio or video data.

Definition: frame.h:330

ff_mpv_report_decode_progress

void ff_mpv_report_decode_progress(MpegEncContext *s)

Definition: mpegvideo_dec.c:565

AVPacket::data

uint8_t * data

Definition: packet.h:374

ff_mpeg4_decode_studio_slice_header

int ff_mpeg4_decode_studio_slice_header(Mpeg4DecContext *ctx)

Decode the next video packet.

Definition: mpeg4videodec.c:793

ff_msmpeg4_decode_ext_header

int ff_msmpeg4_decode_ext_header(MpegEncContext *s, int buf_size)

Definition: msmpeg4dec.c:541

FFCodec

Definition: codec_internal.h:127

ff_er_add_slice

void ff_er_add_slice(ERContext *s, int startx, int starty, int endx, int endy, int status)

Add a slice.

Definition: error_resilience.c:822

ff_init_block_index

void ff_init_block_index(MpegEncContext *s)

Definition: mpegvideo.c:848

mpegvideo.h

AVERROR_UNKNOWN

#define AVERROR_UNKNOWN

Unknown error, typically from an external library.

Definition: error.h:73

mpegutils.h

ff_set_dimensions

int ff_set_dimensions(AVCodecContext *s, int width, int height)

Check that the provided frame dimensions are valid and set them on the codec context.

Definition: utils.c:91

thread.h

AVFrame::data

uint8_t * data[AV_NUM_DATA_POINTERS]

pointer to the picture/channel planes.

Definition: frame.h:351

ff_wmv2_decode_secondary_picture_header

int ff_wmv2_decode_secondary_picture_header(MpegEncContext *s)

Definition: wmv2dec.c:239

ff_mpeg4_frame_end

int ff_mpeg4_frame_end(AVCodecContext *avctx, const uint8_t *buf, int buf_size)

Definition: mpeg4videodec.c:3648

ff_mpv_reconstruct_mb

void ff_mpv_reconstruct_mb(MpegEncContext *s, int16_t block[12][64])

Definition: mpegvideo_dec.c:1006

FFCodec::p

AVCodec p

The public AVCodec.

Definition: codec_internal.h:131

AVCodecContext::codec

const struct AVCodec * codec

Definition: avcodec.h:435

AVCodecContext::skip_frame

enum AVDiscard skip_frame

Skip decoding for selected frames.

Definition: avcodec.h:1713

GetBitContext

Definition: get_bits.h:107

decode_slice

static int decode_slice(MpegEncContext *s)

Definition: h263dec.c:172

ff_h263dsp_init

av_cold void ff_h263dsp_init(H263DSPContext *ctx)

Definition: h263dsp.c:117

AVCodecContext::flags

int flags

AV_CODEC_FLAG_*.

Definition: avcodec.h:506

HWACCEL_VDPAU

#define HWACCEL_VDPAU(codec)

Definition: hwconfig.h:75

AVCodecContext::coded_height

int coded_height

Definition: avcodec.h:613

ff_print_debug_info

void ff_print_debug_info(const MpegEncContext *s, const Picture *p, AVFrame *pict)

Definition: mpegvideo_dec.c:499

SLICE_END

#define SLICE_END

end marker found

Definition: mpegvideo.h:474

ff_h263_decode_picture_header

int ff_h263_decode_picture_header(MpegEncContext *s)

Definition: ituh263dec.c:1089

AV_CODEC_ID_MSMPEG4V2

@ AV_CODEC_ID_MSMPEG4V2

Definition: codec_id.h:67

ff_h263_update_motion_val

void ff_h263_update_motion_val(MpegEncContext *s)

Definition: h263.c:53

ff_mpv_common_end

void ff_mpv_common_end(MpegEncContext *s)

Definition: mpegvideo.c:784

mpegvideodec.h

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:180

h263dec.h

av_cold

#define av_cold

Definition: attributes.h:90

AV_CODEC_ID_H263I

@ AV_CODEC_ID_H263I

Definition: codec_id.h:72

ff_mpeg4_decode_partitions

int ff_mpeg4_decode_partitions(Mpeg4DecContext *ctx)

Decode the first and second partition.

Definition: mpeg4videodec.c:1224

init_get_bits8

static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)

Initialize GetBitContext.

Definition: get_bits.h:524

ff_wmv2_decode_picture_header

int ff_wmv2_decode_picture_header(MpegEncContext *s)

Definition: wmv2dec.c:204

ff_msmpeg4_decode_picture_header

int ff_msmpeg4_decode_picture_header(MpegEncContext *s)

Definition: msmpeg4dec.c:385

AVCodecContext::extradata_size

int extradata_size

Definition: avcodec.h:528

AVCodecContext::has_b_frames

int has_b_frames

Size of the frame reordering buffer in the decoder.

Definition: avcodec.h:721

ff_mpv_common_frame_size_change

int ff_mpv_common_frame_size_change(MpegEncContext *s)

Definition: mpegvideo_dec.c:195

FF_CODEC_DECODE_CB

#define FF_CODEC_DECODE_CB(func)

Definition: codec_internal.h:306

#define s(width, name)

Definition: cbs_vp9.c:256

AV_CEIL_RSHIFT

#define AV_CEIL_RSHIFT(a, b)

Definition: common.h:50

h263_get_format

static enum AVPixelFormat h263_get_format(AVCodecContext *avctx)

Definition: h263dec.c:51

init

int(* init)(AVBSFContext *ctx)

Definition: dts2pts_bsf.c:365

FF_BUG_NO_PADDING

#define FF_BUG_NO_PADDING

Definition: avcodec.h:1315

ff_mpeg_er_frame_start

void ff_mpeg_er_frame_start(MpegEncContext *s)

Definition: mpeg_er.c:47

AV_CODEC_ID_WMV2

@ AV_CODEC_ID_WMV2

Definition: codec_id.h:70

AV_EF_IGNORE_ERR

#define AV_EF_IGNORE_ERR

ignore errors and continue

Definition: defs.h:53

AVCodecContext::bits_per_raw_sample

int bits_per_raw_sample

Bits per sample/pixel of internal libavcodec pixel/sample format.

Definition: avcodec.h:1487

ff_mpeg4_workaround_bugs

int ff_mpeg4_workaround_bugs(AVCodecContext *avctx)

Definition: mpeg4videodec.c:2981

decode.h

AV_CODEC_ID_MSMPEG4V1

@ AV_CODEC_ID_MSMPEG4V1

Definition: codec_id.h:66

AV_PIX_FMT_YUV420P

@ AV_PIX_FMT_YUV420P

planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)

Definition: pixfmt.h:66

CODEC_LONG_NAME

#define CODEC_LONG_NAME(str)

Definition: codec_internal.h:272

AVCodecContext::codec_id

enum AVCodecID codec_id

Definition: avcodec.h:436

FRAME_SKIPPED

#define FRAME_SKIPPED

Return value for header parsers if frame is not coded.

Definition: mpegutils.h:33

AVDISCARD_ALL

@ AVDISCARD_ALL

discard all

Definition: defs.h:76

ff_h263_decode_init_vlc

void ff_h263_decode_init_vlc(void)

Definition: ituh263dec.c:136

NULL

#define NULL

Definition: coverity.c:32

bits_left

#define bits_left

Definition: bitstream.h:113

AVCodecContext::color_range

enum AVColorRange color_range

MPEG vs JPEG YUV range.

Definition: avcodec.h:1009

ER_AC_ERROR

#define ER_AC_ERROR

Definition: error_resilience.h:31

ff_mpv_idct_init

av_cold void ff_mpv_idct_init(MpegEncContext *s)

Definition: mpegvideo.c:342

SLICE_NOEND

#define SLICE_NOEND

no end marker or error found but mb count exceeded

Definition: mpegvideo.h:475

ER_MB_ERROR

#define ER_MB_ERROR

Definition: error_resilience.h:38

AVHWAccel::end_frame

int(* end_frame)(AVCodecContext *avctx)

Called at the end of each frame or field picture.

Definition: avcodec.h:2176

AV_PICTURE_TYPE_I

@ AV_PICTURE_TYPE_I

Intra.

Definition: avutil.h:274

ff_flv_decode_picture_header

int ff_flv_decode_picture_header(MpegEncContext *s)

Definition: flvdec.c:29

ff_set_qscale

void ff_set_qscale(MpegEncContext *s, int qscale)

set qscale and update qscale dependent variables.

Definition: mpegvideo.c:881

ff_set_sar

int ff_set_sar(AVCodecContext *avctx, AVRational sar)

Check that the provided sample aspect ratio is valid and set it on the codec context.

Definition: utils.c:106

ff_h263_decode_frame

int ff_h263_decode_frame(AVCodecContext *avctx, AVFrame *pict, int *got_frame, AVPacket *avpkt)

Definition: h263dec.c:402

AV_CODEC_ID_WMV1

@ AV_CODEC_ID_WMV1

Definition: codec_id.h:69

AV_PIX_FMT_GRAY8

@ AV_PIX_FMT_GRAY8

Y , 8bpp.

Definition: pixfmt.h:74

AVCOL_RANGE_UNSPECIFIED

@ AVCOL_RANGE_UNSPECIFIED

Definition: pixfmt.h:627

FF_MPV_QSCALE_TYPE_MPEG1

#define FF_MPV_QSCALE_TYPE_MPEG1

Definition: mpegvideodec.h:40

ff_h263_decode_end

av_cold int ff_h263_decode_end(AVCodecContext *avctx)

Definition: h263dec.c:141

ff_dlog

#define ff_dlog(a,...)

Definition: tableprint_vlc.h:28

AVDISCARD_NONKEY

@ AVDISCARD_NONKEY

discard all frames except keyframes

Definition: defs.h:75

AV_CODEC_CAP_DR1

#define AV_CODEC_CAP_DR1

Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.

Definition: codec.h:52

AV_CODEC_FLAG_GRAY

#define AV_CODEC_FLAG_GRAY

Only decode/encode grayscale.

Definition: avcodec.h:301

AVPacket::size

int size

Definition: packet.h:375

ff_mpeg4_clean_buffers

void ff_mpeg4_clean_buffers(MpegEncContext *s)

Definition: mpeg4video.c:57

av_frame_ref

int av_frame_ref(AVFrame *dst, const AVFrame *src)

Set up a new reference to the data described by the source frame.

Definition: frame.c:344

codec_internal.h

ff_update_block_index

static void ff_update_block_index(MpegEncContext *s, int bits_per_raw_sample, int lowres, int chroma_x_shift)

Definition: mpegvideo.h:595

AV_CODEC_ID_H263

@ AV_CODEC_ID_H263

Definition: codec_id.h:56

FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM

#define FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM

The decoder extracts and fills its parameters even if the frame is skipped due to the skip_frame sett...

Definition: codec_internal.h:54

ff_mpeg_draw_horiz_band

void ff_mpeg_draw_horiz_band(MpegEncContext *s, int y, int h)

Definition: mpegvideo_dec.c:536

AVFrame::format

int format

format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...

Definition: frame.h:417

AVCodecHWConfigInternal

Definition: hwconfig.h:29

ff_mpv_frame_start

int ff_mpv_frame_start(MpegEncContext *s, AVCodecContext *avctx)

generic function called after decoding the header and before a frame is decoded.

Definition: mpegvideo_dec.c:271

ff_mpeg_flush

void ff_mpeg_flush(AVCodecContext *avctx)

Definition: mpegvideo_dec.c:544

ff_h263_decoder

const FFCodec ff_h263_decoder

Definition: h263dec.c:706

msmpeg4dec.h

flvdec.h

HWACCEL_NVDEC

#define HWACCEL_NVDEC(codec)

Definition: hwconfig.h:71

AV_PIX_FMT_VAAPI

@ AV_PIX_FMT_VAAPI

Hardware acceleration through VA-API, data[3] contains a VASurfaceID.

Definition: pixfmt.h:119

AVCodec::id

enum AVCodecID id

Definition: codec.h:198

AV_PIX_FMT_VDPAU

@ AV_PIX_FMT_VDPAU

HW acceleration through VDPAU, Picture.data[3] contains a VdpVideoSurface.

Definition: pixfmt.h:187

get_consumed_bytes

static int get_consumed_bytes(MpegEncContext *s, int buf_size)

Return the number of bytes consumed for building the current frame.

Definition: h263dec.c:152

AV_PIX_FMT_VIDEOTOOLBOX

@ AV_PIX_FMT_VIDEOTOOLBOX

hardware decoding through Videotoolbox

Definition: pixfmt.h:302

FMT_H263

@ FMT_H263

Definition: mpegutils.h:119

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

Definition: cbs_h2645.c:269

ff_h263p_decoder

const FFCodec ff_h263p_decoder

Definition: h263dec.c:724

ff_h263_hwaccel_pixfmt_list_420

enum AVPixelFormat ff_h263_hwaccel_pixfmt_list_420[]

Definition: h263dec.c:673

AVCodecContext::extradata

uint8_t * extradata

some codecs need / can use extradata like Huffman tables.

Definition: avcodec.h:527

show_bits

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

Show 1-25 bits.

Definition: get_bits.h:361

ff_mpeg4_decode_picture_header

int ff_mpeg4_decode_picture_header(Mpeg4DecContext *ctx, GetBitContext *gb, int header, int parse_only)

Decode MPEG-4 headers.

Definition: mpeg4videodec.c:3490

ff_mpv_decode_init

void ff_mpv_decode_init(MpegEncContext *s, AVCodecContext *avctx)

Initialize the given MpegEncContext for decoding.

Definition: mpegvideo_dec.c:42

av_assert1

#define av_assert1(cond)

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

Definition: avassert.h:53

FF_BUG_AUTODETECT

#define FF_BUG_AUTODETECT

autodetection

Definition: avcodec.h:1312

ff_intel_h263_decode_picture_header

int ff_intel_h263_decode_picture_header(MpegEncContext *s)

Definition: intelh263dec.c:30

AVCodec::name

const char * name

Name of the codec implementation.

Definition: codec.h:191

ff_h263_decode_init

av_cold int ff_h263_decode_init(AVCodecContext *avctx)

Definition: h263dec.c:68

AVCodecContext::chroma_sample_location

enum AVChromaLocation chroma_sample_location

This defines the location of chroma samples.

Definition: avcodec.h:1016

AVCodecContext::pix_fmt

enum AVPixelFormat pix_fmt

Pixel format, see AV_PIX_FMT_xxx.

Definition: avcodec.h:635

AVCOL_RANGE_MPEG

@ AVCOL_RANGE_MPEG

Narrow or limited range content.

Definition: pixfmt.h:644

HWACCEL_VIDEOTOOLBOX

#define HWACCEL_VIDEOTOOLBOX(codec)

Definition: hwconfig.h:77

avcodec.h

mpeg4videodefs.h

ret

Definition: filter_design.txt:187

AV_EF_AGGRESSIVE

#define AV_EF_AGGRESSIVE

consider things that a sane encoder/muxer should not do as an error

Definition: defs.h:56

wmv2dec.h

pos

unsigned int pos

Definition: spdifenc.c:413

ff_thread_finish_setup

the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before as well as code calling up to before the decode process starts Call ff_thread_finish_setup() afterwards. If some code can 't be moved

ff_h263_loop_filter

void ff_h263_loop_filter(MpegEncContext *s)

Definition: h263.c:105

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_RL32

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32

Definition: bytestream.h:92

ff_decode_frame_props

int ff_decode_frame_props(AVCodecContext *avctx, AVFrame *frame)

Set various frame properties from the codec context / packet data.

Definition: decode.c:1350

AVCodecContext

main external API structure.

Definition: avcodec.h:426

AVFrame::height