FFmpeg: libavcodec/h264dec.c Source File

FFmpeg

[フレーム]

libavcodec

h264dec.c

Go to the documentation of this file.

1 /*

2 * H.26L/H.264/AVC/JVT/14496-10/... decoder

4 *

5 * This file is part of FFmpeg.

6 *

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

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

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

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

11 *

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

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

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

15 * Lesser General Public License for more details.

16 *

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

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

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

20 */

22 /**

23 * @file

24 * H.264 / AVC / MPEG-4 part10 codec.

25 * @author Michael Niedermayer <michaelni@gmx.at>

26 */

28 #define UNCHECKED_BITSTREAM_READER 1

30 #include "libavutil/avassert.h"

31 #include "libavutil/display.h"

32 #include "libavutil/imgutils.h"

33 #include "libavutil/opt.h"

34 #include "libavutil/stereo3d.h"

35 #include "libavutil/timer.h"

36 #include "internal.h"

37 #include "bytestream.h"

38 #include "cabac.h"

39 #include "cabac_functions.h"

40 #include "error_resilience.h"

41 #include "avcodec.h"

42 #include "h264.h"

43 #include "h264dec.h"

44 #include "h2645_parse.h"

45 #include "h264data.h"

46 #include "h264chroma.h"

47 #include "h264_mvpred.h"

48 #include "h264_ps.h"

49 #include "golomb.h"

50 #include "hwaccel.h"

51 #include "mathops.h"

52 #include "me_cmp.h"

53 #include "mpegutils.h"

54 #include "profiles.h"

55 #include "rectangle.h"

56 #include "thread.h"

58 const uint16_t ff_h264_mb_sizes[4] = { 256, 384, 512, 768 };

60 int avpriv_h264_has_num_reorder_frames(AVCodecContext *avctx)

61 {

62 H264Context *h = avctx->priv_data;

63 return h && h->ps.sps ? h->ps.sps->num_reorder_frames : 0;

64 }

66 static void h264_er_decode_mb(void *opaque, int ref, int mv_dir, int mv_type,

67 int (*mv)[2][4][2],

68 int mb_x, int mb_y, int mb_intra, int mb_skipped)

69 {

70 H264Context *h = opaque;

71 H264SliceContext *sl = &h->slice_ctx[0];

73 sl->mb_x = mb_x;

74 sl->mb_y = mb_y;

75 sl->mb_xy = mb_x + mb_y * h->mb_stride;

76 memset(sl->non_zero_count_cache, 0, sizeof(sl->non_zero_count_cache));

77 av_assert1(ref >= 0);

78 /* FIXME: It is possible albeit uncommon that slice references

79 * differ between slices. We take the easy approach and ignore

80 * it for now. If this turns out to have any relevance in

81 * practice then correct remapping should be added. */

82 if (ref >= sl->ref_count[0])

83 ref = 0;

84 if (!sl->ref_list[0][ref].data[0]) {

85 av_log(h->avctx, AV_LOG_DEBUG, "Reference not available for error concealing\n");

86 ref = 0;

87 }

88 if ((sl->ref_list[0][ref].reference&3) != 3) {

89 av_log(h->avctx, AV_LOG_DEBUG, "Reference invalid\n");

90 return;

91 }

92 fill_rectangle(&h->cur_pic.ref_index[0][4 * sl->mb_xy],

93 2, 2, 2, ref, 1);

94 fill_rectangle(&sl->ref_cache[0][scan8[0]], 4, 4, 8, ref, 1);

95 fill_rectangle(sl->mv_cache[0][scan8[0]], 4, 4, 8,

96 pack16to32((*mv)[0][0][0], (*mv)[0][0][1]), 4);

97 sl->mb_mbaff =

98 sl->mb_field_decoding_flag = 0;

99 ff_h264_hl_decode_mb(h, &h->slice_ctx[0]);

100 }

101

102 void ff_h264_draw_horiz_band(const H264Context *h, H264SliceContext *sl,

103 int y, int height)

104 {

105 AVCodecContext *avctx = h->avctx;

106 const AVFrame *src = h->cur_pic.f;

107 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);

108 int vshift = desc->log2_chroma_h;

109 const int field_pic = h->picture_structure != PICT_FRAME;

110 if (field_pic) {

111 height <<= 1;

112 y <<= 1;

113 }

114

115 height = FFMIN(height, avctx->height - y);

116

117 if (field_pic && h->first_field && !(avctx->slice_flags & SLICE_FLAG_ALLOW_FIELD))

118 return;

119

120 if (avctx->draw_horiz_band) {

121 int offset[AV_NUM_DATA_POINTERS];

122 int i;

123

124 offset[0] = y * src->linesize[0];

125 offset[1] =

126 offset[2] = (y >> vshift) * src->linesize[1];

127 for (i = 3; i < AV_NUM_DATA_POINTERS; i++)

128 offset[i] = 0;

129

130 emms_c();

131

132 avctx->draw_horiz_band(avctx, src, offset,

133 y, h->picture_structure, height);

134 }

135 }

136

137 void ff_h264_free_tables(H264Context *h)

138 {

139 int i;

140

141 av_freep(&h->intra4x4_pred_mode);

142 av_freep(&h->chroma_pred_mode_table);

143 av_freep(&h->cbp_table);

144 av_freep(&h->mvd_table[0]);

145 av_freep(&h->mvd_table[1]);

146 av_freep(&h->direct_table);

147 av_freep(&h->non_zero_count);

148 av_freep(&h->slice_table_base);

149 h->slice_table = NULL;

150 av_freep(&h->list_counts);

151

152 av_freep(&h->mb2b_xy);

153 av_freep(&h->mb2br_xy);

154

155 av_buffer_pool_uninit(&h->qscale_table_pool);

156 av_buffer_pool_uninit(&h->mb_type_pool);

157 av_buffer_pool_uninit(&h->motion_val_pool);

158 av_buffer_pool_uninit(&h->ref_index_pool);

159

160 for (i = 0; i < h->nb_slice_ctx; i++) {

161 H264SliceContext *sl = &h->slice_ctx[i];

162

163 av_freep(&sl->dc_val_base);

164 av_freep(&sl->er.mb_index2xy);

165 av_freep(&sl->er.error_status_table);

166 av_freep(&sl->er.er_temp_buffer);

167

168 av_freep(&sl->bipred_scratchpad);

169 av_freep(&sl->edge_emu_buffer);

170 av_freep(&sl->top_borders[0]);

171 av_freep(&sl->top_borders[1]);

172

173 sl->bipred_scratchpad_allocated = 0;

174 sl->edge_emu_buffer_allocated = 0;

175 sl->top_borders_allocated[0] = 0;

176 sl->top_borders_allocated[1] = 0;

177 }

178 }

179

180 int ff_h264_alloc_tables(H264Context *h)

181 {

182 const int big_mb_num = h->mb_stride * (h->mb_height + 1);

183 const int row_mb_num = 2*h->mb_stride*FFMAX(h->nb_slice_ctx, 1);

184 int x, y;

185

186 FF_ALLOCZ_ARRAY_OR_GOTO(h->avctx, h->intra4x4_pred_mode,

187 row_mb_num, 8 * sizeof(uint8_t), fail)

188 h->slice_ctx[0].intra4x4_pred_mode = h->intra4x4_pred_mode;

189

190 FF_ALLOCZ_OR_GOTO(h->avctx, h->non_zero_count,

191 big_mb_num * 48 * sizeof(uint8_t), fail)

192 FF_ALLOCZ_OR_GOTO(h->avctx, h->slice_table_base,

193 (big_mb_num + h->mb_stride) * sizeof(*h->slice_table_base), fail)

194 FF_ALLOCZ_OR_GOTO(h->avctx, h->cbp_table,

195 big_mb_num * sizeof(uint16_t), fail)

196 FF_ALLOCZ_OR_GOTO(h->avctx, h->chroma_pred_mode_table,

197 big_mb_num * sizeof(uint8_t), fail)

198 FF_ALLOCZ_ARRAY_OR_GOTO(h->avctx, h->mvd_table[0],

199 row_mb_num, 16 * sizeof(uint8_t), fail);

200 FF_ALLOCZ_ARRAY_OR_GOTO(h->avctx, h->mvd_table[1],

201 row_mb_num, 16 * sizeof(uint8_t), fail);

202 h->slice_ctx[0].mvd_table[0] = h->mvd_table[0];

203 h->slice_ctx[0].mvd_table[1] = h->mvd_table[1];

204

205 FF_ALLOCZ_OR_GOTO(h->avctx, h->direct_table,

206 4 * big_mb_num * sizeof(uint8_t), fail);

207 FF_ALLOCZ_OR_GOTO(h->avctx, h->list_counts,

208 big_mb_num * sizeof(uint8_t), fail)

209

210 memset(h->slice_table_base, -1,

211 (big_mb_num + h->mb_stride) * sizeof(*h->slice_table_base));

212 h->slice_table = h->slice_table_base + h->mb_stride * 2 + 1;

213

214 FF_ALLOCZ_OR_GOTO(h->avctx, h->mb2b_xy,

215 big_mb_num * sizeof(uint32_t), fail);

216 FF_ALLOCZ_OR_GOTO(h->avctx, h->mb2br_xy,

217 big_mb_num * sizeof(uint32_t), fail);

218 for (y = 0; y < h->mb_height; y++)

219 for (x = 0; x < h->mb_width; x++) {

220 const int mb_xy = x + y * h->mb_stride;

221 const int b_xy = 4 * x + 4 * y * h->b_stride;

222

223 h->mb2b_xy[mb_xy] = b_xy;

224 h->mb2br_xy[mb_xy] = 8 * (FMO ? mb_xy : (mb_xy % (2 * h->mb_stride)));

225 }

226

227 return 0;

228

229 fail:

230 ff_h264_free_tables(h);

231 return AVERROR(ENOMEM);

232 }

233

234 /**

235 * Init context

236 * Allocate buffers which are not shared amongst multiple threads.

237 */

238 int ff_h264_slice_context_init(H264Context *h, H264SliceContext *sl)

