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 "libavutil/cpu.h"

31 #include "avcodec.h"

32 #include "error_resilience.h"

33 #include "flv.h"

34 #include "h263.h"

35 #include "h263_parser.h"

36 #include "hwaccel.h"

37 #include "internal.h"

38 #include "mpeg_er.h"

39 #include "mpeg4video.h"

40 #include "mpeg4video_parser.h"

41 #include "mpegutils.h"

42 #include "mpegvideo.h"

43 #include "msmpeg4.h"

44 #include "qpeldsp.h"

45 #include "thread.h"

46 #include "wmv2.h"

48 static enum AVPixelFormat h263_get_format(AVCodecContext *avctx)

49 {

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

51 if (avctx->bits_per_raw_sample > 8) {

52 av_assert1(avctx->profile == FF_PROFILE_MPEG4_SIMPLE_STUDIO);

53 return avctx->pix_fmt;

54 }

56 if (avctx->codec->id == AV_CODEC_ID_MSS2)

57 return AV_PIX_FMT_YUV420P;

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_defaults(s);

77 ff_mpv_decode_init(s, avctx);

79 s->quant_precision = 5;

80 s->decode_mb = ff_h263_decode_mb;

81 s->low_delay = 1;

82 s->unrestricted_mv = 1;

84 /* select sub codec */

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

86 case AV_CODEC_ID_H263:

87 case AV_CODEC_ID_H263P:

88 s->unrestricted_mv = 0;

89 avctx->chroma_sample_location = AVCHROMA_LOC_CENTER;

90 break;

91 case AV_CODEC_ID_MPEG4:

92 break;

93 case AV_CODEC_ID_MSMPEG4V1:

94 s->h263_pred = 1;

95 s->msmpeg4_version = 1;

96 break;

97 case AV_CODEC_ID_MSMPEG4V2:

98 s->h263_pred = 1;

99 s->msmpeg4_version = 2;

100 break;

101 case AV_CODEC_ID_MSMPEG4V3:

102 s->h263_pred = 1;

103 s->msmpeg4_version = 3;

104 break;

105 case AV_CODEC_ID_WMV1:

106 s->h263_pred = 1;

107 s->msmpeg4_version = 4;

108 break;

109 case AV_CODEC_ID_WMV2:

110 s->h263_pred = 1;

111 s->msmpeg4_version = 5;

112 break;

113 case AV_CODEC_ID_VC1:

114 case AV_CODEC_ID_WMV3:

115 case AV_CODEC_ID_VC1IMAGE:

116 case AV_CODEC_ID_WMV3IMAGE:

117 case AV_CODEC_ID_MSS2:

118 s->h263_pred = 1;

119 s->msmpeg4_version = 6;

120 avctx->chroma_sample_location = AVCHROMA_LOC_LEFT;

121 break;

122 case AV_CODEC_ID_H263I:

123 break;

124 case AV_CODEC_ID_FLV1:

125 s->h263_flv = 1;

126 break;

127 default:

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

129 avctx->codec->id);

130 return AVERROR(ENOSYS);

131 }

132 s->codec_id = avctx->codec->id;

133

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

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

136 s->ehc_mode = 1;

137

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

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

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

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

142 avctx->pix_fmt = h263_get_format(avctx);

143 ff_mpv_idct_init(s);

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

145 return ret;

146 }

147

148 ff_h263dsp_init(&s->h263dsp);

149 ff_qpeldsp_init(&s->qdsp);

150 ff_h263_decode_init_vlc();

151

152 return 0;

153 }

154

155 av_cold int ff_h263_decode_end(AVCodecContext *avctx)

156 {

157 MpegEncContext *s = avctx->priv_data;

158

159 ff_mpv_common_end(s);

160 return 0;

161 }

162

163 /**

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

165 */

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

167 {

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

169

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

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

172 * reordering ... */

173 return buf_size;

174 } else if (s->avctx->flags & AV_CODEC_FLAG_TRUNCATED) {

175 pos -= s->parse_context.last_index;

176 // padding is not really read so this might be -1

177 if (pos < 0)

178 pos = 0;

179 return pos;

180 } else {

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

182 if (pos == 0)

183 pos = 1;

184 // oops ;)

185 if (pos + 10 > buf_size)

186 pos = buf_size;

187

188 return pos;

189 }

190 }

191

192 static int decode_slice(MpegEncContext *s)

193 {

194 const int part_mask = s->partitioned_frame

195 ? (ER_AC_END | ER_AC_ERROR) : 0x7F;

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

197 int ret;

198

199 s->last_resync_gb = s->gb;

200 s->first_slice_line = 1;

201 s->resync_mb_x = s->mb_x;

202 s->resync_mb_y = s->mb_y;

203

204 ff_set_qscale(s, s->qscale);

205

206 if (s->studio_profile) {

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

208 return ret;

209 }

210

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

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

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

214 // ensure we exit decode loop

215 s->mb_y = s->mb_height;

216 return ret;

217 }

218

219 if (s->partitioned_frame) {

220 const int qscale = s->qscale;

221

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

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

224 return ret;

225

226 /* restore variables which were modified */

227 s->first_slice_line = 1;

228 s->mb_x = s->resync_mb_x;

229 s->mb_y = s->resync_mb_y;

230 ff_set_qscale(s, qscale);

231 }

232

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

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

235 if (s->msmpeg4_version) {

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

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

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

239

240 return 0;

241 }

242 }

243

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

245 s->last_dc[0] =

246 s->last_dc[1] =

247 s->last_dc[2] = 128;

248 }

249

250 ff_init_block_index(s);

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

252 int ret;

253

254 ff_update_block_index(s);

255

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

257 s->first_slice_line = 0;

258

259 /* DCT & quantize */

260

261 s->mv_dir = MV_DIR_FORWARD;

262 s->mv_type = MV_TYPE_16X16;

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

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

265

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

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

268

269 if (s->pict_type != AV_PICTURE_TYPE_B)

270 ff_h263_update_motion_val(s);

271