239 {

240 ERContext *er = &sl->er;

241 int mb_array_size = h->mb_height * h->mb_stride;

242 int y_size = (2 * h->mb_width + 1) * (2 * h->mb_height + 1);

243 int c_size = h->mb_stride * (h->mb_height + 1);

244 int yc_size = y_size + 2 * c_size;

245 int x, y, i;

246

247 sl->ref_cache[0][scan8[5] + 1] =

248 sl->ref_cache[0][scan8[7] + 1] =

249 sl->ref_cache[0][scan8[13] + 1] =

250 sl->ref_cache[1][scan8[5] + 1] =

251 sl->ref_cache[1][scan8[7] + 1] =

252 sl->ref_cache[1][scan8[13] + 1] = PART_NOT_AVAILABLE;

253

254 if (sl != h->slice_ctx) {

255 memset(er, 0, sizeof(*er));

256 } else

257 if (CONFIG_ERROR_RESILIENCE) {

258

259 /* init ER */

260 er->avctx = h->avctx;

261 er->decode_mb = h264_er_decode_mb;

262 er->opaque = h;

263 er->quarter_sample = 1;

264

265 er->mb_num = h->mb_num;

266 er->mb_width = h->mb_width;

267 er->mb_height = h->mb_height;

268 er->mb_stride = h->mb_stride;

269 er->b8_stride = h->mb_width * 2 + 1;

270

271 // error resilience code looks cleaner with this

272 FF_ALLOCZ_OR_GOTO(h->avctx, er->mb_index2xy,

273 (h->mb_num + 1) * sizeof(int), fail);

274

275 for (y = 0; y < h->mb_height; y++)

276 for (x = 0; x < h->mb_width; x++)

277 er->mb_index2xy[x + y * h->mb_width] = x + y * h->mb_stride;

278

279 er->mb_index2xy[h->mb_height * h->mb_width] = (h->mb_height - 1) *

280 h->mb_stride + h->mb_width;

281

282 FF_ALLOCZ_OR_GOTO(h->avctx, er->error_status_table,

283 mb_array_size * sizeof(uint8_t), fail);

284

285 FF_ALLOC_OR_GOTO(h->avctx, er->er_temp_buffer,

286 h->mb_height * h->mb_stride * (4*sizeof(int) + 1), fail);

287

288 FF_ALLOCZ_OR_GOTO(h->avctx, sl->dc_val_base,

289 yc_size * sizeof(int16_t), fail);

290 er->dc_val[0] = sl->dc_val_base + h->mb_width * 2 + 2;

291 er->dc_val[1] = sl->dc_val_base + y_size + h->mb_stride + 1;

292 er->dc_val[2] = er->dc_val[1] + c_size;

293 for (i = 0; i < yc_size; i++)

294 sl->dc_val_base[i] = 1024;

295 }

296

297 return 0;

298

299 fail:

300 return AVERROR(ENOMEM); // ff_h264_free_tables will clean up for us

301 }

302

303 static int h264_init_context(AVCodecContext *avctx, H264Context *h)

304 {

305 int i;

306

307 h->avctx = avctx;

308 h->cur_chroma_format_idc = -1;

309

310 h->width_from_caller = avctx->width;

311 h->height_from_caller = avctx->height;

312

313 h->picture_structure = PICT_FRAME;

314 h->workaround_bugs = avctx->workaround_bugs;

315 h->flags = avctx->flags;

316 h->poc.prev_poc_msb = 1 << 16;

317 h->recovery_frame = -1;

318 h->frame_recovered = 0;

319 h->poc.prev_frame_num = -1;

320 h->sei.frame_packing.arrangement_cancel_flag = -1;

321 h->sei.unregistered.x264_build = -1;

322

323 h->next_outputed_poc = INT_MIN;

324 for (i = 0; i < MAX_DELAYED_PIC_COUNT; i++)

325 h->last_pocs[i] = INT_MIN;

326

327 ff_h264_sei_uninit(&h->sei);

328

329 avctx->chroma_sample_location = AVCHROMA_LOC_LEFT;

330

331 h->nb_slice_ctx = (avctx->active_thread_type & FF_THREAD_SLICE) ? avctx->thread_count : 1;

332 h->slice_ctx = av_mallocz_array(h->nb_slice_ctx, sizeof(*h->slice_ctx));

333 if (!h->slice_ctx) {

334 h->nb_slice_ctx = 0;

335 return AVERROR(ENOMEM);

336 }

337

338 for (i = 0; i < H264_MAX_PICTURE_COUNT; i++) {

339 h->DPB[i].f = av_frame_alloc();

340 if (!h->DPB[i].f)

341 return AVERROR(ENOMEM);

342 }

343

344 h->cur_pic.f = av_frame_alloc();

345 if (!h->cur_pic.f)

346 return AVERROR(ENOMEM);

347

348 h->last_pic_for_ec.f = av_frame_alloc();

349 if (!h->last_pic_for_ec.f)

350 return AVERROR(ENOMEM);

351

352 for (i = 0; i < h->nb_slice_ctx; i++)

353 h->slice_ctx[i].h264 = h;

354

355 return 0;

356 }

357

358 static av_cold int h264_decode_end(AVCodecContext *avctx)

359 {

360 H264Context *h = avctx->priv_data;

361 int i;

362

363 ff_h264_remove_all_refs(h);

364 ff_h264_free_tables(h);

365

366 for (i = 0; i < H264_MAX_PICTURE_COUNT; i++) {

367 ff_h264_unref_picture(h, &h->DPB[i]);

368 av_frame_free(&h->DPB[i].f);

369 }

370 memset(h->delayed_pic, 0, sizeof(h->delayed_pic));

371

372 h->cur_pic_ptr = NULL;

373

374 av_freep(&h->slice_ctx);

375 h->nb_slice_ctx = 0;

376

377 ff_h264_sei_uninit(&h->sei);

378 ff_h264_ps_uninit(&h->ps);

379

380 ff_h2645_packet_uninit(&h->pkt);

381

382 ff_h264_unref_picture(h, &h->cur_pic);

383 av_frame_free(&h->cur_pic.f);

384 ff_h264_unref_picture(h, &h->last_pic_for_ec);

385 av_frame_free(&h->last_pic_for_ec.f);

386

387 return 0;

388 }

389

390 static AVOnce h264_vlc_init = AV_ONCE_INIT;

391

392 static av_cold int h264_decode_init(AVCodecContext *avctx)

393 {

394 H264Context *h = avctx->priv_data;

395 int ret;

396

397 ret = h264_init_context(avctx, h);

398 if (ret < 0)

399 return ret;

400

401 ret = ff_thread_once(&h264_vlc_init, ff_h264_decode_init_vlc);

402 if (ret != 0) {

403 av_log(avctx, AV_LOG_ERROR, "pthread_once has failed.");

404 return AVERROR_UNKNOWN;

405 }

406

407 if (avctx->ticks_per_frame == 1) {

408 if(h->avctx->time_base.den < INT_MAX/2) {

409 h->avctx->time_base.den *= 2;

410 } else

411 h->avctx->time_base.num /= 2;

412 }

413 avctx->ticks_per_frame = 2;

414

415 if (avctx->extradata_size > 0 && avctx->extradata) {

416 ret = ff_h264_decode_extradata(avctx->extradata, avctx->extradata_size,

417 &h->ps, &h->is_avc, &h->nal_length_size,

418 avctx->err_recognition, avctx);

419 if (ret < 0) {

420 h264_decode_end(avctx);

421 return ret;

422 }

423 }

424

425 if (h->ps.sps && h->ps.sps->bitstream_restriction_flag &&

426 h->avctx->has_b_frames < h->ps.sps->num_reorder_frames) {

427 h->avctx->has_b_frames = h->ps.sps->num_reorder_frames;

428 }

429

430 avctx->internal->allocate_progress = 1;

431

432 ff_h264_flush_change(h);

433

434 if (h->enable_er < 0 && (avctx->active_thread_type & FF_THREAD_SLICE))

435 h->enable_er = 0;

436

437 if (h->enable_er && (avctx->active_thread_type & FF_THREAD_SLICE)) {

438 av_log(avctx, AV_LOG_WARNING,

439 "Error resilience with slice threads is enabled. It is unsafe and unsupported and may crash. "

440 "Use it at your own risk\n");

441 }

442

443 return 0;

444 }

445

446 #if HAVE_THREADS

447 static int decode_init_thread_copy(AVCodecContext *avctx)

448 {

449 H264Context *h = avctx->priv_data;

450 int ret;

451

452 if (!avctx->internal->is_copy)

453 return 0;

454

455 memset(h, 0, sizeof(*h));

456

457 ret = h264_init_context(avctx, h);

458 if (ret < 0)

459 return ret;

460

461 h->context_initialized = 0;

462

463 return 0;

464 }

465 #endif

466

467 /**

468 * instantaneous decoder refresh.

469 */

470 static void idr(H264Context *h)

471 {

472 int i;

473 ff_h264_remove_all_refs(h);

474 h->poc.prev_frame_num =

475 h->poc.prev_frame_num_offset = 0;

476 h->poc.prev_poc_msb = 1<<16;

477 h->poc.prev_poc_lsb = 0;

478 for (i = 0; i < MAX_DELAYED_PIC_COUNT; i++)

479 h->last_pocs[i] = INT_MIN;

480 }

481

482 /* forget old pics after a seek */

483 void ff_h264_flush_change(H264Context *h)

484 {

485 int i, j;

486

487 h->next_outputed_poc = INT_MIN;

488 h->prev_interlaced_frame = 1;

489 idr(h);

490

491 h->poc.prev_frame_num = -1;

492 if (h->cur_pic_ptr) {

493 h->cur_pic_ptr->reference = 0;

494 for (j=i=0; h->delayed_pic[i]; i++)

495 if (h->delayed_pic[i] != h->cur_pic_ptr)

496 h->delayed_pic[j++] = h->delayed_pic[i];

497 h->delayed_pic[j] = NULL;

498 }

499 ff_h264_unref_picture(h, &h->last_pic_for_ec);

500

501 h->first_field = 0;

502 h->recovery_frame = -1;

503 h->frame_recovered = 0;

504 h->current_slice = 0;

505 h->mmco_reset = 1;

506 }

507

508 /* forget old pics after a seek */

509 static void flush_dpb(AVCodecContext *avctx)

510 {

511 H264Context *h = avctx->priv_data;

512 int i;

513

514 memset(h->delayed_pic, 0, sizeof(h->delayed_pic));

515

516 ff_h264_flush_change(h);

517 ff_h264_sei_uninit(&h->sei);

518

519 for (i = 0; i < H264_MAX_PICTURE_COUNT; i++)

520 ff_h264_unref_picture(h, &h->DPB[i]);

521 h->cur_pic_ptr = NULL;

522 ff_h264_unref_picture(h, &h->cur_pic);

523

524 h->mb_y = 0;

525

526 ff_h264_free_tables(h);

527 h->context_initialized = 0;

528 }

529

530 static int get_last_needed_nal(H264Context *h)

531 {

532 int nals_needed = 0;

533 int first_slice = 0;

534 int i, ret;

535

536 for (i = 0; i < h->pkt.nb_nals; i++) {

537 H2645NAL *nal = &h->pkt.nals[i];

538 GetBitContext gb;

539

540 /* packets can sometimes contain multiple PPS/SPS,

541 * e.g. two PAFF field pictures in one packet, or a demuxer

542 * which splits NALs strangely if so, when frame threading we

543 * can't start the next thread until we've read all of them */

544 switch (nal->type) {

545 case H264_NAL_SPS:

546 case H264_NAL_PPS:

547 nals_needed = i;

548 break;

549 case H264_NAL_DPA:

550 case H264_NAL_IDR_SLICE:

551 case H264_NAL_SLICE:

552 ret = init_get_bits8(&gb, nal->data + 1, nal->size - 1);

553 if (ret < 0) {

554 av_log(h->avctx, AV_LOG_ERROR, "Invalid zero-sized VCL NAL unit\n");

555 if (h->avctx->err_recognition & AV_EF_EXPLODE)

556 return ret;

557

558 break;

559 }

560 if (!get_ue_golomb_long(&gb) || // first_mb_in_slice

561 !first_slice ||

562 first_slice != nal->type)

563 nals_needed = i;

564 if (!first_slice)

565 first_slice = nal->type;

566 }

567 }

568

569 return nals_needed;

570 }

571

572 static void debug_green_metadata(const H264SEIGreenMetaData *gm, void *logctx)

573 {

574 av_log(logctx, AV_LOG_DEBUG, "Green Metadata Info SEI message\n");

575 av_log(logctx, AV_LOG_DEBUG, " green_metadata_type: %d\n", gm->green_metadata_type);

576

577 if (gm->green_metadata_type == 0) {

578 av_log(logctx, AV_LOG_DEBUG, " green_metadata_period_type: %d\n", gm->period_type);

579

580 if (gm->period_type == 2)

581 av_log(logctx, AV_LOG_DEBUG, " green_metadata_num_seconds: %d\n", gm->num_seconds);

582 else if (gm->period_type == 3)

583 av_log(logctx, AV_LOG_DEBUG, " green_metadata_num_pictures: %d\n", gm->num_pictures);

584

585 av_log(logctx, AV_LOG_DEBUG, " SEI GREEN Complexity Metrics: %f %f %f %f\n",

586 (float)gm->percent_non_zero_macroblocks/255,

587 (float)gm->percent_intra_coded_macroblocks/255,

588 (float)gm->percent_six_tap_filtering/255,

589 (float)gm->percent_alpha_point_deblocking_instance/255);

590

591 } else if (gm->green_metadata_type == 1) {

592 av_log(logctx, AV_LOG_DEBUG, " xsd_metric_type: %d\n", gm->xsd_metric_type);

593

594 if (gm->xsd_metric_type == 0)

595 av_log(logctx, AV_LOG_DEBUG, " xsd_metric_value: %f\n",

596 (float)gm->xsd_metric_value/100);

597 }

598 }

599

600 static int decode_nal_units(H264Context *h, const uint8_t *buf, int buf_size)

601 {

602 AVCodecContext *const avctx = h->avctx;

603 int nals_needed = 0; ///< number of NALs that need decoding before the next frame thread starts

604 int idr_cleared=0;

605 int i, ret = 0;

606

607 h->has_slice = 0;

608 h->nal_unit_type= 0;

609

610 if (!(avctx->flags2 & AV_CODEC_FLAG2_CHUNKS)) {

611 h->current_slice = 0;

612 if (!h->first_field)

613 h->cur_pic_ptr = NULL;

614 ff_h264_sei_uninit(&h->sei);

615 }

616

617 if (h->nal_length_size == 4) {

618 if (buf_size > 8 && AV_RB32(buf) == 1 && AV_RB32(buf+5) > (unsigned)buf_size) {

619 h->is_avc = 0;

620 }else if(buf_size > 3 && AV_RB32(buf) > 1 && AV_RB32(buf) <= (unsigned)buf_size)

621 h->is_avc = 1;

622 }

623

624 ret = ff_h2645_packet_split(&h->pkt, buf, buf_size, avctx, h->is_avc,

625 h->nal_length_size, avctx->codec_id, avctx->flags2 & AV_CODEC_FLAG2_FAST);

626 if (ret < 0) {

627 av_log(avctx, AV_LOG_ERROR,

628 "Error splitting the input into NAL units.\n");

629 return ret;

630 }

631

632 if (avctx->active_thread_type & FF_THREAD_FRAME)

633 nals_needed = get_last_needed_nal(h);

634 if (nals_needed < 0)

635 return nals_needed;

636

637 for (i = 0; i < h->pkt.nb_nals; i++) {

638 H2645NAL *nal = &h->pkt.nals[i];

639 int max_slice_ctx, err;

640

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

642 nal->ref_idc == 0 && nal->type != H264_NAL_SEI)

643 continue;

644

645 // FIXME these should stop being context-global variables

646 h->nal_ref_idc = nal->ref_idc;

647 h->nal_unit_type = nal->type;

648

649 err = 0;

650 switch (nal->type) {

651 case H264_NAL_IDR_SLICE:

652 if ((nal->data[1] & 0xFC) == 0x98) {

653 av_log(h->avctx, AV_LOG_ERROR, "Invalid inter IDR frame\n");

654 h->next_outputed_poc = INT_MIN;

655 ret = -1;

656 goto end;

657 }

658 if(!idr_cleared) {

659 if (h->current_slice && (avctx->active_thread_type & FF_THREAD_SLICE)) {

660 av_log(h, AV_LOG_ERROR, "invalid mixed IDR / non IDR frames cannot be decoded in slice multithreading mode\n");

661 ret = AVERROR_INVALIDDATA;

662 goto end;

663 }

664 idr(h); // FIXME ensure we don't lose some frames if there is reordering

665 }

666 idr_cleared = 1;

667 h->has_recovery_point = 1;

668 case H264_NAL_SLICE:

669 h->has_slice = 1;

670

671 if ((err = ff_h264_queue_decode_slice(h, nal))) {

672 H264SliceContext *sl = h->slice_ctx + h->nb_slice_ctx_queued;

673 sl->ref_count[0] = sl->ref_count[1] = 0;

674 break;

675 }

676

677 if (h->current_slice == 1) {

678 if (avctx->active_thread_type & FF_THREAD_FRAME &&

679 i >= nals_needed && !h->setup_finished && h->cur_pic_ptr) {

680 ff_thread_finish_setup(avctx);

681 h->setup_finished = 1;

682 }

683

684 if (h->avctx->hwaccel &&

685 (ret = h->avctx->hwaccel->start_frame(h->avctx, buf, buf_size)) < 0)

686 goto end;

687 }

688

689 max_slice_ctx = avctx->hwaccel ? 1 : h->nb_slice_ctx;

690 if (h->nb_slice_ctx_queued == max_slice_ctx) {

691 if (h->avctx->hwaccel) {

692 ret = avctx->hwaccel->decode_slice(avctx, nal->raw_data, nal->raw_size);

693 h->nb_slice_ctx_queued = 0;

694 } else

695 ret = ff_h264_execute_decode_slices(h);

696 if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))

697 goto end;

698 }

699 break;

700 case H264_NAL_DPA:

701 case H264_NAL_DPB:

702 case H264_NAL_DPC:

703 avpriv_request_sample(avctx, "data partitioning");

704 break;

705 case H264_NAL_SEI:

706 ret = ff_h264_sei_decode(&h->sei, &nal->gb, &h->ps, avctx);

707 h->has_recovery_point = h->has_recovery_point || h->sei.recovery_point.recovery_frame_cnt != -1;

708 if (avctx->debug & FF_DEBUG_GREEN_MD)

709 debug_green_metadata(&h->sei.green_metadata, h->avctx);

710 if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))

711 goto end;

712 break;

713 case H264_NAL_SPS: {

714 GetBitContext tmp_gb = nal->gb;

715 if (avctx->hwaccel && avctx->hwaccel->decode_params) {

716 ret = avctx->hwaccel->decode_params(avctx,

717 nal->type,

718 nal->raw_data,

719 nal->raw_size);

720 if (ret < 0)

721 goto end;

722 }

723 if (ff_h264_decode_seq_parameter_set(&tmp_gb, avctx, &h->ps, 0) >= 0)

724 break;

725 av_log(h->avctx, AV_LOG_DEBUG,

726 "SPS decoding failure, trying again with the complete NAL\n");

727 init_get_bits8(&tmp_gb, nal->raw_data + 1, nal->raw_size - 1);

728 if (ff_h264_decode_seq_parameter_set(&tmp_gb, avctx, &h->ps, 0) >= 0)

729 break;

730 ff_h264_decode_seq_parameter_set(&nal->gb, avctx, &h->ps, 1);

731 break;

732 }

733 case H264_NAL_PPS:

734 if (avctx->hwaccel && avctx->hwaccel->decode_params) {

735 ret = avctx->hwaccel->decode_params(avctx,

736 nal->type,

737 nal->raw_data,

738 nal->raw_size);

739 if (ret < 0)

740 goto end;

741 }

742 ret = ff_h264_decode_picture_parameter_set(&nal->gb, avctx, &h->ps,

743 nal->size_bits);

744 if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))

745 goto end;

746 break;

747 case H264_NAL_AUD:

748 case H264_NAL_END_SEQUENCE:

749 case H264_NAL_END_STREAM:

750 case H264_NAL_FILLER_DATA:

751 case H264_NAL_SPS_EXT:

752 case H264_NAL_AUXILIARY_SLICE:

753 break;

754 default:

755 av_log(avctx, AV_LOG_DEBUG, "Unknown NAL code: %d (%d bits)\n",

756 nal->type, nal->size_bits);

757 }

758

759 if (err < 0) {

760 av_log(h->avctx, AV_LOG_ERROR, "decode_slice_header error\n");

761 }

762 }

763

764 ret = ff_h264_execute_decode_slices(h);

765 if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))

766 goto end;

767

768 ret = 0;

769 end:

770

771 #if CONFIG_ERROR_RESILIENCE

772 /*

773 * FIXME: Error handling code does not seem to support interlaced

774 * when slices span multiple rows

775 * The ff_er_add_slice calls don't work right for bottom

776 * fields; they cause massive erroneous error concealing

777 * Error marking covers both fields (top and bottom).

778 * This causes a mismatched s->error_count

779 * and a bad error table. Further, the error count goes to

780 * INT_MAX when called for bottom field, because mb_y is

781 * past end by one (callers fault) and resync_mb_y != 0

782 * causes problems for the first MB line, too.

783 */