272 if (ret < 0) {

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

274 if (ret == SLICE_END) {

275 ff_mpv_reconstruct_mb(s, s->block);

276 if (s->loop_filter)

277 ff_h263_loop_filter(s);

278

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

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

281

282 s->padding_bug_score--;

283

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

285 s->mb_x = 0;

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

287 ff_mpv_report_decode_progress(s);

288 s->mb_y++;

289 }

290 return 0;

291 } else if (ret == SLICE_NOEND) {

292 av_log(s->avctx, AV_LOG_ERROR,

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

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

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

296 ER_MB_END & part_mask);

297 return AVERROR_INVALIDDATA;

298 }

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

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

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

302

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

304 continue;

305 return AVERROR_INVALIDDATA;

306 }

307

308 ff_mpv_reconstruct_mb(s, s->block);

309 if (s->loop_filter)

310 ff_h263_loop_filter(s);

311 }

312

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

314 ff_mpv_report_decode_progress(s);

315

316 s->mb_x = 0;

317 }

318

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

320

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

322 (s->workaround_bugs & FF_BUG_AUTODETECT) &&

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

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

325 !s->data_partitioning)

326 s->padding_bug_score += 32;

327

328 /* try to detect the padding bug */

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

330 (s->workaround_bugs & FF_BUG_AUTODETECT) &&

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

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

333 !s->data_partitioning) {

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

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

336

337 if (bits_left == 0) {

338 s->padding_bug_score += 16;

339 } else if (bits_left != 1) {

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

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

342

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

344 s->padding_bug_score--;

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

346 bits_left <= 16)

347 s->padding_bug_score += 4;

348 else

349 s->padding_bug_score++;

350 }

351 }

352

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

354 (s->workaround_bugs & FF_BUG_AUTODETECT) &&

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

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

357 s->pict_type == AV_PICTURE_TYPE_I &&

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

359 !s->data_partitioning) {

360

361 s->padding_bug_score += 32;

362 }

363

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

365 (s->workaround_bugs & FF_BUG_AUTODETECT) &&

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

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

368

369 s->padding_bug_score += 32;

370 }

371

372 if (s->workaround_bugs & FF_BUG_AUTODETECT) {

373 if (

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

375 s->workaround_bugs |= FF_BUG_NO_PADDING;

376 else

377 s->workaround_bugs &= ~FF_BUG_NO_PADDING;

378 }

379

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

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

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

383 int max_extra = 7;

384

385 /* no markers in M$ crap */

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

387 max_extra += 17;

388

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

390 * the bitstream end */

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

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

393 max_extra += 48;

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

395 max_extra += 256 * 256 * 256 * 64;

396

397 if (left > max_extra)

398 av_log(s->avctx, AV_LOG_ERROR,

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

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

401 else if (left < 0)

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

403 else

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

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

406

407 return 0;

408 }

409

410 av_log(s->avctx, AV_LOG_ERROR,

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

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

413

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

415 ER_MB_END & part_mask);

416

417 return AVERROR_INVALIDDATA;

418 }

419

420 int ff_h263_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,

421 AVPacket *avpkt)

422 {

423 const uint8_t *buf = avpkt->data;

424 int buf_size = avpkt->size;

425 MpegEncContext *s = avctx->priv_data;

426 int ret;

427 int slice_ret = 0;

428 AVFrame *pict = data;

429

430 /* no supplementary picture */

431 if (buf_size == 0) {

432 /* special case for last picture */

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

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

435 return ret;

436 s->next_picture_ptr = NULL;

437

438 *got_frame = 1;

439 }

440

441 return 0;

442 }

443

444 if (s->avctx->flags & AV_CODEC_FLAG_TRUNCATED) {

445 int next;

446

447 if (CONFIG_MPEG4_DECODER && s->codec_id == AV_CODEC_ID_MPEG4) {

448 next = ff_mpeg4_find_frame_end(&s->parse_context, buf, buf_size);

449 } else if (CONFIG_H263_DECODER && s->codec_id == AV_CODEC_ID_H263) {

450 next = ff_h263_find_frame_end(&s->parse_context, buf, buf_size);

451 } else if (CONFIG_H263P_DECODER && s->codec_id == AV_CODEC_ID_H263P) {

452 next = ff_h263_find_frame_end(&s->parse_context, buf, buf_size);

453 } else {

454 av_log(s->avctx, AV_LOG_ERROR,

455 "this codec does not support truncated bitstreams\n");

456 return AVERROR(ENOSYS);

457 }

458

459 if (ff_combine_frame(&s->parse_context, next, (const uint8_t **)&buf,

460 &buf_size) < 0)

461 return buf_size;

462 }

463

464 retry:

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

466 int i;

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

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

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

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

471 s->bitstream_buffer_size = 0;

472 }

473 break;

474 }

475 }

476 }

477

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

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

480 s->bitstream_buffer_size);

481 else

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

483

484 s->bitstream_buffer_size = 0;

485 if (ret < 0)

486 return ret;

487

488 if (!s->context_initialized)

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

490 ff_mpv_idct_init(s);

491

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

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

494 ret = ff_wmv2_decode_picture_header(s);

495 } else if (CONFIG_MSMPEG4_DECODER && s->msmpeg4_version) {

496 ret = ff_msmpeg4_decode_picture_header(s);

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

498 if (s->avctx->extradata_size && s->picture_number == 0) {

499 GetBitContext gb;

500

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

502 ff_mpeg4_decode_picture_header(avctx->priv_data, &gb);

503 }

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

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

506 ret = ff_intel_h263_decode_picture_header(s);

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

508 ret = ff_flv_decode_picture_header(s);

509 } else {

510 ret = ff_h263_decode_picture_header(s);

511 }

512

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

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

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

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

517 s->width = avctx->coded_width;

518 s->height= avctx->coded_height;

519 }

520 }

521 if (ret == FRAME_SKIPPED)

522 return get_consumed_bytes(s, buf_size);

523

524 /* skip if the header was thrashed */

525 if (ret < 0) {

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

527 return ret;

528 }

529

530 if (!s->context_initialized) {

531 avctx->pix_fmt = h263_get_format(avctx);

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

533 return ret;

534 }

535

536 if (!s->current_picture_ptr || s->current_picture_ptr->f->data[0]) {

537 int i = ff_find_unused_picture(s->avctx, s->picture, 0);

538 if (i < 0)

539 return i;

540 s->current_picture_ptr = &s->picture[i];

541 }

542

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

544

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

546 if (ff_mpeg4_workaround_bugs(avctx) == 1)