784 if (!FIELD_PICTURE(h) && h->current_slice &&

785 h->ps.sps == (const SPS*)h->ps.sps_list[h->ps.pps->sps_id]->data &&

786 h->enable_er) {

787

788 H264SliceContext *sl = h->slice_ctx;

789 int use_last_pic = h->last_pic_for_ec.f->buf[0] && !sl->ref_count[0];

790

791 ff_h264_set_erpic(&sl->er.cur_pic, h->cur_pic_ptr);

792

793 if (use_last_pic) {

794 ff_h264_set_erpic(&sl->er.last_pic, &h->last_pic_for_ec);

795 sl->ref_list[0][0].parent = &h->last_pic_for_ec;

796 memcpy(sl->ref_list[0][0].data, h->last_pic_for_ec.f->data, sizeof(sl->ref_list[0][0].data));

797 memcpy(sl->ref_list[0][0].linesize, h->last_pic_for_ec.f->linesize, sizeof(sl->ref_list[0][0].linesize));

798 sl->ref_list[0][0].reference = h->last_pic_for_ec.reference;

799 } else if (sl->ref_count[0]) {

800 ff_h264_set_erpic(&sl->er.last_pic, sl->ref_list[0][0].parent);

801 } else

802 ff_h264_set_erpic(&sl->er.last_pic, NULL);

803

804 if (sl->ref_count[1])

805 ff_h264_set_erpic(&sl->er.next_pic, sl->ref_list[1][0].parent);

806

807 sl->er.ref_count = sl->ref_count[0];

808

809 ff_er_frame_end(&sl->er);

810 if (use_last_pic)

811 memset(&sl->ref_list[0][0], 0, sizeof(sl->ref_list[0][0]));

812 }

813 #endif /* CONFIG_ERROR_RESILIENCE */

814 /* clean up */

815 if (h->cur_pic_ptr && !h->droppable && h->has_slice) {

816 ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX,

817 h->picture_structure == PICT_BOTTOM_FIELD);

818 }

819

820 return (ret < 0) ? ret : buf_size;

821 }

822

823 /**

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

825 */

826 static int get_consumed_bytes(int pos, int buf_size)

827 {

828 if (pos == 0)

829 pos = 1; // avoid infinite loops (I doubt that is needed but...)

830 if (pos + 10 > buf_size)

831 pos = buf_size; // oops ;)

832

833 return pos;

834 }

835

836 static int output_frame(H264Context *h, AVFrame *dst, H264Picture *srcp)

837 {

838 AVFrame *src = srcp->f;

839 int ret;

840

841 ret = av_frame_ref(dst, src);

842 if (ret < 0)

843 return ret;

844

845 av_dict_set(&dst->metadata, "stereo_mode", ff_h264_sei_stereo_mode(&h->sei.frame_packing), 0);

846

847 if (srcp->sei_recovery_frame_cnt == 0)

848 dst->key_frame = 1;

849

850 return 0;

851 }

852

853 static int is_extra(const uint8_t *buf, int buf_size)

854 {

855 int cnt= buf[5]&0x1f;

856 const uint8_t *p= buf+6;

857 while(cnt--){

858 int nalsize= AV_RB16(p) + 2;

859 if(nalsize > buf_size - (p-buf) || (p[2] & 0x9F) != 7)

860 return 0;

861 p += nalsize;

862 }

863 cnt = *(p++);

864 if(!cnt)

865 return 0;

866 while(cnt--){

867 int nalsize= AV_RB16(p) + 2;

868 if(nalsize > buf_size - (p-buf) || (p[2] & 0x9F) != 8)

869 return 0;

870 p += nalsize;

871 }

872 return 1;

873 }

874

875 static int finalize_frame(H264Context *h, AVFrame *dst, H264Picture *out, int *got_frame)

876 {

877 int ret;

878

879 if (((h->avctx->flags & AV_CODEC_FLAG_OUTPUT_CORRUPT) ||

880 (h->avctx->flags2 & AV_CODEC_FLAG2_SHOW_ALL) ||

881 out->recovered)) {

882

883 if (!h->avctx->hwaccel &&

884 (out->field_poc[0] == INT_MAX ||

885 out->field_poc[1] == INT_MAX)

886 ) {

887 int p;

888 AVFrame *f = out->f;

889 int field = out->field_poc[0] == INT_MAX;

890 uint8_t *dst_data[4];

891 int linesizes[4];

892 const uint8_t *src_data[4];

893

894 av_log(h->avctx, AV_LOG_DEBUG, "Duplicating field %d to fill missing\n", field);

895

896 for (p = 0; p<4; p++) {

897 dst_data[p] = f->data[p] + (field^1)*f->linesize[p];

898 src_data[p] = f->data[p] + field *f->linesize[p];

899 linesizes[p] = 2*f->linesize[p];

900 }

901

902 av_image_copy(dst_data, linesizes, src_data, linesizes,

903 f->format, f->width, f->height>>1);

904 }

905

906 ret = output_frame(h, dst, out);

907 if (ret < 0)

908 return ret;

909

910 *got_frame = 1;

911

912 if (CONFIG_MPEGVIDEO) {

913 ff_print_debug_info2(h->avctx, dst, NULL,

914 out->mb_type,

915 out->qscale_table,

916 out->motion_val,

917 NULL,

918 h->mb_width, h->mb_height, h->mb_stride, 1);

919 }

920 }

921

922 return 0;

923 }

924

925 static int send_next_delayed_frame(H264Context *h, AVFrame *dst_frame,

926 int *got_frame, int buf_index)

927 {

928 int ret, i, out_idx;

929 H264Picture *out = h->delayed_pic[0];

930

931 h->cur_pic_ptr = NULL;

932 h->first_field = 0;

933

934 out_idx = 0;

935 for (i = 1;

936 h->delayed_pic[i] &&

937 !h->delayed_pic[i]->f->key_frame &&

938 !h->delayed_pic[i]->mmco_reset;

939 i++)

940 if (h->delayed_pic[i]->poc < out->poc) {

941 out = h->delayed_pic[i];

942 out_idx = i;

943 }

944

945 for (i = out_idx; h->delayed_pic[i]; i++)

946 h->delayed_pic[i] = h->delayed_pic[i + 1];

947

948 if (out) {

949 out->reference &= ~DELAYED_PIC_REF;

950 ret = finalize_frame(h, dst_frame, out, got_frame);

951 if (ret < 0)

952 return ret;

953 }

954

955 return buf_index;

956 }

957

958 static int h264_decode_frame(AVCodecContext *avctx, void *data,

959 int *got_frame, AVPacket *avpkt)

960 {

961 const uint8_t *buf = avpkt->data;

962 int buf_size = avpkt->size;

963 H264Context *h = avctx->priv_data;

964 AVFrame *pict = data;

965 int buf_index;

966 int ret;

967

968 h->flags = avctx->flags;

969 h->setup_finished = 0;

970 h->nb_slice_ctx_queued = 0;

971

972 ff_h264_unref_picture(h, &h->last_pic_for_ec);

973

974 /* end of stream, output what is still in the buffers */

975 if (buf_size == 0)

976 return send_next_delayed_frame(h, pict, got_frame, 0);

977

978 if (h->is_avc && av_packet_get_side_data(avpkt, AV_PKT_DATA_NEW_EXTRADATA, NULL)) {

979 int side_size;

980 uint8_t *side = av_packet_get_side_data(avpkt, AV_PKT_DATA_NEW_EXTRADATA, &side_size);

981 if (is_extra(side, side_size))

982 ff_h264_decode_extradata(side, side_size,

983 &h->ps, &h->is_avc, &h->nal_length_size,

984 avctx->err_recognition, avctx);

985 }

986 if(h->is_avc && buf_size >= 9 && buf[0]==1 && buf[2]==0 && (buf[4]&0xFC)==0xFC && (buf[5]&0x1F) && buf[8]==0x67){

987 if (is_extra(buf, buf_size))

988 return ff_h264_decode_extradata(buf, buf_size,

989 &h->ps, &h->is_avc, &h->nal_length_size,

990 avctx->err_recognition, avctx);

991 }

992

993 buf_index = decode_nal_units(h, buf, buf_size);

994 if (buf_index < 0)

995 return AVERROR_INVALIDDATA;

996

997 if (!h->cur_pic_ptr && h->nal_unit_type == H264_NAL_END_SEQUENCE) {

998 av_assert0(buf_index <= buf_size);

999 return send_next_delayed_frame(h, pict, got_frame, buf_index);

1000 }

1001

1002 if (!(avctx->flags2 & AV_CODEC_FLAG2_CHUNKS) && (!h->cur_pic_ptr || !h->has_slice)) {

1003 if (avctx->skip_frame >= AVDISCARD_NONREF ||

1004 buf_size >= 4 && !memcmp("Q264", buf, 4))

1005 return buf_size;

1006 av_log(avctx, AV_LOG_ERROR, "no frame!\n");

1007 return AVERROR_INVALIDDATA;

1008 }

1009

1010 if (!(avctx->flags2 & AV_CODEC_FLAG2_CHUNKS) ||

1011 (h->mb_y >= h->mb_height && h->mb_height)) {

1012 if ((ret = ff_h264_field_end(h, &h->slice_ctx[0], 0)) < 0)

1013 return ret;

1014

1015 /* Wait for second field. */

1016 if (h->next_output_pic) {

1017 ret = finalize_frame(h, pict, h->next_output_pic, got_frame);

1018 if (ret < 0)

1019 return ret;

1020 }

1021 }

1022

1023 av_assert0(pict->buf[0] || !*got_frame);

1024

1025 ff_h264_unref_picture(h, &h->last_pic_for_ec);

1026

1027 return get_consumed_bytes(buf_index, buf_size);

1028 }

1029

1030 #define OFFSET(x) offsetof(H264Context, x)

1031 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM

1032 static const AVOption h264_options[] = {

1033 { "is_avc", "is avc", OFFSET(is_avc), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, 0 },

1034 { "nal_length_size", "nal_length_size", OFFSET(nal_length_size), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 4, 0 },

1035 { "enable_er", "Enable error resilience on damaged frames (unsafe)", OFFSET(enable_er), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VD },

1036 { "x264_build", "Assume this x264 version if no x264 version found in any SEI", OFFSET(x264_build), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VD },

1037 { NULL },

1038 };

1039

1040 static const AVClass h264_class = {

1041 .class_name = "H264 Decoder",

1042 .item_name = av_default_item_name,

1043 .option = h264_options,

1044 .version = LIBAVUTIL_VERSION_INT,

1045 };

1046