547 goto retry;

548 }

549

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

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

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

553 * an H263EncContext */

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

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

556 s->context_reinit) {

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

558 s->context_reinit = 0;

559

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

561 if (ret < 0)

562 return ret;

563

564 ff_set_sar(avctx, avctx->sample_aspect_ratio);

565

566 if ((ret = ff_mpv_common_frame_size_change(s)))

567 return ret;

568

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

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

571 avctx->pix_fmt = AV_PIX_FMT_NONE;

572 return AVERROR_UNKNOWN;

573 }

574 }

575

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

577 s->codec_id == AV_CODEC_ID_H263P ||

578 s->codec_id == AV_CODEC_ID_H263I)

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

580

581 // for skipping the frame

582 s->current_picture.f->pict_type = s->pict_type;

583 s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;

584

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

586 if (!s->last_picture_ptr &&

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

588 return get_consumed_bytes(s, buf_size);

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

590 s->pict_type == AV_PICTURE_TYPE_B) ||

591 (avctx->skip_frame >= AVDISCARD_NONKEY &&

592 s->pict_type != AV_PICTURE_TYPE_I) ||

593 avctx->skip_frame >= AVDISCARD_ALL)

594 return get_consumed_bytes(s, buf_size);

595

596 if (s->next_p_frame_damaged) {

597 if (s->pict_type == AV_PICTURE_TYPE_B)

598 return get_consumed_bytes(s, buf_size);

599 else

600 s->next_p_frame_damaged = 0;

601 }

602

603 if ((!s->no_rounding) || s->pict_type == AV_PICTURE_TYPE_B) {

604 s->me.qpel_put = s->qdsp.put_qpel_pixels_tab;

605 s->me.qpel_avg = s->qdsp.avg_qpel_pixels_tab;

606 } else {

607 s->me.qpel_put = s->qdsp.put_no_rnd_qpel_pixels_tab;

608 s->me.qpel_avg = s->qdsp.avg_qpel_pixels_tab;

609 }

610

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

612 return ret;

613

614 if (!s->divx_packed)

615 ff_thread_finish_setup(avctx);

616

617 if (avctx->hwaccel) {

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

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

620 if (ret < 0 )

621 return ret;

622 }

623

624 ff_mpeg_er_frame_start(s);

625

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

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

628 * ff_mpv_frame_start() */

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

630 ret = ff_wmv2_decode_secondary_picture_header(s);

631 if (ret < 0)

632 return ret;

633 if (ret == 1)

634 goto frame_end;

635 }

636

637 /* decode each macroblock */

638 s->mb_x = 0;

639 s->mb_y = 0;

640

641 slice_ret = decode_slice(s);

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

643 if (s->msmpeg4_version) {

644 if (s->slice_height == 0 || s->mb_x != 0 ||

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

646 break;

647 } else {

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

649 if (ff_h263_resync(s) < 0)

650 break;

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

652 s->er.error_occurred = 1;

653 }

654

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

656 ff_mpeg4_clean_buffers(s);

657

658 if (decode_slice(s) < 0)

659 slice_ret = AVERROR_INVALIDDATA;

660 }

661

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

663 s->pict_type == AV_PICTURE_TYPE_I)

664 if (!CONFIG_MSMPEG4_DECODER ||

665 ff_msmpeg4_decode_ext_header(s, buf_size) < 0)

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

667

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

669 frame_end:

670 ff_er_frame_end(&s->er);

671

672 if (avctx->hwaccel) {

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

674 if (ret < 0)

675 return ret;

676 }

677

678 ff_mpv_frame_end(s);

679

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

681 ff_mpeg4_frame_end(avctx, buf, buf_size);

682

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

684 ff_thread_finish_setup(avctx);

685

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

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

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

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

690 return ret;

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

692 ff_mpv_export_qp_table(s, pict, s->current_picture_ptr, FF_QSCALE_TYPE_MPEG1);

693 } else if (s->last_picture_ptr) {

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

695 return ret;

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

697 ff_mpv_export_qp_table(s, pict, s->last_picture_ptr, FF_QSCALE_TYPE_MPEG1);

698 }

699

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

701 if ( pict->format == AV_PIX_FMT_YUV420P

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

703 int x, y, p;

704 av_frame_make_writable(pict);

705 for (p=0; p<3; p++) {

706 int w = AV_CEIL_RSHIFT(pict-> width, !!p);

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

708 int linesize = pict->linesize[p];

709 for (y=0; y<(h>>1); y++)

710 for (x=0; x<w; x++)

711 FFSWAP(int,

712 pict->data[p][x + y*linesize],

713 pict->data[p][x + (h-1-y)*linesize]);

714 }

715 }

716 *got_frame = 1;

717 }

718

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

720 return slice_ret;

721 else

722 return get_consumed_bytes(s, buf_size);

723 }

724

725 const enum AVPixelFormat ff_h263_hwaccel_pixfmt_list_420[] = {

726 #if CONFIG_H263_VAAPI_HWACCEL || CONFIG_MPEG4_VAAPI_HWACCEL

727 AV_PIX_FMT_VAAPI,

728 #endif

729 #if CONFIG_MPEG4_NVDEC_HWACCEL

730 AV_PIX_FMT_CUDA,

731 #endif

732 #if CONFIG_MPEG4_VDPAU_HWACCEL

733 AV_PIX_FMT_VDPAU,

734 #endif

735 #if CONFIG_H263_VIDEOTOOLBOX_HWACCEL || CONFIG_MPEG4_VIDEOTOOLBOX_HWACCEL

736 AV_PIX_FMT_VIDEOTOOLBOX,

737 #endif

738 AV_PIX_FMT_YUV420P,

739 AV_PIX_FMT_NONE

740 };

741

742 AVCodec ff_h263_decoder = {

743 .name = "h263",

744 .long_name = NULL_IF_CONFIG_SMALL("H.263 / H.263-1996, H.263+ / H.263-1998 / H.263 version 2"),

745 .type = AVMEDIA_TYPE_VIDEO,

746 .id = AV_CODEC_ID_H263,

747 .priv_data_size = sizeof(MpegEncContext),

748 .init = ff_h263_decode_init,

749 .close = ff_h263_decode_end,

750 .decode = ff_h263_decode_frame,

751 .capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 |

752 AV_CODEC_CAP_TRUNCATED | AV_CODEC_CAP_DELAY,

753 .caps_internal = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,

754 .flush = ff_mpeg_flush,

755 .max_lowres = 3,

756 .pix_fmts = ff_h263_hwaccel_pixfmt_list_420,

757 };

758

759 AVCodec ff_h263p_decoder = {

760 .name = "h263p",

761 .long_name = NULL_IF_CONFIG_SMALL("H.263 / H.263-1996, H.263+ / H.263-1998 / H.263 version 2"),

762 .type = AVMEDIA_TYPE_VIDEO,

763 .id = AV_CODEC_ID_H263P,

764 .priv_data_size = sizeof(MpegEncContext),

765 .init = ff_h263_decode_init,

766 .close = ff_h263_decode_end,

767 .decode = ff_h263_decode_frame,

768 .capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 |

769 AV_CODEC_CAP_TRUNCATED | AV_CODEC_CAP_DELAY,

770 .caps_internal = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,

771 .flush = ff_mpeg_flush,

772 .max_lowres = 3,

773 .pix_fmts = ff_h263_hwaccel_pixfmt_list_420,

774 .hw_configs = (const AVCodecHWConfigInternal*[]) {

775 #if CONFIG_H263_VAAPI_HWACCEL

776 HWACCEL_VAAPI(h263),

777 #endif

778 #if CONFIG_MPEG4_VDPAU_HWACCEL

779 HWACCEL_VDPAU(mpeg4),

780 #endif

781 #if CONFIG_H263_VIDEOTOOLBOX_HWACCEL

782 HWACCEL_VIDEOTOOLBOX(h263),

783 #endif

784 NULL

785 },

786 };

MpegEncContext::bitstream_buffer_size

int bitstream_buffer_size

Definition: mpegvideo.h:416

AV_EF_AGGRESSIVE

#define AV_EF_AGGRESSIVE

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

Definition: avcodec.h:2658

ff_tlog

#define ff_tlog(ctx,...)

Definition: internal.h:75

NULL

#define NULL

Definition: coverity.c:32

ff_get_format

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

Select the (possibly hardware accelerated) pixel format.

Definition: decode.c:1299

AVCodecContext::codec

const struct AVCodec * codec

Definition: avcodec.h:1527

AVDISCARD_NONKEY

discard all frames except keyframes

Definition: avcodec.h:793

ff_init_block_index

void ff_init_block_index(MpegEncContext *s)

Definition: mpegvideo.c:2231

AVHWAccel::start_frame

int(* start_frame)(AVCodecContext *avctx, const uint8_t *buf, uint32_t buf_size)

Called at the beginning of each frame or field picture.

Definition: avcodec.h:3638

QpelDSPContext::avg_qpel_pixels_tab

qpel_mc_func avg_qpel_pixels_tab[2][16]

Definition: qpeldsp.h:74

hwaccel.h

MpegEncContext::picture_number

int picture_number

Definition: mpegvideo.h:127

const char * s

Definition: avisynth_c.h:768

AVERROR_INVALIDDATA

#define AVERROR_INVALIDDATA

Invalid data found when processing input.

Definition: error.h:59

AVCHROMA_LOC_LEFT

MPEG-2/4 4:2:0, H.264 default for 4:2:0.

Definition: pixfmt.h:520

AVFrame

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

Definition: frame.h:218

AV_PIX_FMT_NONE

Definition: pixfmt.h:61

Definition: vp9dsp_template.c:2038

data

ptrdiff_t const GLvoid * data

Definition: opengl_enc.c:101

flush

static void flush(AVCodecContext *avctx)

Definition: aacdec_template.c:500

AVCodecContext::coded_width

int coded_width

Bitstream width / height, may be different from width/height e.g.

Definition: avcodec.h:1705

SLICE_NOEND

#define SLICE_NOEND

no end marker or error found but mb count exceeded

Definition: mpegvideo.h:516

mpeg4video.h

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:182

QpelDSPContext::put_no_rnd_qpel_pixels_tab

qpel_mc_func put_no_rnd_qpel_pixels_tab[2][16]

Definition: qpeldsp.h:75

ER_MB_END

#define ER_MB_END

Definition: error_resilience.h:39

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:104

AV_PIX_FMT_VIDEOTOOLBOX

hardware decoding through Videotoolbox

Definition: pixfmt.h:278

init

static av_cold int init(AVCodecContext *avctx)

Definition: avrndec.c:35

decode_slice

static int decode_slice(MpegEncContext *s)

Definition: h263dec.c:192

AV_CODEC_ID_VC1

Definition: avcodec.h:288

ff_er_frame_end

void ff_er_frame_end(ERContext *s)

Definition: error_resilience.c:901

AVCodecContext::color_range

enum AVColorRange color_range

MPEG vs JPEG YUV range.

Definition: avcodec.h:2148

MpegEncContext::msmpeg4_version

int msmpeg4_version

0=not msmpeg4, 1=mp41, 2=mp42, 3=mp43/divx3 4=wmv1/7 5=wmv2/8

Definition: mpegvideo.h:438

ff_h263dsp_init

av_cold void ff_h263dsp_init(H263DSPContext *ctx)

Definition: h263dsp.c:117

AVPacket::size

int size

Definition: avcodec.h:1431

MpegEncContext::bitstream_buffer

uint8_t * bitstream_buffer

Definition: mpegvideo.h:415

MpegEncContext::codec_id

enum AVCodecID codec_id

Definition: mpegvideo.h:112

AV_EF_BUFFER

#define AV_EF_BUFFER

detect improper bitstream length

Definition: avcodec.h:2652

GetBitContext::buffer

const uint8_t * buffer

Definition: get_bits.h:57

AVCodecContext::sample_aspect_ratio

AVRational sample_aspect_ratio

sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel...

Definition: avcodec.h:1896

FMT_H263

Definition: mpegutils.h:126

AVCodecContext::pix_fmt

enum AVPixelFormat pix_fmt

Pixel format, see AV_PIX_FMT_xxx.

Definition: avcodec.h:1727

FF_PROFILE_MPEG4_SIMPLE_STUDIO

#define FF_PROFILE_MPEG4_SIMPLE_STUDIO

Definition: avcodec.h:2917