1047 AVCodec ff_h264_decoder = {

1048 .name = "h264",

1049 .long_name = NULL_IF_CONFIG_SMALL("H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10"),

1050 .type = AVMEDIA_TYPE_VIDEO,

1051 .id = AV_CODEC_ID_H264,

1052 .priv_data_size = sizeof(H264Context),

1053 .init = h264_decode_init,

1054 .close = h264_decode_end,

1055 .decode = h264_decode_frame,

1056 .capabilities = /*AV_CODEC_CAP_DRAW_HORIZ_BAND |*/ AV_CODEC_CAP_DR1 |

1057 AV_CODEC_CAP_DELAY | AV_CODEC_CAP_SLICE_THREADS |

1058 AV_CODEC_CAP_FRAME_THREADS,

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

1060 #if CONFIG_H264_DXVA2_HWACCEL

1061 HWACCEL_DXVA2(h264),

1062 #endif

1063 #if CONFIG_H264_D3D11VA_HWACCEL

1064 HWACCEL_D3D11VA(h264),

1065 #endif

1066 #if CONFIG_H264_D3D11VA2_HWACCEL

1067 HWACCEL_D3D11VA2(h264),

1068 #endif

1069 #if CONFIG_H264_NVDEC_HWACCEL

1070 HWACCEL_NVDEC(h264),

1071 #endif

1072 #if CONFIG_H264_VAAPI_HWACCEL

1073 HWACCEL_VAAPI(h264),

1074 #endif

1075 #if CONFIG_H264_VDPAU_HWACCEL

1076 HWACCEL_VDPAU(h264),

1077 #endif

1078 #if CONFIG_H264_VIDEOTOOLBOX_HWACCEL

1079 HWACCEL_VIDEOTOOLBOX(h264),

1080 #endif

1081 NULL

1082 },

1083 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_EXPORTS_CROPPING,

1084 .flush = flush_dpb,

1085 .init_thread_copy = ONLY_IF_THREADS_ENABLED(decode_init_thread_copy),

1086 .update_thread_context = ONLY_IF_THREADS_ENABLED(ff_h264_update_thread_context),

1087 .profiles = NULL_IF_CONFIG_SMALL(ff_h264_profiles),

1088 .priv_class = &h264_class,

1089 };

ff_h264_decode_picture_parameter_set

int ff_h264_decode_picture_parameter_set(GetBitContext *gb, AVCodecContext *avctx, H264ParamSets *ps, int bit_length)

Decode PPS.

Definition: h264_ps.c:725

H264SliceContext::h264

struct H264Context * h264

Definition: h264dec.h:178

ff_h2645_packet_split

int ff_h2645_packet_split(H2645Packet *pkt, const uint8_t *buf, int length, void *logctx, int is_nalff, int nal_length_size, enum AVCodecID codec_id, int small_padding)

Split an input packet into NAL units.

Definition: h2645_parse.c:263

NULL

#define NULL

Definition: coverity.c:32

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

H264Context::workaround_bugs

int workaround_bugs

Definition: h264dec.h:367

hwaccel.h

AVERROR_INVALIDDATA

#define AVERROR_INVALIDDATA

Invalid data found when processing input.

Definition: error.h:59

H264Picture::sei_recovery_frame_cnt

int sei_recovery_frame_cnt

Definition: h264dec.h:163

AV_NUM_DATA_POINTERS

#define AV_NUM_DATA_POINTERS

Definition: frame.h:219

SLICE_FLAG_ALLOW_FIELD

#define SLICE_FLAG_ALLOW_FIELD

allow draw_horiz_band() with field slices (MPEG-2 field pics)

Definition: avcodec.h:1997

ff_h264_queue_decode_slice

int ff_h264_queue_decode_slice(H264Context *h, const H2645NAL *nal)

Submit a slice for decoding.

Definition: h264_slice.c:2022

H264Context::poc

H264POCContext poc

Definition: h264dec.h:460

send_next_delayed_frame

static int send_next_delayed_frame(H264Context *h, AVFrame *dst_frame, int *got_frame, int buf_index)

Definition: h264dec.c:925

H264Context::mb_num

int mb_num

Definition: h264dec.h:437

av_pix_fmt_desc_get

const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)

Definition: pixdesc.c:2363

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

FF_ALLOCZ_ARRAY_OR_GOTO

#define FF_ALLOCZ_ARRAY_OR_GOTO(ctx, p, nelem, elsize, label)

Definition: internal.h:167

H264_NAL_FILLER_DATA

Definition: h264.h:42

H264SEIRecoveryPoint::recovery_frame_cnt

int recovery_frame_cnt

recovery_frame_cnt

Definition: h264_sei.h:112

Definition: vp9dsp_template.c:2038

HWACCEL_D3D11VA2

#define HWACCEL_D3D11VA2(codec)

Definition: hwaccel.h:69

H264SliceContext::mv_cache

int16_t mv_cache[2][5 *8][2]

Motion vector cache.

Definition: h264dec.h:299

AVOption

AVOption.

Definition: opt.h:246

data

ptrdiff_t const GLvoid * data

Definition: opengl_enc.c:101

H2645NAL::size

int size

Definition: h2645_parse.h:34

HWACCEL_NVDEC

#define HWACCEL_NVDEC(codec)

Definition: hwaccel.h:71

H264SliceContext::edge_emu_buffer_allocated

int edge_emu_buffer_allocated

Definition: h264dec.h:287

H264SEIGreenMetaData::num_pictures

uint16_t num_pictures

Definition: h264_sei.h:141

debug_green_metadata

static void debug_green_metadata(const H264SEIGreenMetaData *gm, void *logctx)

Definition: h264dec.c:572

H264_NAL_END_STREAM

Definition: h264.h:41

H264Context::first_field

int first_field

Definition: h264dec.h:408

imgutils.h

misc image utilities

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:182

LIBAVUTIL_VERSION_INT

#define LIBAVUTIL_VERSION_INT

Definition: version.h:85

ERContext

Definition: error_resilience.h:53

H264ParamSets::sps_list

AVBufferRef * sps_list[MAX_SPS_COUNT]

Definition: h264_ps.h:138

AVFrame::buf

AVBufferRef * buf[AV_NUM_DATA_POINTERS]

AVBuffer references backing the data for this frame.

Definition: frame.h:410

desc

const char * desc

Definition: nvenc.c:65

init

static av_cold int init(AVCodecContext *avctx)

Definition: avrndec.c:35

AV_OPT_TYPE_INT

Definition: opt.h:223

H264Context::cbp_table

uint16_t * cbp_table

Definition: h264dec.h:413

H264SliceContext::mb_xy

int mb_xy

Definition: h264dec.h:231

H264SliceContext

Definition: h264dec.h:177

ff_er_frame_end

void ff_er_frame_end(ERContext *s)

Definition: error_resilience.c:901

SPS

Sequence parameter set.

Definition: h264_ps.h:43

H264Context::mb_y

int mb_y

Definition: h264dec.h:434

SPS::bitstream_restriction_flag

int bitstream_restriction_flag

Definition: h264_ps.h:84

AVRational::num

int num

Numerator.

Definition: rational.h:59

ERContext::mb_height

int mb_height

Definition: error_resilience.h:60

H264SliceContext::bipred_scratchpad_allocated

int bipred_scratchpad_allocated

Definition: h264dec.h:286

AVPacket::size

int size

Definition: avcodec.h:1431

DELAYED_PIC_REF

#define DELAYED_PIC_REF

Value of Picture.reference when Picture is not a reference picture, but is held for delayed output...

Definition: diracdec.c:67

av_default_item_name

const char * av_default_item_name(void *ptr)

Return the context name.

Definition: log.c:191

H264Context::mb_type_pool

AVBufferPool * mb_type_pool

Definition: h264dec.h:550

idr

static void idr(H264Context *h)

instantaneous decoder refresh.

Definition: h264dec.c:470

H264Picture::motion_val

int16_t(*[2] motion_val)[2]

Definition: h264dec.h:136

H264_NAL_AUXILIARY_SLICE

Definition: h264.h:44

H264Context::flags

int flags

Definition: h264dec.h:366

ff_h264_flush_change

void ff_h264_flush_change(H264Context *h)

Definition: h264dec.c:483

AVCodecContext::pix_fmt

enum AVPixelFormat pix_fmt

Pixel format, see AV_PIX_FMT_xxx.

Definition: avcodec.h:1727

H264Context::mb_height

int mb_height

Definition: h264dec.h:435

H264Context::delayed_pic

H264Picture * delayed_pic[MAX_DELAYED_PIC_COUNT+2]

Definition: h264dec.h:465

H264Context::is_avc

int is_avc

Used to parse AVC variant of H.264.

Definition: h264dec.h:450

h264chroma.h

H264Context::ref_index_pool

AVBufferPool * ref_index_pool

Definition: h264dec.h:552

H264Context::height_from_caller

int height_from_caller

Definition: h264dec.h:543

ff_h264_sei_uninit

void ff_h264_sei_uninit(H264SEIContext *h)

Reset SEI values at the beginning of the frame.

Definition: h264_sei.c:41

ERContext::last_pic

ERPicture last_pic

Definition: error_resilience.h:74

H264Context

H264Context.

Definition: h264dec.h:337

H264Picture::f

AVFrame * f

Definition: h264dec.h:129

AV_CODEC_FLAG2_CHUNKS

#define AV_CODEC_FLAG2_CHUNKS

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

Definition: avcodec.h:920

HWACCEL_D3D11VA

#define HWACCEL_D3D11VA(codec)

Definition: hwaccel.h:79

HWACCEL_VIDEOTOOLBOX

Definition: ffmpeg.h:62

H264_NAL_AUD

Definition: h264.h:39

AV_RB16

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_RB16

Definition: bytestream.h:87

AVCodecContext::hwaccel

const struct AVHWAccel * hwaccel

Hardware accelerator in use.

Definition: avcodec.h:2674

src

#define src

Definition: vp8dsp.c:254

AV_CODEC_ID_H264

Definition: avcodec.h:245

AVCodec

AVCodec.

Definition: avcodec.h:3408

H264Context::picture_structure

int picture_structure

Definition: h264dec.h:407

H264SEIGreenMetaData::period_type

uint8_t period_type

Definition: h264_sei.h:139

decode

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

Definition: decode_audio.c:42

ERContext::opaque

void * opaque

Definition: error_resilience.h:89

flush_dpb

static void flush_dpb(AVCodecContext *avctx)

Definition: h264dec.c:509

H264SliceContext::ref_count

unsigned int ref_count[2]

num_ref_idx_l0/1_active_minus1 + 1

Definition: h264dec.h:267

H2645NAL::size_bits

int size_bits

Size, in bits, of just the data, excluding the stop bit and any trailing padding. ...

Definition: h2645_parse.h:41