ff_mpeg4_frame_end

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

Definition: mpeg4videodec.c:3247

AV_CODEC_ID_VC1IMAGE

Definition: avcodec.h:370

MpegEncContext::studio_profile

int studio_profile

Definition: mpegvideo.h:384

ff_msmpeg4_decode_ext_header

int ff_msmpeg4_decode_ext_header(MpegEncContext *s, int buf_size)

Definition: msmpeg4dec.c:559

AV_CODEC_ID_MPEG4

Definition: avcodec.h:230

mpegvideo.h

mpegvideo header.

AV_CODEC_ID_H263I

Definition: avcodec.h:238

wmv2.h

AVDISCARD_ALL

discard all

Definition: avcodec.h:794

ff_mpeg4_workaround_bugs

int ff_mpeg4_workaround_bugs(AVCodecContext *avctx)

Definition: mpeg4videodec.c:2459

AVCodecContext::bits_per_raw_sample

int bits_per_raw_sample

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

Definition: avcodec.h:2741

MpegEncContext::padding_bug_score

int padding_bug_score

used to detect the VERY common padding bug in MPEG-4

Definition: mpegvideo.h:411

HWACCEL_VIDEOTOOLBOX

Definition: ffmpeg.h:62

MpegEncContext::mb_num

int mb_num

number of MBs of a picture

Definition: mpegvideo.h:133

AVCodecContext::hwaccel

const struct AVHWAccel * hwaccel

Hardware accelerator in use.

Definition: avcodec.h:2674

AVCodecContext::profile

int profile

profile

Definition: avcodec.h:2843

MpegEncContext::qdsp

QpelDSPContext qdsp

Definition: mpegvideo.h:235

AVCodec

AVCodec.

Definition: avcodec.h:3408

MpegEncContext::qscale

int qscale

QP.

Definition: mpegvideo.h:204

decode

static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)

Definition: decode_audio.c:42

MpegEncContext::quant_precision

int quant_precision

Definition: mpegvideo.h:400

ff_h263_decode_mb

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

Definition: ituh263dec.c:697

AVCodecContext::skip_frame

enum AVDiscard skip_frame

Skip decoding for selected frames.

Definition: avcodec.h:2975

ff_mpeg4_clean_buffers

void ff_mpeg4_clean_buffers(MpegEncContext *s)

Definition: mpeg4video.c:45

AV_CODEC_CAP_DELAY

#define AV_CODEC_CAP_DELAY

Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...

Definition: avcodec.h:984

ff_mpeg_draw_horiz_band

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

Definition: mpegvideo.c:2224

MpegEncContext::context_reinit

int context_reinit

Definition: mpegvideo.h:561

h263_get_format

static enum AVPixelFormat h263_get_format(AVCodecContext *avctx)

Definition: h263dec.c:48

ff_h263_decode_init_vlc

void ff_h263_decode_init_vlc(void)

Definition: ituh263dec.c:108

uint8_t

Definition: audio_convert.c:194

av_cold

#define av_cold

Definition: attributes.h:82

MpegEncContext::out_format

enum OutputFormat out_format

output format

Definition: mpegvideo.h:104

AV_CODEC_ID_MSMPEG4V1

Definition: avcodec.h:232

ff_mpv_common_frame_size_change

int ff_mpv_common_frame_size_change(MpegEncContext *s)

Definition: mpegvideo.c:1043

thread.h

Multithreading support functions.

ER_MB_ERROR

#define ER_MB_ERROR

Definition: error_resilience.h:38

MotionEstContext::qpel_put

qpel_mc_func(* qpel_put)[16]

Definition: motion_est.h:91

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:441

AVCodecContext::extradata

uint8_t * extradata

some codecs need / can use extradata like Huffman tables.

Definition: avcodec.h:1618

MpegEncContext::no_rounding

int no_rounding

apply no rounding to motion compensation (MPEG-4, msmpeg4, ...) for B-frames rounding mode is always ...

Definition: mpegvideo.h:284

ff_intel_h263_decode_picture_header

int ff_intel_h263_decode_picture_header(MpegEncContext *s)

Definition: intelh263dec.c:27

MpegEncContext::current_picture

Picture current_picture

copy of the current picture structure.

Definition: mpegvideo.h:180

MpegEncContext::last_resync_gb

GetBitContext last_resync_gb

used to search for the next resync marker

Definition: mpegvideo.h:358

ff_find_unused_picture

int ff_find_unused_picture(AVCodecContext *avctx, Picture *picture, int shared)

Definition: mpegpicture.c:446

qpeldsp.h

quarterpel DSP functions

MpegEncContext::gob_index

int gob_index

Definition: mpegvideo.h:365

AV_CODEC_ID_FLV1

Definition: avcodec.h:239

AVPacket::data

uint8_t * data

Definition: avcodec.h:1430

get_bits_count

static int get_bits_count(const GetBitContext *s)

Definition: get_bits.h:200

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:119

ff_dlog

#define ff_dlog(a,...)

Definition: tableprint_vlc.h:29

ff_mpv_idct_init

av_cold void ff_mpv_idct_init(MpegEncContext *s)

Definition: mpegvideo.c:330

MpegEncContext::mb_height

int mb_height

number of MBs horizontally & vertically

Definition: mpegvideo.h:129

AVCodecContext::lowres

int lowres

low resolution decoding, 1-> 1/2 size, 2->1/4 size

Definition: avcodec.h:2749

mpegutils.h

MpegEncContext::codec_tag

int codec_tag

internal codec_tag upper case converted from avctx codec_tag

Definition: mpegvideo.h:120

ff_thread_finish_setup

void ff_thread_finish_setup(AVCodecContext *avctx)

If the codec defines update_thread_context(), call this when they are ready for the next thread to st...

Definition: pthread_frame.c:601

AV_CODEC_FLAG_GRAY

#define AV_CODEC_FLAG_GRAY

Only decode/encode grayscale.

Definition: avcodec.h:861

AVCodecContext::chroma_sample_location

enum AVChromaLocation chroma_sample_location

This defines the location of chroma samples.

Definition: avcodec.h:2155

av_log

#define av_log(a,...)

Definition: tableprint_vlc.h:28

ff_update_block_index

static void ff_update_block_index(MpegEncContext *s)

Definition: mpegvideo.h:739

ff_set_qscale

void ff_set_qscale(MpegEncContext *s, int qscale)

set qscale and update qscale dependent variables.

Definition: mpegvideo.c:2295

flv.h

ff_msmpeg4_decode_picture_header

int ff_msmpeg4_decode_picture_header(MpegEncContext *s)

Definition: msmpeg4dec.c:411

get_bits_left

static int get_bits_left(GetBitContext *gb)

Definition: get_bits.h:596

AVCodec::id

enum AVCodecID id

Definition: avcodec.h:3422

MpegEncContext::h263dsp

H263DSPContext h263dsp

Definition: mpegvideo.h:237

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:176

AVCodecContext::has_b_frames

int has_b_frames

Size of the frame reordering buffer in the decoder.

Definition: avcodec.h:1807

MpegEncContext::last_dc

int last_dc[3]

last DC values for MPEG-1

Definition: mpegvideo.h:185

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:831

ff_combine_frame

int ff_combine_frame(ParseContext *pc, int next, const uint8_t **buf, int *buf_size)

Combine the (truncated) bitstream to a complete frame.

Definition: parser.c:319

MpegEncContext::partitioned_frame

int partitioned_frame

is current frame partitioned

Definition: mpegvideo.h:405

AVERROR

#define AVERROR(e)

Definition: error.h:43

ff_h263_decoder

AVCodec ff_h263_decoder

Definition: h263dec.c:742

MpegEncContext::unrestricted_mv

int unrestricted_mv

mv can point outside of the coded picture

Definition: mpegvideo.h:223

NULL_IF_CONFIG_SMALL

#define NULL_IF_CONFIG_SMALL(x)

Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...

Definition: internal.h:186

MpegEncContext::er

ERContext er

Definition: mpegvideo.h:563

AV_PIX_FMT_VAAPI

Definition: pixfmt.h:118

AVCodecHWConfigInternal

Definition: hwaccel.h:29

AVCodecContext::flags

int flags

AV_CODEC_FLAG_*.

Definition: avcodec.h:1598

AV_CODEC_ID_MSMPEG4V2

Definition: avcodec.h:233

FF_BUG_NO_PADDING

#define FF_BUG_NO_PADDING

Definition: avcodec.h:2551

width

uint16_t width

Definition: gdv.c:47

AVCodec::name

const char * name

Name of the codec implementation.

Definition: avcodec.h:3415

h263.h

MpegEncContext::low_delay

int low_delay

no reordering needed / has no B-frames

Definition: mpegvideo.h:406

QpelDSPContext::put_qpel_pixels_tab

qpel_mc_func put_qpel_pixels_tab[2][16]

Definition: qpeldsp.h:73

MpegEncContext::gb

GetBitContext gb

Definition: mpegvideo.h:448

ff_mpv_common_end

void ff_mpv_common_end(MpegEncContext *s)

Definition: mpegvideo.c:1122

ff_mpeg4_decode_studio_slice_header

int ff_mpeg4_decode_studio_slice_header(Mpeg4DecContext *ctx)

Decode the next video packet.

Definition: mpeg4videodec.c:544

ff_flv_decode_picture_header

int ff_flv_decode_picture_header(MpegEncContext *s)

Definition: flvdec.c:28

ff_mpeg_flush

void ff_mpeg_flush(AVCodecContext *avctx)

Definition: mpegvideo.c:2264

frame_end

static void frame_end(MpegEncContext *s)

Definition: mpegvideo_enc.c:1692

MpegEncContext::resync_mb_x

int resync_mb_x

x position of last resync marker

Definition: mpegvideo.h:356

ERContext::error_status_table

uint8_t * error_status_table

Definition: error_resilience.h:66

ER_AC_ERROR

#define ER_AC_ERROR

Definition: error_resilience.h:31

ff_h263_loop_filter

void ff_h263_loop_filter(MpegEncContext *s)

Definition: h263.c:135

AV_CODEC_CAP_DRAW_HORIZ_BAND

#define AV_CODEC_CAP_DRAW_HORIZ_BAND

Decoder can use draw_horiz_band callback.

Definition: avcodec.h:953

ff_mpv_export_qp_table

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

Definition: mpegvideo.c:1435

AVCodec::pix_fmts

enum AVPixelFormat * pix_fmts

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

Definition: avcodec.h:3429

AV_PICTURE_TYPE_I

Intra.

Definition: avutil.h:274

AVFrame::pict_type

enum AVPictureType pict_type

Picture type of the frame.

Definition: frame.h:301

AVCodecContext::err_recognition

int err_recognition

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

Definition: avcodec.h:2642

av_assert1

#define av_assert1(cond)

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

Definition: avassert.h:53

MpegEncContext::mb_y

int mb_y

Definition: mpegvideo.h:288

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:166

MpegEncContext::mv_dir

int mv_dir

Definition: mpegvideo.h:261

ParseContext::last_index

int last_index

Definition: parser.h:31

MpegEncContext::next_p_frame_damaged

int next_p_frame_damaged

set if the next p frame is damaged, to avoid showing trashed B-frames

Definition: mpegvideo.h:360

MpegEncContext::mb_x

int mb_x

Definition: mpegvideo.h:288

uint8_t w

Definition: llviddspenc.c:38

MpegEncContext::current_picture_ptr

Picture * current_picture_ptr

pointer to the current picture

Definition: mpegvideo.h:184

MpegEncContext::width

int width

Definition: mpegvideo.h:100

ff_mpeg_er_frame_start

void ff_mpeg_er_frame_start(MpegEncContext *s)

Definition: mpeg_er.c:46

ff_mpeg4_decode_picture_header

int ff_mpeg4_decode_picture_header(Mpeg4DecContext *ctx, GetBitContext *gb)

Decode MPEG-4 headers.

Definition: mpeg4videodec.c:3083

GetBitContext::size_in_bits

int size_in_bits

Definition: get_bits.h:59

AV_CODEC_ID_WMV2

Definition: avcodec.h:236

ff_wmv2_decode_secondary_picture_header

int ff_wmv2_decode_secondary_picture_header(MpegEncContext *s)

Definition: wmv2dec.c:147

show_bits

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

Show 1-25 bits.

Definition: get_bits.h:304

msmpeg4.h