ERContext::quarter_sample

int quarter_sample

Definition: error_resilience.h:82

H264SEIContext::green_metadata

H264SEIGreenMetaData green_metadata

Definition: h264_sei.h:164

AVCodecContext::time_base

AVRational time_base

This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...

Definition: avcodec.h:1640

ff_h264_update_thread_context

int ff_h264_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)

Definition: h264_slice.c:288

H264Context::chroma_pred_mode_table

uint8_t * chroma_pred_mode_table

Definition: h264dec.h:416

H264Context::setup_finished

int setup_finished

Definition: h264dec.h:534

ff_h264_remove_all_refs

void ff_h264_remove_all_refs(H264Context *h)

Definition: h264_refs.c:563

AVCodecContext::skip_frame

enum AVDiscard skip_frame

Skip decoding for selected frames.

Definition: avcodec.h:2975

ff_h264_execute_decode_slices

int ff_h264_execute_decode_slices(H264Context *h)

Call decode_slice() for each context.

Definition: h264_slice.c:2733

H264Context::sei

H264SEIContext sei

Definition: h264dec.h:547

avpriv_h264_has_num_reorder_frames

int avpriv_h264_has_num_reorder_frames(AVCodecContext *avctx)

Definition: h264dec.c:60

ff_h264_sei_stereo_mode

const char * ff_h264_sei_stereo_mode(const H264SEIFramePacking *h)

Get stereo_mode string from the h264 frame_packing_arrangement.

Definition: h264_sei.c:466

srcp

BYTE int const BYTE * srcp

Definition: avisynth_c.h:813

AVClass::class_name

const char * class_name

The name of the class; usually it is the same name as the context structure type to which the AVClass...

Definition: log.h:72

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

av_assert0

#define av_assert0(cond)

assert() equivalent, that is always enabled.

Definition: avassert.h:37

get_consumed_bytes

static int get_consumed_bytes(int pos, int buf_size)

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

Definition: h264dec.c:826

ERContext::b8_stride

ptrdiff_t b8_stride

Definition: error_resilience.h:62

avpriv_request_sample

void void avpriv_request_sample(void *avc, const char *msg,...) av_printf_format(2

Log a generic warning message about a missing feature.

H264ParamSets::pps

const PPS * pps

Definition: h264_ps.h:144

FF_CODEC_CAP_INIT_THREADSAFE

#define FF_CODEC_CAP_INIT_THREADSAFE

The codec does not modify any global variables in the init function, allowing to call the init functi...

Definition: internal.h:40

uint8_t

Definition: audio_convert.c:194

av_cold

#define av_cold

Definition: attributes.h:82

H264SEIGreenMetaData::green_metadata_type

uint8_t green_metadata_type

Definition: h264_sei.h:138

av_frame_alloc

AVFrame * av_frame_alloc(void)

Allocate an AVFrame and set its fields to default values.

Definition: frame.c:189

opt.h

AVOptions.

ff_h264_set_erpic

void ff_h264_set_erpic(ERPicture *dst, H264Picture *src)

Definition: h264_picture.c:131

ff_h264_hl_decode_mb

void ff_h264_hl_decode_mb(const H264Context *h, H264SliceContext *sl)

Definition: h264_mb.c:799

H264Picture::poc

int poc

frame POC

Definition: h264dec.h:148

end

static av_cold int end(AVCodecContext *avctx)

Definition: avrndec.c:90

thread.h

Multithreading support functions.

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

get_last_needed_nal

static int get_last_needed_nal(H264Context *h)

Definition: h264dec.c:530

AVCodecContext::extradata

uint8_t * extradata

some codecs need / can use extradata like Huffman tables.

Definition: avcodec.h:1618

ERContext::ref_count

int ref_count

Definition: error_resilience.h:84

AV_RB32

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32

Definition: bytestream.h:87

H264SliceContext::top_borders

uint8_t(*[2] top_borders)[(16 *3)*2]

Definition: h264dec.h:285

ff_h2645_packet_uninit

void ff_h2645_packet_uninit(H2645Packet *pkt)

Free all the allocated memory in the packet.

Definition: h2645_parse.c:386

ERContext::cur_pic

ERPicture cur_pic

Definition: error_resilience.h:73

H264Context::frame_recovered

int frame_recovered

Initial frame has been completely recovered.

Definition: h264dec.h:524

ff_h264_decode_extradata

int ff_h264_decode_extradata(const uint8_t *data, int size, H264ParamSets *ps, int *is_avc, int *nal_length_size, int err_recognition, void *logctx)

Definition: h264_parse.c:443

PICT_BOTTOM_FIELD

#define PICT_BOTTOM_FIELD

Definition: mpegutils.h:38

height

#define height

AVPacket::data

uint8_t * data

Definition: avcodec.h:1430

HWACCEL_DXVA2

#define HWACCEL_DXVA2(codec)

Definition: hwaccel.h:67

decode_nal_units

static int decode_nal_units(H264Context *h, const uint8_t *buf, int buf_size)

Definition: h264dec.c:600

H264_NAL_IDR_SLICE

Definition: h264.h:35

AVFrame::metadata

AVDictionary * metadata

metadata.

Definition: frame.h:505

H264Context::has_slice

int has_slice

slice NAL is found in the packet, set by decode_nal_units, its state does not need to be preserved ou...

Definition: h264dec.h:445

mpegutils.h

h264_init_context

static int h264_init_context(AVCodecContext *avctx, H264Context *h)

Definition: h264dec.c:303

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

H264Ref::parent

H264Picture * parent

Definition: h264dec.h:174

timer.h

high precision timer, useful to profile code

H264Picture::recovered

int recovered

picture at IDR or recovery point + recovery count

Definition: h264dec.h:161

AVOnce

#define AVOnce

Definition: thread.h:159

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

H264Context::last_pocs

int last_pocs[MAX_DELAYED_PIC_COUNT]

Definition: h264dec.h:466

H264SEIGreenMetaData::num_seconds

uint16_t num_seconds

Definition: h264_sei.h:140

H264SEIGreenMetaData::percent_six_tap_filtering

uint8_t percent_six_tap_filtering

Definition: h264_sei.h:144

ERContext::mb_width

int mb_width

Definition: error_resilience.h:60

h264.h

H.264 common definitions.

ff_h264_draw_horiz_band

void ff_h264_draw_horiz_band(const H264Context *h, H264SliceContext *sl, int y, int height)

Definition: h264dec.c:102

h264_ps.h

H.264 parameter set handling.

H264Context::DPB

H264Picture DPB[H264_MAX_PICTURE_COUNT]

Definition: h264dec.h:345

AVFrame::width

int width

Definition: frame.h:276

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

AVPixFmtDescriptor::log2_chroma_h

uint8_t log2_chroma_h

Amount to shift the luma height right to find the chroma height.

Definition: pixdesc.h:101

h264_class

static const AVClass h264_class

Definition: h264dec.c:1040

H264SliceContext::mb_x

int mb_x

Definition: h264dec.h:230

H264SliceContext::dc_val_base

int16_t * dc_val_base

Definition: h264dec.h:281

H264Context::context_initialized

int context_initialized

Definition: h264dec.h:365

H264SliceContext::er

ERContext er

Definition: h264dec.h:180

H264Context::nal_unit_type

int nal_unit_type

Definition: h264dec.h:443

SPS::num_reorder_frames

int num_reorder_frames

Definition: h264_ps.h:85

AVCodecInternal::is_copy

int is_copy

Whether the parent AVCodecContext is a copy of the context which had init() called on it...

Definition: internal.h:136

AVERROR

#define AVERROR(e)

Definition: error.h:43

av_packet_get_side_data

uint8_t * av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type, int *size)

Get side information from packet.

Definition: avpacket.c:350

av_frame_free

void av_frame_free(AVFrame **frame)

Free the frame and any dynamically allocated objects in it, e.g.

Definition: frame.c:202

H264_NAL_SPS_EXT

Definition: h264.h:43

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

h264_options

static const AVOption h264_options[]

Definition: h264dec.c:1032

display.h

Display matrix.

AVCodecContext::active_thread_type

int active_thread_type

Which multithreading methods are in use by the codec.

Definition: avcodec.h:2788

H264Context::pkt

H2645Packet pkt

Definition: h264dec.h:354

AVCodecHWConfigInternal

Definition: hwaccel.h:29

AV_LOG_DEBUG

#define AV_LOG_DEBUG

Stuff which is only useful for libav* developers.

Definition: log.h:197

FIELD_PICTURE

#define FIELD_PICTURE(h)

Definition: h264dec.h:74

ERContext::decode_mb

void(* decode_mb)(void *opaque, int ref, int mv_dir, int mv_type, int(*mv)[2][4][2], int mb_x, int mb_y, int mb_intra, int mb_skipped)

Definition: error_resilience.h:86

H264Context::mvd_table

uint8_t(*[2] mvd_table)[2]

Definition: h264dec.h:417

h264_decode_end

static av_cold int h264_decode_end(AVCodecContext *avctx)

Definition: h264dec.c:358

H264Context::prev_interlaced_frame

int prev_interlaced_frame

Complement sei_pic_struct SEI_PIC_STRUCT_TOP_BOTTOM and SEI_PIC_STRUCT_BOTTOM_TOP indicate interlaced...

Definition: h264dec.h:498

AVCodecContext::flags

int flags

AV_CODEC_FLAG_*.

Definition: avcodec.h:1598

finalize_frame

static int finalize_frame(H264Context *h, AVFrame *dst, H264Picture *out, int *got_frame)

Definition: h264dec.c:875

H264Picture::tf

ThreadFrame tf

Definition: h264dec.h:130

avassert.h

simple assert() macros that are a bit more flexible than ISO C assert().

AVCodec::name

const char * name

Name of the codec implementation.

Definition: avcodec.h:3415

H264SEIContext::unregistered

H264SEIUnregistered unregistered

Definition: h264_sei.h:159

offset

static const uint8_t offset[127][2]

Definition: vf_spp.c:92

H264Context::list_counts

uint8_t * list_counts

Array of list_count per MB specifying the slice type.

Definition: h264dec.h:410

FFMAX

#define FFMAX(a, b)

Definition: common.h:94

fail

#define fail()

Definition: checkasm.h:116

AV_CODEC_CAP_FRAME_THREADS

#define AV_CODEC_CAP_FRAME_THREADS

Codec supports frame-level multithreading.

Definition: avcodec.h:1015

av_image_copy

void av_image_copy(uint8_t *dst_data[4], int dst_linesizes[4], const uint8_t *src_data[4], const int src_linesizes[4], enum AVPixelFormat pix_fmt, int width, int height)