AV_CODEC_ID_H263

Definition: avcodec.h:222

MpegEncContext::mb_width

int mb_width

Definition: mpegvideo.h:129

MpegEncContext::droppable

int droppable

Definition: mpegvideo.h:216

ff_h263p_decoder

AVCodec ff_h263p_decoder

Definition: h263dec.c:759

MpegEncContext::me

MotionEstContext me

Definition: mpegvideo.h:282

AV_EF_EXPLODE

#define AV_EF_EXPLODE

abort decoding on minor error detection

Definition: avcodec.h:2653

FRAME_SKIPPED

#define FRAME_SKIPPED

Return value for header parsers if frame is not coded.

Definition: mpegutils.h:34

ff_h263_decode_frame

int ff_h263_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)

Definition: h263dec.c:420

AV_PIX_FMT_CUDA

HW acceleration through CUDA.

Definition: pixfmt.h:231

ff_mpv_decode_defaults

void ff_mpv_decode_defaults(MpegEncContext *s)

Set the given MpegEncContext to defaults for decoding.

Definition: mpegvideo.c:662

ff_h263_decode_end

av_cold int ff_h263_decode_end(AVCodecContext *avctx)

Definition: h263dec.c:155

AV_CODEC_ID_WMV3IMAGE

Definition: avcodec.h:369

AVFrame::format

int format

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

Definition: frame.h:291

MV_TYPE_16X16

#define MV_TYPE_16X16

1 vector for the whole mb

Definition: mpegvideo.h:266

MpegEncContext::first_slice_line

int first_slice_line

used in MPEG-4 too to handle resync markers

Definition: mpegvideo.h:436

MpegEncContext::loop_filter

int loop_filter

Definition: mpegvideo.h:380

avcodec.h

Libavcodec external API header.

ff_h263_update_motion_val

void ff_h263_update_motion_val(MpegEncContext *s)

Definition: h263.c:42

MpegEncContext::h263_flv

int h263_flv

use flv H.263 header

Definition: mpegvideo.h:110

AVCodecContext::codec_id

enum AVCodecID codec_id

Definition: avcodec.h:1528

AVFrame::linesize

int linesize[AV_NUM_DATA_POINTERS]

For video, size in bytes of each picture line.

Definition: frame.h:249

AV_CODEC_ID_WMV1

Definition: avcodec.h:235

cpu.h

init_get_bits8

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

Initialize GetBitContext.

Definition: get_bits.h:464

error_resilience.h

AVCodecContext

main external API structure.

Definition: avcodec.h:1518

mpeg_er.h

MpegEncContext::height

int height

picture size. must be a multiple of 16

Definition: mpegvideo.h:100

AVCodecContext::codec_tag

unsigned int codec_tag

fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').

Definition: avcodec.h:1543

MpegEncContext::ehc_mode

int ehc_mode

Definition: mpegvideo.h:371

buf

void * buf

Definition: avisynth_c.h:690

ff_print_debug_info

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

Definition: mpegvideo.c:1428

SLICE_END

#define SLICE_END

end marker found

Definition: mpegvideo.h:515

MpegEncContext::picture

Picture * picture

main picture buffer

Definition: mpegvideo.h:136

MpegEncContext::data_partitioning

int data_partitioning

data partitioning flag from header

Definition: mpegvideo.h:404

AVCodecContext::extradata_size

int extradata_size

Definition: avcodec.h:1619

ff_mpeg4_decode_partitions

int ff_mpeg4_decode_partitions(Mpeg4DecContext *ctx)

Decode the first and second partition.

Definition: mpeg4videodec.c:973

AVCodecContext::coded_height

int coded_height

Definition: avcodec.h:1705

Picture::f

struct AVFrame * f

Definition: mpegpicture.h:46

AV_PIX_FMT_VDPAU

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

Definition: pixfmt.h:193

MpegEncContext::context_initialized

int context_initialized

Definition: mpegvideo.h:124

AV_EF_IGNORE_ERR

#define AV_EF_IGNORE_ERR

ignore errors and continue

Definition: avcodec.h:2655

MpegEncContext::slice_height

int slice_height

in macroblocks

Definition: mpegvideo.h:435

AV_CODEC_ID_MSS2

Definition: avcodec.h:385

ff_h263_decode_picture_header

int ff_h263_decode_picture_header(MpegEncContext *s)

Definition: ituh263dec.c:999

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.c:1196

AV_CODEC_ID_H263P

Definition: avcodec.h:237

MV_DIR_FORWARD

#define MV_DIR_FORWARD

Definition: mpegvideo.h:262

MpegEncContext::pict_type

int pict_type

AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B, ...

Definition: mpegvideo.h:212

pix_fmts

static enum AVPixelFormat pix_fmts[]

Definition: libkvazaar.c:266

AV_CODEC_CAP_TRUNCATED

#define AV_CODEC_CAP_TRUNCATED

Definition: avcodec.h:960

FF_BUG_AUTODETECT

#define FF_BUG_AUTODETECT

autodetection

Definition: avcodec.h:2548

MpegEncContext::h263_pred

int h263_pred

use MPEG-4/H.263 ac/dc predictions

Definition: mpegvideo.h:105

HWACCEL_VAAPI

#define HWACCEL_VAAPI(codec)

Definition: hwaccel.h:73

ff_h263_decode_init

av_cold int ff_h263_decode_init(AVCodecContext *avctx)

Definition: h263dec.c:68

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:213

av_frame_make_writable

int av_frame_make_writable(AVFrame *frame)

Ensure that the frame data is writable, avoiding data copy if possible.

Definition: frame.c:609

AVFrame::data

uint8_t * data[AV_NUM_DATA_POINTERS]

pointer to the picture/channel planes.

Definition: frame.h:232

MotionEstContext::qpel_avg

qpel_mc_func(* qpel_avg)[16]

Definition: motion_est.h:92

AVCOL_RANGE_MPEG

the normal 219*2^(n-8) "MPEG" YUV ranges

Definition: pixfmt.h:498

MpegEncContext

MpegEncContext.

Definition: mpegvideo.h:81

MpegEncContext::next_picture_ptr

Picture * next_picture_ptr

pointer to the next picture (for bidir pred)

Definition: mpegvideo.h:183

MpegEncContext::avctx

struct AVCodecContext * avctx

Definition: mpegvideo.h:98

AVDISCARD_NONREF

discard all non reference

Definition: avcodec.h:790

AV_RB64

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_RB64

Definition: bytestream.h:87

AV_CODEC_ID_WMV3

Definition: avcodec.h:289

AV_PIX_FMT_YUV420P

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

Definition: pixfmt.h:62

AV_PIX_FMT_GRAY8

Y , 8bpp.

Definition: pixfmt.h:70

GetBitContext

Definition: get_bits.h:56

internal.h

common internal api header.

MpegEncContext::mb_stride

int mb_stride

mb_width+1 used for some arrays to allow simple addressing of left & top MBs without sig11 ...

Definition: mpegvideo.h:130

ff_mpv_decode_init

void ff_mpv_decode_init(MpegEncContext *s, AVCodecContext *avctx)

Definition: mpegvideo.c:667

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: internal.h:60

MpegEncContext::divx_packed

int divx_packed

Definition: mpegvideo.h:414

GetBitContext::buffer_end

const uint8_t * buffer_end

Definition: get_bits.h:57

ff_wmv2_decode_picture_header

int ff_wmv2_decode_picture_header(MpegEncContext *s)

Definition: wmv2dec.c:127

ff_h263_hwaccel_pixfmt_list_420

enum AVPixelFormat ff_h263_hwaccel_pixfmt_list_420[]

Definition: h263dec.c:725

MpegEncContext::last_picture_ptr

Picture * last_picture_ptr

pointer to the previous picture.

Definition: mpegvideo.h:182

AV_PICTURE_TYPE_B

Bi-dir predicted.

Definition: avutil.h:276

H263_GOB_HEIGHT

#define H263_GOB_HEIGHT(h)

Definition: h263.h:42

AVERROR_UNKNOWN

#define AVERROR_UNKNOWN

Unknown error, typically from an external library.

Definition: error.h:71

mpeg4video_parser.h

ERContext::error_occurred

int error_occurred

Definition: error_resilience.h:65

AVCodecContext::priv_data

void * priv_data

Definition: avcodec.h:1545

AV_CODEC_ID_MSMPEG4V3

Definition: avcodec.h:234

ff_mpv_common_init

av_cold int ff_mpv_common_init(MpegEncContext *s)

init common structure for both encoder and decoder.

Definition: mpegvideo.c:883

MpegEncContext::mv_type

int mv_type

Definition: mpegvideo.h:265

ff_mpv_frame_end

void ff_mpv_frame_end(MpegEncContext *s)

Definition: mpegvideo.c:1420

ff_mpv_reconstruct_mb

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

Definition: mpegvideo.c:2212

MpegEncContext::resync_mb_y

int resync_mb_y

y position of last resync marker

Definition: mpegvideo.h:357

MpegEncContext::block

int16_t(* block)[64]

points to one of the following blocks

Definition: mpegvideo.h:507

MpegEncContext::parse_context

ParseContext parse_context

Definition: mpegvideo.h:362

AVFrame::key_frame

int key_frame

1 -> keyframe, 0-> not

Definition: frame.h:296

AV_CODEC_FLAG_TRUNCATED

#define AV_CODEC_FLAG_TRUNCATED

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

Definition: avcodec.h:870

AVFrame::height

int height

Definition: frame.h:276

h263_parser.h

HWACCEL_VDPAU

#define HWACCEL_VDPAU(codec)

Definition: hwaccel.h:75

start

void INT64 start

Definition: avisynth_c.h:690

MpegEncContext::workaround_bugs

int workaround_bugs

workaround bugs in encoders which cannot be detected automatically

Definition: mpegvideo.h:119

AVMEDIA_TYPE_VIDEO

Definition: avutil.h:201

MpegEncContext::decode_mb

int(* decode_mb)(struct MpegEncContext *s, int16_t block[12][64])

Definition: mpegvideo.h:509

AVCHROMA_LOC_CENTER

MPEG-1 4:2:0, JPEG 4:2:0, H.263 4:2:0.

Definition: pixfmt.h:521

ER_AC_END

#define ER_AC_END

Definition: error_resilience.h:34

ff_mpeg4_find_frame_end

int ff_mpeg4_find_frame_end(ParseContext *pc, const uint8_t *buf, int buf_size)

Find the end of the current frame in the bitstream.

Definition: mpeg4video_parser.c:37

ff_qpeldsp_init

av_cold void ff_qpeldsp_init(QpelDSPContext *c)

Definition: qpeldsp.c:783

FFSWAP

#define FFSWAP(type, a, b)

Definition: common.h:99

CONFIG_MSMPEG4_DECODER

#define CONFIG_MSMPEG4_DECODER

Definition: msmpeg4.h:69

AVHWAccel::decode_slice

int(* decode_slice)(AVCodecContext *avctx, const uint8_t *buf, uint32_t buf_size)

Callback for each slice.

Definition: avcodec.h:3666

ff_h263_find_frame_end

int ff_h263_find_frame_end(ParseContext *pc, const uint8_t *buf, int buf_size)

Definition: h263_parser.c:30

FF_QSCALE_TYPE_MPEG1

#define FF_QSCALE_TYPE_MPEG1

Definition: internal.h:81

AVHWAccel::end_frame

int(* end_frame)(AVCodecContext *avctx)

Called at the end of each frame or field picture.

Definition: avcodec.h:3677

AV_RL32

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32

Definition: bytestream.h:87

AVPixelFormat

Pixel format.

Definition: pixfmt.h:60

AVPacket

This structure stores compressed data.

Definition: avcodec.h:1407

ff_mpv_report_decode_progress

void ff_mpv_report_decode_progress(MpegEncContext *s)

Definition: mpegvideo.c:2309

MAX_NVOP_SIZE

#define MAX_NVOP_SIZE

Definition: mpeg4video.h:70

AV_CODEC_CAP_DR1

#define AV_CODEC_CAP_DR1

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

Definition: avcodec.h:959

AV_CEIL_RSHIFT

#define AV_CEIL_RSHIFT(a, b)

Definition: common.h:58

AVCOL_RANGE_UNSPECIFIED

Definition: pixfmt.h:497

Generated on Sun May 13 2018 02:03:47 for FFmpeg by doxygen 1.8.6