Copy image in src_data to dst_data.

Definition: imgutils.c:387

ERContext::mb_index2xy

int * mb_index2xy

Definition: error_resilience.h:58

H2645NAL::raw_size

int raw_size

Definition: h2645_parse.h:43

H264SEIGreenMetaData::percent_non_zero_macroblocks

uint8_t percent_non_zero_macroblocks

Definition: h264_sei.h:142

bytestream.h

FF_CODEC_CAP_EXPORTS_CROPPING

#define FF_CODEC_CAP_EXPORTS_CROPPING

The decoder sets the cropping fields in the output frames manually.

Definition: internal.h:66

ONLY_IF_THREADS_ENABLED

#define ONLY_IF_THREADS_ENABLED(x)

Define a function with only the non-default version specified.

Definition: internal.h:225

ERContext::error_status_table

uint8_t * error_status_table

Definition: error_resilience.h:66

H264Context::direct_table

uint8_t * direct_table

Definition: h264dec.h:418

H264Context::nal_length_size

int nal_length_size

Number of bytes used for nal length (1, 2 or 4)

Definition: h264dec.h:451

rectangle.h

useful rectangle filling function

H264Ref::data

uint8_t * data[3]

Definition: h264dec.h:167

H264POCContext::prev_poc_msb

int prev_poc_msb

poc_msb of the last reference pic for POC type 0

Definition: h264_parse.h:49

AVCodecContext::draw_horiz_band

void(* draw_horiz_band)(struct AVCodecContext *s, const AVFrame *src, int offset[AV_NUM_DATA_POINTERS], int y, int type, int height)

If non NULL, 'draw_horiz_band' is called by the libavcodec decoder to draw a horizontal band...

Definition: avcodec.h:1752

profiles.h

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

FF_THREAD_FRAME

#define FF_THREAD_FRAME

Decode more than one frame at once.

Definition: avcodec.h:2780

H264Context::mb2br_xy

uint32_t * mb2br_xy

Definition: h264dec.h:400

ERContext::er_temp_buffer

uint8_t * er_temp_buffer

Definition: error_resilience.h:67

FFMIN

#define FFMIN(a, b)

Definition: common.h:96

H264Context::slice_table

uint16_t * slice_table

slice_table_base + 2*mb_stride + 1

Definition: h264dec.h:403

h264_er_decode_mb

static void h264_er_decode_mb(void *opaque, int ref, int mv_dir, int mv_type, int(*mv)[2][4][2], int mb_x, int mb_y, int mb_intra, int mb_skipped)

Definition: h264dec.c:66

H264Picture::reference

int reference

Definition: h264dec.h:160

is_extra

static int is_extra(const uint8_t *buf, int buf_size)

Definition: h264dec.c:853

AVCodecContext::width

int width

picture width / height.

Definition: avcodec.h:1690

H264Context::nb_slice_ctx

int nb_slice_ctx

Definition: h264dec.h:351

mathops.h

H264Picture::mb_type

uint32_t * mb_type

Definition: h264dec.h:139

ff_thread_report_progress

void ff_thread_report_progress(ThreadFrame *f, int n, int field)

Notify later decoding threads when part of their reference picture is ready.

Definition: pthread_frame.c:557

AV_OPT_TYPE_BOOL

Definition: opt.h:240

H264SEIUnregistered::x264_build

int x264_build

Definition: h264_sei.h:101

FF_THREAD_SLICE

#define FF_THREAD_SLICE

Decode more than one part of a single frame at once.

Definition: avcodec.h:2781

cabac_functions.h

Context Adaptive Binary Arithmetic Coder inline functions.

h264dec.h

H.264 / AVC / MPEG-4 part10 codec.

H264Context::mmco_reset

int mmco_reset

Definition: h264dec.h:475

H264Context::slice_ctx

H264SliceContext * slice_ctx

Definition: h264dec.h:350

AV_EF_EXPLODE

#define AV_EF_EXPLODE

abort decoding on minor error detection

Definition: avcodec.h:2653

H264Ref::reference

int reference

Definition: h264dec.h:170

AVCodecContext::ticks_per_frame

int ticks_per_frame

For some codecs, the time base is closer to the field rate than the frame rate.

Definition: avcodec.h:1649

H264SliceContext::top_borders_allocated

int top_borders_allocated[2]

Definition: h264dec.h:288

fill_rectangle

static void fill_rectangle(int x, int y, int w, int h)

Definition: ffplay.c:822

H2645NAL::ref_idc

int ref_idc

H.264 only, nal_ref_idc.

Definition: h2645_parse.h:64

AVCodecContext::height

int height

Definition: avcodec.h:1690

H264SliceContext::mb_y

int mb_y

Definition: h264dec.h:230

ff_print_debug_info2

void ff_print_debug_info2(AVCodecContext *avctx, AVFrame *pict, uint8_t *mbskip_table, uint32_t *mbtype_table, int8_t *qscale_table, int16_t(*motion_val[2])[2], int *low_delay, int mb_width, int mb_height, int mb_stride, int quarter_sample)

Print debugging info for the given picture.

Definition: mpegutils.c:103

H2645NAL::type

int type

NAL unit type.

Definition: h2645_parse.h:51

H264_NAL_DPA

Definition: h264.h:32

AVCodecContext::thread_count

int thread_count

thread count is used to decide how many independent tasks should be passed to execute() ...

Definition: avcodec.h:2769

H264_NAL_PPS

Definition: h264.h:38

H264SliceContext::edge_emu_buffer

uint8_t * edge_emu_buffer

Definition: h264dec.h:284

get_ue_golomb_long

static unsigned get_ue_golomb_long(GetBitContext *gb)

Read an unsigned Exp-Golomb code in the range 0 to UINT32_MAX-1.

Definition: golomb.h:85

me_cmp.h

AV_CODEC_CAP_SLICE_THREADS

#define AV_CODEC_CAP_SLICE_THREADS

Codec supports slice-based (or partition-based) multithreading.

Definition: avcodec.h:1019

static const int8_t mv[256][2]

Definition: 4xm.c:77

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

AV_PKT_DATA_NEW_EXTRADATA

The AV_PKT_DATA_NEW_EXTRADATA is used to notify the codec or the format that the extradata buffer was...

Definition: avcodec.h:1158

H264Context::mb_stride

int mb_stride

Definition: h264dec.h:436

H264Context::avctx

AVCodecContext * avctx

Definition: h264dec.h:339

AV_ONCE_INIT

#define AV_ONCE_INIT

Definition: thread.h:160

avcodec.h

Libavcodec external API header.

h264data.h

MAX_DELAYED_PIC_COUNT

#define MAX_DELAYED_PIC_COUNT

Definition: h264dec.h:56

AVCodecContext::codec_id

enum AVCodecID codec_id

Definition: avcodec.h:1528

ff_h264_decoder

AVCodec ff_h264_decoder

Definition: h264dec.c:1047

ERContext::next_pic

ERPicture next_pic

Definition: error_resilience.h:75

AVFrame::linesize

int linesize[AV_NUM_DATA_POINTERS]

For video, size in bytes of each picture line.

Definition: frame.h:249

H264Context::next_outputed_poc

int next_outputed_poc

Definition: h264dec.h:468

init_get_bits8

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

Initialize GetBitContext.

Definition: get_bits.h:464

H264Picture::field_poc

int field_poc[2]

top/bottom POC

Definition: h264dec.h:147

AV_CODEC_FLAG2_FAST

#define AV_CODEC_FLAG2_FAST

Allow non spec compliant speedup tricks.

Definition: avcodec.h:901

AVCodecContext::debug

int debug

debug

Definition: avcodec.h:2598

AVPixFmtDescriptor

Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...

Definition: pixdesc.h:81

error_resilience.h

H264Context::recovery_frame

int recovery_frame

recovery_frame is the frame_num at which the next frame should be fully constructed.

Definition: h264dec.h:511

AVCodecContext

main external API structure.

Definition: avcodec.h:1518

AVBufferRef::data

uint8_t * data

The data buffer.

Definition: buffer.h:89

H264SEIGreenMetaData

Definition: h264_sei.h:137

H2645NAL

Definition: h2645_parse.h:31

H2645NAL::data

const uint8_t * data

Definition: h2645_parse.h:35

h264_vlc_init

static AVOnce h264_vlc_init

Definition: h264dec.c:390

buf

void * buf

Definition: avisynth_c.h:690

H264Picture::qscale_table

int8_t * qscale_table

Definition: h264dec.h:133

scan8

static const uint8_t scan8[16 *3+3]

Definition: h264dec.h:644

AVCodecContext::extradata_size

int extradata_size

Definition: avcodec.h:1619

av_dict_set

int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)

Set the given entry in *pm, overwriting an existing entry.

Definition: dict.c:70

AVCodecContext::slice_flags

int slice_flags

slice flags

Definition: avcodec.h:1995

output_frame

static int output_frame(H264Context *h, AVFrame *dst, H264Picture *srcp)

Definition: h264dec.c:836

AVClass

Describe the class of an AVClass context structure.

Definition: log.h:67

H264POCContext::prev_frame_num

int prev_frame_num

frame_num of the last pic for POC type 1/2

Definition: h264_parse.h:53

H264SliceContext::non_zero_count_cache

uint8_t non_zero_count_cache[15 *8]

non zero coeff count cache.

Definition: h264dec.h:294

av_buffer_pool_uninit

void av_buffer_pool_uninit(AVBufferPool **ppool)

Mark the pool as being available for freeing.

Definition: buffer.c:275

pack16to32

static av_always_inline uint32_t pack16to32(unsigned a, unsigned b)

Definition: h264dec.h:660

H264Picture::ref_index

int8_t * ref_index[2]

Definition: h264dec.h:145

ff_h264_decode_init_vlc

av_cold void ff_h264_decode_init_vlc(void)

Definition: h264_cavlc.c:327

H264Picture::mmco_reset

int mmco_reset

MMCO_RESET set this 1.

Definition: h264dec.h:150

H264Context::cur_pic_ptr

H264Picture * cur_pic_ptr

Definition: h264dec.h:346

FMO

#define FMO

Definition: h264dec.h:62

H264SliceContext::mb_mbaff

int mb_mbaff

mb_aff_frame && mb_field_decoding_flag

Definition: h264dec.h:242

FF_DEBUG_GREEN_MD

#define FF_DEBUG_GREEN_MD

Definition: avcodec.h:2622

h2645_parse.h

H264Context::enable_er

int enable_er

Definition: h264dec.h:545

H264SEIGreenMetaData::percent_intra_coded_macroblocks

uint8_t percent_intra_coded_macroblocks

Definition: h264_sei.h:143

H264ParamSets::sps

const SPS * sps

Definition: h264_ps.h:145

PPS::sps_id

unsigned int sps_id

Definition: h264_ps.h:109

H264Context::width_from_caller

int width_from_caller

Definition: h264dec.h:542

H264_NAL_SEI

Definition: h264.h:36

AVCodecInternal::allocate_progress

int allocate_progress

Whether to allocate progress for frame threading.

Definition: internal.h:151

H264SEIContext::recovery_point

H264SEIRecoveryPoint recovery_point

Definition: h264_sei.h:160

ERContext::avctx

AVCodecContext * avctx

Definition: error_resilience.h:54

H264_NAL_SPS

Definition: h264.h:37

HWACCEL_VAAPI

#define HWACCEL_VAAPI(codec)

Definition: hwaccel.h:73

H264Ref::linesize

int linesize[3]

Definition: h264dec.h:168

AVFrame::data

uint8_t * data[AV_NUM_DATA_POINTERS]

pointer to the picture/channel planes.

Definition: frame.h:232

H264POCContext::prev_poc_lsb

int prev_poc_lsb

poc_lsb of the last reference pic for POC type 0

Definition: h264_parse.h:50

H264SEIGreenMetaData::xsd_metric_type

uint8_t xsd_metric_type

Definition: h264_sei.h:146

ff_h264_alloc_tables

int ff_h264_alloc_tables(H264Context *h)

Allocate tables.

Definition: h264dec.c:180

H264Context::has_recovery_point

int has_recovery_point

Definition: h264dec.h:526

H264Picture

Definition: h264dec.h:128

H264SEIGreenMetaData::xsd_metric_value

uint16_t xsd_metric_value

Definition: h264_sei.h:147

H264Context::nb_slice_ctx_queued

int nb_slice_ctx_queued

Definition: h264dec.h:352

AVDISCARD_NONREF

discard all non reference

Definition: avcodec.h:790

ff_h264_field_end

int ff_h264_field_end(H264Context *h, H264SliceContext *sl, int in_setup)

Definition: h264_picture.c:154

H264Context::qscale_table_pool

AVBufferPool * qscale_table_pool

Definition: h264dec.h:549

H264Context::next_output_pic

H264Picture * next_output_pic

Definition: h264dec.h:467

H264Context::motion_val_pool

AVBufferPool * motion_val_pool

Definition: h264dec.h:551

GetBitContext

Definition: get_bits.h:56

internal.h

common internal api header.

if(ret< 0)

Definition: vf_mcdeint.c:279

ref

static int ref[MAX_W *MAX_W]

Definition: jpeg2000dwt.c:107

H2645Packet::nb_nals

int nb_nals

Definition: h2645_parse.h:77

H264_NAL_END_SEQUENCE

Definition: h264.h:40

FF_ALLOC_OR_GOTO

#define FF_ALLOC_OR_GOTO(ctx, p, size, label)

Definition: internal.h:140

H264Context::slice_table_base

uint16_t * slice_table_base

Definition: h264dec.h:458

OFFSET

#define OFFSET(x)

Definition: h264dec.c:1030

H264Context::ps

H264ParamSets ps

Definition: h264dec.h:456

ERContext::dc_val

int16_t * dc_val[3]

Definition: error_resilience.h:68

H264SEIContext::frame_packing

H264SEIFramePacking frame_packing

Definition: h264_sei.h:162

h264_mvpred.h

H.264 / AVC / MPEG-4 part10 motion vector prediction.

stereo3d.h

Stereoscopic video.

AVCodecContext::workaround_bugs

int workaround_bugs

Work around bugs in encoders which sometimes cannot be detected automatically.

Definition: avcodec.h:2547

ff_h264_profiles

const AVProfile ff_h264_profiles[]

Definition: profiles.c:59

H264Context::cur_chroma_format_idc

int cur_chroma_format_idc

Definition: h264dec.h:536

H264SliceContext::intra4x4_pred_mode

int8_t * intra4x4_pred_mode

Definition: h264dec.h:206

AVRational::den

int den

Denominator.

Definition: rational.h:60

ff_h264_ps_uninit

void ff_h264_ps_uninit(H264ParamSets *ps)

Uninit H264 param sets structure.

Definition: h264_ps.c:317

AVERROR_UNKNOWN

#define AVERROR_UNKNOWN

Unknown error, typically from an external library.

Definition: error.h:71

h264_decode_frame

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

Definition: h264dec.c:958

H2645NAL::gb

GetBitContext gb

Definition: h2645_parse.h:46

ERContext::mb_num

int mb_num

Definition: error_resilience.h:59

#define VD

Definition: h264dec.c:1031

ff_h264_free_tables

void ff_h264_free_tables(H264Context *h)

Definition: h264dec.c:137

AVCodecContext::priv_data

void * priv_data

Definition: avcodec.h:1545

H2645NAL::raw_data

const uint8_t * raw_data

Definition: h2645_parse.h:44

PICT_FRAME

#define PICT_FRAME

Definition: mpegutils.h:39

H264SliceContext::ref_cache

int8_t ref_cache[2][5 *8]

Definition: h264dec.h:300

AV_CODEC_FLAG_OUTPUT_CORRUPT

#define AV_CODEC_FLAG_OUTPUT_CORRUPT

Output even those frames that might be corrupted.

Definition: avcodec.h:841

ff_h264_decode_seq_parameter_set

int ff_h264_decode_seq_parameter_set(GetBitContext *gb, AVCodecContext *avctx, H264ParamSets *ps, int ignore_truncation)

Decode SPS.

Definition: h264_ps.c:334

H264_NAL_SLICE

Definition: h264.h:31

AVCodecContext::internal

struct AVCodecInternal * internal

Private context used for internal data.

Definition: avcodec.h:1553

ff_thread_once

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

Definition: thread.h:162

H2645Packet::nals

H2645NAL * nals

Definition: h2645_parse.h:75

H264Context::cur_pic

H264Picture cur_pic

Definition: h264dec.h:347

PART_NOT_AVAILABLE

#define PART_NOT_AVAILABLE

Definition: h264dec.h:391

AVFrame::key_frame

int key_frame

1 -> keyframe, 0-> not

Definition: frame.h:296

H264Context::mb_width

int mb_width

Definition: h264dec.h:435

H264Context::current_slice

int current_slice

current slice number, used to initialize slice_num of each thread/context

Definition: h264dec.h:488

AVCodecContext::flags2

int flags2

AV_CODEC_FLAG2_*.

Definition: avcodec.h:1605

H264Context::mb2b_xy

uint32_t * mb2b_xy

Definition: h264dec.h:399

H264SliceContext::ref_list

H264Ref ref_list[2][48]

0..15: frame refs, 16..47: mbaff field refs.

Definition: h264dec.h:269

h264_decode_init

static av_cold int h264_decode_init(AVCodecContext *avctx)

Definition: h264dec.c:392

H264_NAL_DPB

Definition: h264.h:33

H264Context::last_pic_for_ec

H264Picture last_pic_for_ec

Definition: h264dec.h:348

AVFrame::height

int height

Definition: frame.h:276

AV_CODEC_FLAG2_SHOW_ALL

#define AV_CODEC_FLAG2_SHOW_ALL

Show all frames before the first keyframe.

Definition: avcodec.h:929

out

FILE * out

Definition: movenc.c:54

H264SliceContext::mvd_table

uint8_t(*[2] mvd_table)[2]

Definition: h264dec.h:313

av_freep

#define av_freep(p)

Definition: tableprint_vlc.h:35

HWACCEL_VDPAU

#define HWACCEL_VDPAU(codec)

Definition: hwaccel.h:75

ff_h264_sei_decode

int ff_h264_sei_decode(H264SEIContext *h, GetBitContext *gb, const H264ParamSets *ps, void *logctx)

Definition: h264_sei.c:391

AVMEDIA_TYPE_VIDEO

Definition: avutil.h:201

H264POCContext::prev_frame_num_offset

int prev_frame_num_offset

for POC type 2

Definition: h264_parse.h:52

H264Context::intra4x4_pred_mode

int8_t * intra4x4_pred_mode

Definition: h264dec.h:385

ff_h264_slice_context_init

int ff_h264_slice_context_init(H264Context *h, H264SliceContext *sl)

Init context Allocate buffers which are not shared amongst multiple threads.

Definition: h264dec.c:238

AVHWAccel::decode_slice

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

Callback for each slice.

Definition: avcodec.h:3666

ERContext::mb_stride

ptrdiff_t mb_stride

Definition: error_resilience.h:61

H264SliceContext::mb_field_decoding_flag

int mb_field_decoding_flag

Definition: h264dec.h:241

H264Context::non_zero_count

uint8_t(* non_zero_count)[48]

Definition: h264dec.h:388

golomb.h

exp golomb vlc stuff

H264SliceContext::bipred_scratchpad

uint8_t * bipred_scratchpad

Definition: h264dec.h:283

ff_h264_unref_picture

void ff_h264_unref_picture(H264Context *h, H264Picture *pic)

Definition: h264_picture.c:45

AVPacket

This structure stores compressed data.

Definition: avcodec.h:1407

H264Context::droppable

int droppable

Definition: h264dec.h:362

AV_CODEC_CAP_DR1

#define AV_CODEC_CAP_DR1

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

Definition: avcodec.h:959

H264SEIFramePacking::arrangement_cancel_flag

int arrangement_cancel_flag

is previous arrangement canceled, -1 if never received

Definition: h264_sei.h:123

H264Context::nal_ref_idc

int nal_ref_idc

Definition: h264dec.h:442

for

for(j=16;j >0;--j)

Definition: h264pred_template.c:469

FF_ALLOCZ_OR_GOTO

#define FF_ALLOCZ_OR_GOTO(ctx, p, size, label)

Definition: internal.h:149

H264Context::b_stride

int b_stride

Definition: h264dec.h:401

ff_h264_mb_sizes

const uint16_t ff_h264_mb_sizes[4]

Definition: h264dec.c:58

AVHWAccel::decode_params

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

Callback for parameter data (SPS/PPS/VPS etc).

Definition: avcodec.h:3652

cabac.h

Context Adaptive Binary Arithmetic Coder.

H264_MAX_PICTURE_COUNT

#define H264_MAX_PICTURE_COUNT

Definition: h264dec.h:52

av_mallocz_array

void * av_mallocz_array(size_t nmemb, size_t size)

Definition: mem.c:191

H264SEIGreenMetaData::percent_alpha_point_deblocking_instance

uint8_t percent_alpha_point_deblocking_instance

Definition: h264_sei.h:145

H264_NAL_DPC

Definition: h264.h:34

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