FFmpeg: libavcodec/hevc/refs.c Source File

FFmpeg

[フレーム]

refs.c

Go to the documentation of this file.

1 /*

2 * HEVC video decoder

3 *

6 *

7 * This file is part of FFmpeg.

8 *

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

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

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

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

13 *

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

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

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

17 * Lesser General Public License for more details.

18 *

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

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

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

22 */

24 #include "libavutil/mem.h"

25 #include "libavutil/stereo3d.h"

27 #include "container_fifo.h"

28 #include "decode.h"

29 #include "hevc.h"

30 #include "hevcdec.h"

31 #include "progressframe.h"

32 #include "refstruct.h"

34 void ff_hevc_unref_frame(HEVCFrame *frame, int flags)

35 {

36 frame->flags &= ~flags;

37 if (!frame->flags) {

38 ff_progress_frame_unref(&frame->tf);

39 av_frame_unref(frame->frame_grain);

40 frame->needs_fg = 0;

42 ff_refstruct_unref(&frame->pps);

43 ff_refstruct_unref(&frame->tab_mvf);

45 ff_refstruct_unref(&frame->rpl);

46 frame->nb_rpl_elems = 0;

47 ff_refstruct_unref(&frame->rpl_tab);

48 frame->refPicList = NULL;

50 ff_refstruct_unref(&frame->hwaccel_picture_private);

51 }

52 }

54 const RefPicList *ff_hevc_get_ref_list(const HEVCFrame *ref, int x0, int y0)

55 {

56 const HEVCSPS *sps = ref->pps->sps;

57 int x_cb = x0 >> sps->log2_ctb_size;

58 int y_cb = y0 >> sps->log2_ctb_size;

59 int pic_width_cb = sps->ctb_width;

60 int ctb_addr_ts = ref->pps->ctb_addr_rs_to_ts[y_cb * pic_width_cb + x_cb];

61 return &ref->rpl_tab[ctb_addr_ts]->refPicList[0];

62 }

64 void ff_hevc_clear_refs(HEVCLayerContext *l)

65 {

66 int i;

67 for (i = 0; i < FF_ARRAY_ELEMS(l->DPB); i++)

68 ff_hevc_unref_frame(&l->DPB[i],

69 HEVC_FRAME_FLAG_SHORT_REF |

70 HEVC_FRAME_FLAG_LONG_REF);

71 }

73 void ff_hevc_flush_dpb(HEVCContext *s)

74 {

75 for (int layer = 0; layer < FF_ARRAY_ELEMS(s->layers); layer++) {

76 HEVCLayerContext *l = &s->layers[layer];

77 for (int i = 0; i < FF_ARRAY_ELEMS(l->DPB); i++)

78 ff_hevc_unref_frame(&l->DPB[i], ~0);

79 }

80 }

82 static HEVCFrame *alloc_frame(HEVCContext *s, HEVCLayerContext *l)

83 {

84 const HEVCVPS *vps = l->sps->vps;

85 const int view_id = vps->view_id[s->cur_layer];

86 int i, j, ret;

87 for (i = 0; i < FF_ARRAY_ELEMS(l->DPB); i++) {

88 HEVCFrame *frame = &l->DPB[i];

89 if (frame->f)

90 continue;

92 ret = ff_progress_frame_alloc(s->avctx, &frame->tf);

93 if (ret < 0)

94 return NULL;

96 // Add LCEVC SEI metadata here, as it's needed in get_buffer()

97 if (s->sei.common.lcevc.info) {

98 HEVCSEILCEVC *lcevc = &s->sei.common.lcevc;

99 ret = ff_frame_new_side_data_from_buf(s->avctx, frame->tf.f,

100 AV_FRAME_DATA_LCEVC, &lcevc->info);

101 if (ret < 0)

102 goto fail;

103 }

104

105 // add view ID side data if it's nontrivial

106 if (vps->nb_layers > 1 || view_id) {

107 HEVCSEITDRDI *tdrdi = &s->sei.tdrdi;

108 AVFrameSideData *sd = av_frame_side_data_new(&frame->f->side_data,

109 &frame->f->nb_side_data,

110 AV_FRAME_DATA_VIEW_ID,

111 sizeof(int), 0);

112 if (!sd)

113 goto fail;

114 *(int*)sd->data = view_id;

115

116 if (tdrdi->num_ref_displays) {

117 AVStereo3D *stereo_3d;

118

119 stereo_3d = av_stereo3d_create_side_data(frame->f);

120 if (!stereo_3d)

121 goto fail;

122

123 stereo_3d->type = AV_STEREO3D_FRAMESEQUENCE;

124 if (tdrdi->left_view_id[0] == view_id)

125 stereo_3d->view = AV_STEREO3D_VIEW_LEFT;

126 else if (tdrdi->right_view_id[0] == view_id)

127 stereo_3d->view = AV_STEREO3D_VIEW_RIGHT;

128 else

129 stereo_3d->view = AV_STEREO3D_VIEW_UNSPEC;

130 }

131 }

132

133 ret = ff_progress_frame_get_buffer(s->avctx, &frame->tf,

134 AV_GET_BUFFER_FLAG_REF);

135 if (ret < 0)

136 return NULL;

137

138 frame->rpl = ff_refstruct_allocz(s->pkt.nb_nals * sizeof(*frame->rpl));

139 if (!frame->rpl)

140 goto fail;

141 frame->nb_rpl_elems = s->pkt.nb_nals;

142

143 frame->tab_mvf = ff_refstruct_pool_get(l->tab_mvf_pool);

144 if (!frame->tab_mvf)

145 goto fail;

146

147 frame->rpl_tab = ff_refstruct_pool_get(l->rpl_tab_pool);

148 if (!frame->rpl_tab)

149 goto fail;

150 frame->ctb_count = l->sps->ctb_width * l->sps->ctb_height;

151 for (j = 0; j < frame->ctb_count; j++)

152 frame->rpl_tab[j] = frame->rpl;

153

154 if (s->sei.picture_timing.picture_struct == AV_PICTURE_STRUCTURE_TOP_FIELD)

155 frame->f->flags |= AV_FRAME_FLAG_TOP_FIELD_FIRST;

156 if ((s->sei.picture_timing.picture_struct == AV_PICTURE_STRUCTURE_TOP_FIELD) ||

157 (s->sei.picture_timing.picture_struct == AV_PICTURE_STRUCTURE_BOTTOM_FIELD))

158 frame->f->flags |= AV_FRAME_FLAG_INTERLACED;

159

160 ret = ff_hwaccel_frame_priv_alloc(s->avctx, &frame->hwaccel_picture_private);

161 if (ret < 0)

162 goto fail;

163

164 frame->pps = ff_refstruct_ref_c(s->pps);

165

166 return frame;

167 fail:

168 ff_hevc_unref_frame(frame, ~0);

169 return NULL;

170 }

171 av_log(s->avctx, AV_LOG_ERROR, "Error allocating frame, DPB full.\n");

172 return NULL;

173 }

174

175 int ff_hevc_set_new_ref(HEVCContext *s, HEVCLayerContext *l, int poc)

176 {

177 HEVCFrame *ref;

178 int i;

179

180 /* check that this POC doesn't already exist */

181 for (i = 0; i < FF_ARRAY_ELEMS(l->DPB); i++) {

182 HEVCFrame *frame = &l->DPB[i];

183

184 if (frame->f && frame->poc == poc) {

185 av_log(s->avctx, AV_LOG_ERROR, "Duplicate POC in a sequence: %d.\n",

186 poc);

187 return AVERROR_INVALIDDATA;

188 }

189 }

190

191 ref = alloc_frame(s, l);

192 if (!ref)

193 return AVERROR(ENOMEM);

194

195 s->cur_frame = ref;

196 l->cur_frame = ref;

197 s->collocated_ref = NULL;

198

199 ref->base_layer_frame = (l != &s->layers[0] && s->layers[0].cur_frame) ?

200 s->layers[0].cur_frame - s->layers[0].DPB : -1;

201

202 if (s->sh.pic_output_flag)

203 ref->flags = HEVC_FRAME_FLAG_OUTPUT | HEVC_FRAME_FLAG_SHORT_REF;

204 else

205 ref->flags = HEVC_FRAME_FLAG_SHORT_REF;

206

207 ref->poc = poc;

208 ref->f->crop_left = l->sps->output_window.left_offset;

209 ref->f->crop_right = l->sps->output_window.right_offset;

210 ref->f->crop_top = l->sps->output_window.top_offset;

211 ref->f->crop_bottom = l->sps->output_window.bottom_offset;

212

213 return 0;

214 }

215

216 static void unref_missing_refs(HEVCLayerContext *l)

217 {

218 for (int i = 0; i < FF_ARRAY_ELEMS(l->DPB); i++) {

219 HEVCFrame *frame = &l->DPB[i];

220 if (frame->flags & HEVC_FRAME_FLAG_UNAVAILABLE) {

221 ff_hevc_unref_frame(frame, ~0);

222 }

223 }

224 }

225

226 int ff_hevc_output_frames(HEVCContext *s,

227 unsigned layers_active_decode, unsigned layers_active_output,

228 unsigned max_output, unsigned max_dpb, int discard)

229 {

230 while (1) {

231 int nb_dpb[HEVC_VPS_MAX_LAYERS] = { 0 };

232 int nb_output = 0;

233 int min_poc = INT_MAX;

234 int min_layer = -1;

235 int min_idx, ret = 0;

236

237 for (int layer = 0; layer < FF_ARRAY_ELEMS(s->layers); layer++) {

238 HEVCLayerContext *l = &s->layers[layer];

239

240 if (!(layers_active_decode & (1 << layer)))

241 continue;

242

243 for (int i = 0; i < FF_ARRAY_ELEMS(l->DPB); i++) {

244 HEVCFrame *frame = &l->DPB[i];

245 if (frame->flags & HEVC_FRAME_FLAG_OUTPUT) {

246 // nb_output counts AUs with an output-pending frame

247 // in at least one layer

248 if (!(frame->base_layer_frame >= 0 &&

249 (s->layers[0].DPB[frame->base_layer_frame].flags & HEVC_FRAME_FLAG_OUTPUT)))

250 nb_output++;

251 if (min_layer < 0 || frame->poc < min_poc) {

252 min_poc = frame->poc;

253 min_idx = i;

254 min_layer = layer;

255 }

256 }

257 nb_dpb[layer] += !!frame->flags;

258 }

259 }

260

261 if (nb_output > max_output ||

262 (nb_output &&

263 (nb_dpb[0] > max_dpb || nb_dpb[1] > max_dpb))) {

264 HEVCFrame *frame = &s->layers[min_layer].DPB[min_idx];

265 AVFrame *f = frame->needs_fg ? frame->frame_grain : frame->f;

266 int output = !discard && (layers_active_output & (1 << min_layer));

267

268 if (output) {

269 f->pkt_dts = s->pkt_dts;

270 ret = ff_container_fifo_write(s->output_fifo, f);

271 }

272 ff_hevc_unref_frame(frame, HEVC_FRAME_FLAG_OUTPUT);

273 if (ret < 0)

274 return ret;

275

276 av_log(s->avctx, AV_LOG_DEBUG, "%s frame with POC %d/%d.\n",

277 output ? "Output" : "Discarded", min_layer, frame->poc);

278 continue;

279 }

280 return 0;

281 }

282 }

283

284 static int init_slice_rpl(HEVCContext *s)

285 {

286 HEVCFrame *frame = s->cur_frame;

287 int ctb_count = frame->ctb_count;

288 int ctb_addr_ts = s->pps->ctb_addr_rs_to_ts[s->sh.slice_segment_addr];

289 int i;

290

291 if (s->slice_idx >= frame->nb_rpl_elems)

292 return AVERROR_INVALIDDATA;

293

294 for (i = ctb_addr_ts; i < ctb_count; i++)

295 frame->rpl_tab[i] = frame->rpl + s->slice_idx;

296

297 frame->refPicList = (RefPicList *)frame->rpl_tab[ctb_addr_ts];

298

299 return 0;

300 }

301

302 int ff_hevc_slice_rpl(HEVCContext *s)

303 {

304 SliceHeader *sh = &s->sh;

305

306 uint8_t nb_list = sh->slice_type == HEVC_SLICE_B ? 2 : 1;

307 uint8_t list_idx;

308 int i, j, ret;

309

310 ret = init_slice_rpl(s);

311 if (ret < 0)

312 return ret;

313

314 if (!(s->rps[ST_CURR_BEF].nb_refs + s->rps[ST_CURR_AFT].nb_refs +

315 s->rps[LT_CURR].nb_refs +

316 s->rps[INTER_LAYER0].nb_refs + s->rps[INTER_LAYER1].nb_refs) &&

317 !s->pps->pps_curr_pic_ref_enabled_flag) {

318 av_log(s->avctx, AV_LOG_ERROR, "Zero refs in the frame RPS.\n");

319 return AVERROR_INVALIDDATA;

320 }

321

322 for (list_idx = 0; list_idx < nb_list; list_idx++) {

323 RefPicList rpl_tmp = { { 0 } };

324 RefPicList *rpl = &s->cur_frame->refPicList[list_idx];

325

326 /* The order of the elements is

327 * ST_CURR_BEF - INTER_LAYER0 - ST_CURR_AFT - LT_CURR - INTER_LAYER1 for the L0 and

328 * ST_CURR_AFT - INTER_LAYER1 - ST_CURR_BEF - LT_CURR - INTER_LAYER0 for the L1 */

329 int cand_lists[] = { list_idx ? ST_CURR_AFT : ST_CURR_BEF,

330 list_idx ? INTER_LAYER1 : INTER_LAYER0,

331 list_idx ? ST_CURR_BEF : ST_CURR_AFT,

332 LT_CURR,

333 list_idx ? INTER_LAYER0 : INTER_LAYER1

334 };

335

336 /* concatenate the candidate lists for the current frame */

337 while (rpl_tmp.nb_refs < sh->nb_refs[list_idx]) {

338 for (i = 0; i < FF_ARRAY_ELEMS(cand_lists); i++) {

339 RefPicList *rps = &s->rps[cand_lists[i]];

340 for (j = 0; j < rps->nb_refs && rpl_tmp.nb_refs < HEVC_MAX_REFS; j++) {

341 rpl_tmp.list[rpl_tmp.nb_refs] = rps->list[j];

342 rpl_tmp.ref[rpl_tmp.nb_refs] = rps->ref[j];

343 // multiview inter-layer refs are treated as long-term here,

344 // cf. G.8.1.3

345 rpl_tmp.isLongTerm[rpl_tmp.nb_refs] = cand_lists[i] == LT_CURR ||

346 cand_lists[i] == INTER_LAYER0 ||

347 cand_lists[i] == INTER_LAYER1;

348 rpl_tmp.nb_refs++;

349 }

350 }

351 // Construct RefPicList0, RefPicList1 (8-8, 8-10)

352 if (s->pps->pps_curr_pic_ref_enabled_flag && rpl_tmp.nb_refs < HEVC_MAX_REFS) {

353 rpl_tmp.list[rpl_tmp.nb_refs] = s->cur_frame->poc;

354 rpl_tmp.ref[rpl_tmp.nb_refs] = s->cur_frame;

355 rpl_tmp.isLongTerm[rpl_tmp.nb_refs] = 1;

356 rpl_tmp.nb_refs++;

357 }

358 }

359

360 /* reorder the references if necessary */

361 if (sh->rpl_modification_flag[list_idx]) {

362 for (i = 0; i < sh->nb_refs[list_idx]; i++) {

363 int idx = sh->list_entry_lx[list_idx][i];

364

365 if (idx >= rpl_tmp.nb_refs) {

366 av_log(s->avctx, AV_LOG_ERROR, "Invalid reference index.\n");

367 return AVERROR_INVALIDDATA;

368 }

369

370 rpl->list[i] = rpl_tmp.list[idx];

371 rpl->ref[i] = rpl_tmp.ref[idx];

372 rpl->isLongTerm[i] = rpl_tmp.isLongTerm[idx];

373 rpl->nb_refs++;

374 }

375 } else {

376 memcpy(rpl, &rpl_tmp, sizeof(*rpl));

377 rpl->nb_refs = FFMIN(rpl->nb_refs, sh->nb_refs[list_idx]);

378 }

379

380 // 8-9

381 if (s->pps->pps_curr_pic_ref_enabled_flag &&

382 !sh->rpl_modification_flag[list_idx] &&

383 rpl_tmp.nb_refs > sh->nb_refs[L0]) {

384 rpl->list[sh->nb_refs[L0] - 1] = s->cur_frame->poc;

385 rpl->ref[sh->nb_refs[L0] - 1] = s->cur_frame;

386 }

387

388 if (sh->collocated_list == list_idx &&

389 sh->collocated_ref_idx < rpl->nb_refs)

390 s->collocated_ref = rpl->ref[sh->collocated_ref_idx];

391 }

392

393 return 0;

394 }

395

396 static HEVCFrame *find_ref_idx(HEVCContext *s, HEVCLayerContext *l,

397 int poc, uint8_t use_msb)

398 {

399 int mask = use_msb ? ~0 : (1 << l->sps->log2_max_poc_lsb) - 1;

400 int i;

401

402 for (i = 0; i < FF_ARRAY_ELEMS(l->DPB); i++) {

403 HEVCFrame *ref = &l->DPB[i];

404 if (ref->f) {

405 if ((ref->poc & mask) == poc && (use_msb || ref->poc != s->poc))

406 return ref;

407 }

408 }

409

410 if (s->nal_unit_type != HEVC_NAL_CRA_NUT && !IS_BLA(s))

411 av_log(s->avctx, AV_LOG_ERROR,

412 "Could not find ref with POC %d\n", poc);

413 return NULL;

414 }

415

416 static void mark_ref(HEVCFrame *frame, int flag)

417 {

418 frame->flags &= ~(HEVC_FRAME_FLAG_LONG_REF | HEVC_FRAME_FLAG_SHORT_REF);

419 frame->flags |= flag;

420 }

421

422 static HEVCFrame *generate_missing_ref(HEVCContext *s, HEVCLayerContext *l, int poc)

423 {

424 HEVCFrame *frame;

425 int i, y;

426

427 frame = alloc_frame(s, l);

428 if (!frame)

429 return NULL;

430

431 if (!s->avctx->hwaccel) {

432 if (!l->sps->pixel_shift) {

433 for (i = 0; frame->f->data[i]; i++)

434 memset(frame->f->data[i], 1 << (l->sps->bit_depth - 1),

435 frame->f->linesize[i] * AV_CEIL_RSHIFT(l->sps->height, l->sps->vshift[i]));

436 } else {

437 for (i = 0; frame->f->data[i]; i++)

438 for (y = 0; y < (l->sps->height >> l->sps->vshift[i]); y++) {

439 uint8_t *dst = frame->f->data[i] + y * frame->f->linesize[i];

440 AV_WN16(dst, 1 << (l->sps->bit_depth - 1));

441 av_memcpy_backptr(dst + 2, 2, 2*(l->sps->width >> l->sps->hshift[i]) - 2);

442 }

443 }

444 }

445

446 frame->poc = poc;

447 frame->flags = HEVC_FRAME_FLAG_UNAVAILABLE;

448

449 if (s->avctx->active_thread_type == FF_THREAD_FRAME)

450 ff_progress_frame_report(&frame->tf, INT_MAX);

451

452 return frame;

453 }

454

455 /* add a reference with the given poc to the list and mark it as used in DPB */

456 static int add_candidate_ref(HEVCContext *s, HEVCLayerContext *l,

457 RefPicList *list,

458 int poc, int ref_flag, uint8_t use_msb)

459 {

460 HEVCFrame *ref = find_ref_idx(s, l, poc, use_msb);

461

462 if (ref == s->cur_frame || list->nb_refs >= HEVC_MAX_REFS)

463 return AVERROR_INVALIDDATA;

464

465 if (!ref) {

466 ref = generate_missing_ref(s, l, poc);

467 if (!ref)

468 return AVERROR(ENOMEM);

469 }

470

471 list->list[list->nb_refs] = ref->poc;

472 list->ref[list->nb_refs] = ref;

473 list->nb_refs++;

474

475 mark_ref(ref, ref_flag);

476 return 0;

477 }

478

479 int ff_hevc_frame_rps(HEVCContext *s, HEVCLayerContext *l)

480 {

481 const ShortTermRPS *short_rps = s->sh.short_term_rps;

482 const LongTermRPS *long_rps = &s->sh.long_term_rps;

483 RefPicList *rps = s->rps;

484 int i, ret = 0;

485

486 unref_missing_refs(l);

487

488 /* clear the reference flags on all frames except the current one */

489 for (i = 0; i < FF_ARRAY_ELEMS(l->DPB); i++) {

490 HEVCFrame *frame = &l->DPB[i];

491

492 if (frame == s->cur_frame)

493 continue;

494

495 mark_ref(frame, 0);

496 }

497

498 for (i = 0; i < NB_RPS_TYPE; i++)

499 rps[i].nb_refs = 0;

500

501 if (!short_rps)

502 goto inter_layer;

503

504 /* add the short refs */

505 for (i = 0; i < short_rps->num_delta_pocs; i++) {

506 int poc = s->poc + short_rps->delta_poc[i];

507 int list;

508

509 if (!(short_rps->used & (1 << i)))

510 list = ST_FOLL;

511 else if (i < short_rps->num_negative_pics)

512 list = ST_CURR_BEF;

513 else

514 list = ST_CURR_AFT;

515

516 ret = add_candidate_ref(s, l, &rps[list], poc,

517 HEVC_FRAME_FLAG_SHORT_REF, 1);

518 if (ret < 0)

519 goto fail;

520 }

521

522 /* add the long refs */

523 for (i = 0; i < long_rps->nb_refs; i++) {

524 int poc = long_rps->poc[i];

525 int list = long_rps->used[i] ? LT_CURR : LT_FOLL;

526

527 ret = add_candidate_ref(s, l, &rps[list], poc,

528 HEVC_FRAME_FLAG_LONG_REF, long_rps->poc_msb_present[i]);

529 if (ret < 0)

530 goto fail;

531 }

532

533 inter_layer:

534 /* add inter-layer refs */

535 if (s->sh.inter_layer_pred) {

536 HEVCLayerContext *l0 = &s->layers[0];

537

538 av_assert0(l != l0);

539

540 /* Given the assumption of at most two layers, refPicSet0Flag is

541 * always 1, so only RefPicSetInterLayer0 can ever contain a frame. */

542 if (l0->cur_frame) {

543 // inter-layer refs are treated as short-term here, cf. F.8.1.6

544 ret = add_candidate_ref(s, l0, &rps[INTER_LAYER0], l0->cur_frame->poc,

545 HEVC_FRAME_FLAG_SHORT_REF, 1);

546 if (ret < 0)

547 goto fail;

548 }

549 }

550

551 fail:

552 /* release any frames that are now unused */

553 for (i = 0; i < FF_ARRAY_ELEMS(l->DPB); i++)

554 ff_hevc_unref_frame(&l->DPB[i], 0);

555

556 return ret;

557 }

558

559 int ff_hevc_frame_nb_refs(const SliceHeader *sh, const HEVCPPS *pps,

560 unsigned layer_idx)

561 {

562 int ret = 0;

563 int i;

564 const ShortTermRPS *rps = sh->short_term_rps;

565 const LongTermRPS *long_rps = &sh->long_term_rps;

566

567 if (rps) {

568 for (i = 0; i < rps->num_negative_pics; i++)

569 ret += !!(rps->used & (1 << i));

570 for (; i < rps->num_delta_pocs; i++)

571 ret += !!(rps->used & (1 << i));

572 }

573

574 if (long_rps) {

575 for (i = 0; i < long_rps->nb_refs; i++)

576 ret += !!long_rps->used[i];

577 }

578

579 if (sh->inter_layer_pred) {

580 av_assert0(pps->sps->vps->num_direct_ref_layers[layer_idx] < 2);

581 ret++;

582 }

583

584 if (pps->pps_curr_pic_ref_enabled_flag)

585 ret++;

586

587 return ret;

588 }

ff_progress_frame_report

void ff_progress_frame_report(ProgressFrame *f, int n)

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

Definition: decode.c:1917

ff_hevc_flush_dpb

void ff_hevc_flush_dpb(HEVCContext *s)

Drop all frames currently in DPB.

Definition: refs.c:73

ff_container_fifo_write

int ff_container_fifo_write(ContainerFifo *cf, void *obj)

Write the contents of obj to the FIFO.

Definition: container_fifo.c:136

AV_STEREO3D_VIEW_LEFT

@ AV_STEREO3D_VIEW_LEFT

Frame contains only the left view.

Definition: stereo3d.h:158

LT_FOLL

@ LT_FOLL

Definition: hevcdec.h:86

AVERROR

Filter the word "frame" indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions

HEVCWindow::bottom_offset

unsigned int bottom_offset

Definition: ps.h:95

ShortTermRPS::num_negative_pics

uint8_t num_negative_pics

Definition: ps.h:80

HEVC_VPS_MAX_LAYERS

#define HEVC_VPS_MAX_LAYERS

Definition: ps.h:35

HEVCSPS::bit_depth

int bit_depth

Definition: ps.h:262

output

filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce output

Definition: filter_design.txt:225

HEVCSEILCEVC::info

AVBufferRef * info

Definition: h2645_sei.h:54

mask

int mask

Definition: mediacodecdec_common.c:154

container_fifo.h

AVFrame

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

Definition: frame.h:389

ff_progress_frame_get_buffer

int ff_progress_frame_get_buffer(AVCodecContext *avctx, ProgressFrame *f, int flags)

This function sets up the ProgressFrame, i.e.

Definition: decode.c:1872

ff_hevc_frame_rps

int ff_hevc_frame_rps(HEVCContext *s, HEVCLayerContext *l)

Construct the reference picture sets for the current frame.

Definition: refs.c:479

RefPicList

Definition: hevcdec.h:192

AV_STEREO3D_VIEW_RIGHT

@ AV_STEREO3D_VIEW_RIGHT

Frame contains only the right view.

Definition: stereo3d.h:163

HEVCSEILCEVC

Definition: h2645_sei.h:53

AV_STEREO3D_VIEW_UNSPEC

@ AV_STEREO3D_VIEW_UNSPEC

Content is unspecified.

Definition: stereo3d.h:168

HEVCSPS::output_window

HEVCWindow output_window

Definition: ps.h:256

AV_FRAME_FLAG_TOP_FIELD_FIRST

#define AV_FRAME_FLAG_TOP_FIELD_FIRST

A flag to mark frames where the top field is displayed first if the content is interlaced.

Definition: frame.h:653

find_ref_idx

static HEVCFrame * find_ref_idx(HEVCContext *s, HEVCLayerContext *l, int poc, uint8_t use_msb)

Definition: refs.c:396

HEVC_FRAME_FLAG_LONG_REF

#define HEVC_FRAME_FLAG_LONG_REF

Definition: hevcdec.h:354

fail

#define fail()

Definition: checkasm.h:188

HEVCWindow::left_offset

unsigned int left_offset

Definition: ps.h:92

mark_ref

static void mark_ref(HEVCFrame *frame, int flag)

Definition: refs.c:416

HEVC_MAX_REFS

@ HEVC_MAX_REFS

Definition: hevc.h:122

RefPicList::nb_refs

int nb_refs

Definition: hevcdec.h:196

HEVCSPS::log2_max_poc_lsb

unsigned int log2_max_poc_lsb

Definition: ps.h:267

progressframe.h

refstruct.h

ff_frame_new_side_data_from_buf

int ff_frame_new_side_data_from_buf(const AVCodecContext *avctx, AVFrame *frame, enum AVFrameSideDataType type, AVBufferRef **buf)

Similar to ff_frame_new_side_data, but using an existing buffer ref.

Definition: decode.c:2161

AV_STEREO3D_FRAMESEQUENCE

@ AV_STEREO3D_FRAMESEQUENCE

Views are alternated temporally.

Definition: stereo3d.h:89

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:180

HEVC_SLICE_B

@ HEVC_SLICE_B

Definition: hevc.h:96

HEVCLayerContext::rpl_tab_pool

struct FFRefStructPool * rpl_tab_pool

Definition: hevcdec.h:484

unref_missing_refs

static void unref_missing_refs(HEVCLayerContext *l)

Definition: refs.c:216

FF_ARRAY_ELEMS

#define FF_ARRAY_ELEMS(a)

Definition: sinewin_tablegen.c:29

ff_refstruct_ref_c

const void * ff_refstruct_ref_c(const void *obj)

Analog of ff_refstruct_ref(), but for constant objects.

Definition: refstruct.c:149

av_memcpy_backptr

void av_memcpy_backptr(uint8_t *dst, int back, int cnt)

Overlapping memcpy() implementation.

Definition: mem.c:447

stereo3d.h

ff_hwaccel_frame_priv_alloc

int ff_hwaccel_frame_priv_alloc(AVCodecContext *avctx, void **hwaccel_picture_private)

Allocate a hwaccel frame private data if the provided avctx uses a hwaccel method that needs it.

Definition: decode.c:2275

HEVCLayerContext::cur_frame

HEVCFrame * cur_frame

Definition: hevcdec.h:451

#define s(width, name)

Definition: cbs_vp9.c:198

HEVCSPS::height

int height

Definition: ps.h:348

AV_CEIL_RSHIFT

#define AV_CEIL_RSHIFT(a, b)

Definition: common.h:60

AV_GET_BUFFER_FLAG_REF

#define AV_GET_BUFFER_FLAG_REF

The decoder will keep a reference to the frame and may reuse it later.

Definition: avcodec.h:431

av_assert0

#define av_assert0(cond)

assert() equivalent, that is always enabled.

Definition: avassert.h:40

AV_LOG_DEBUG

#define AV_LOG_DEBUG

Stuff which is only useful for libav* developers.

Definition: log.h:201

ff_progress_frame_unref

void ff_progress_frame_unref(ProgressFrame *f)

Give up a reference to the underlying frame contained in a ProgressFrame and reset the ProgressFrame,...

Definition: decode.c:1900

decode.h

hevc.h

HEVC_FRAME_FLAG_SHORT_REF

#define HEVC_FRAME_FLAG_SHORT_REF

Definition: hevcdec.h:353

ff_hevc_slice_rpl

int ff_hevc_slice_rpl(HEVCContext *s)

Construct the reference picture list(s) for the current slice.

Definition: refs.c:302

RefPicList::ref

struct HEVCFrame * ref[HEVC_MAX_REFS]

Definition: hevcdec.h:193

HEVCLayerContext::tab_mvf_pool

struct FFRefStructPool * tab_mvf_pool

Definition: hevcdec.h:483

HEVCWindow::top_offset

unsigned int top_offset

Definition: ps.h:94

SliceHeader::collocated_list

uint8_t collocated_list

Definition: hevcdec.h:243

ShortTermRPS::num_delta_pocs

uint8_t num_delta_pocs

Definition: ps.h:81

if(ret)

Definition: filter_design.txt:179

AV_PICTURE_STRUCTURE_BOTTOM_FIELD

@ AV_PICTURE_STRUCTURE_BOTTOM_FIELD

coded as bottom field

Definition: avcodec.h:2744

IS_BLA

#define IS_BLA(s)

Definition: hevcdec.h:77

NULL

#define NULL

Definition: coverity.c:32

LongTermRPS::poc

int poc[32]

Definition: hevcdec.h:186

AV_PICTURE_STRUCTURE_TOP_FIELD

@ AV_PICTURE_STRUCTURE_TOP_FIELD

coded as top field

Definition: avcodec.h:2743

generate_missing_ref

static HEVCFrame * generate_missing_ref(HEVCContext *s, HEVCLayerContext *l, int poc)

Definition: refs.c:422

#define L0

Definition: hevcdec.h:58

list

Definition: filter_design.txt:25

LongTermRPS::poc_msb_present

uint8_t poc_msb_present[32]

Definition: hevcdec.h:187

ff_refstruct_allocz

static void * ff_refstruct_allocz(size_t size)

Equivalent to ff_refstruct_alloc_ext(size, 0, NULL, NULL)

Definition: refstruct.h:105

INTER_LAYER0

@ INTER_LAYER0

Definition: hevcdec.h:87

vps

static int FUNC() vps(CodedBitstreamContext *ctx, RWContext *rw, H265RawVPS *current)

Definition: cbs_h265_syntax_template.c:423

SliceHeader::nb_refs

unsigned int nb_refs[2]

Definition: hevcdec.h:235

ff_hevc_set_new_ref

int ff_hevc_set_new_ref(HEVCContext *s, HEVCLayerContext *l, int poc)

Definition: refs.c:175

ShortTermRPS::used

uint32_t used

Definition: ps.h:77

ff_hevc_output_frames

int ff_hevc_output_frames(HEVCContext *s, unsigned layers_active_decode, unsigned layers_active_output, unsigned max_output, unsigned max_dpb, int discard)

Find frames in the DPB that are ready for output and either write them to the output FIFO or drop the...

Definition: refs.c:226

LongTermRPS::used

uint8_t used[32]

Definition: hevcdec.h:188

ff_hevc_unref_frame

void ff_hevc_unref_frame(HEVCFrame *frame, int flags)

Definition: refs.c:34

HEVCSEITDRDI

Definition: sei.h:82

ST_FOLL

@ ST_FOLL

Definition: hevcdec.h:84

add_candidate_ref

static int add_candidate_ref(HEVCContext *s, HEVCLayerContext *l, RefPicList *list, int poc, int ref_flag, uint8_t use_msb)

Definition: refs.c:456

Definition: af_crystalizer.c:122

HEVCSPS::vps

const HEVCVPS * vps

RefStruct reference.

Definition: ps.h:368

ff_progress_frame_alloc

int ff_progress_frame_alloc(AVCodecContext *avctx, ProgressFrame *f)

This function allocates ProgressFrame.f May be called before ff_progress_frame_get_buffer() in the ca...

Definition: decode.c:1858

hevcdec.h

dst

uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst

Definition: dsp.h:83

HEVCSEITDRDI::right_view_id

uint16_t right_view_id[32]

Definition: sei.h:88

HEVCSEITDRDI::left_view_id

uint16_t left_view_id[32]

Definition: sei.h:87

AV_FRAME_DATA_LCEVC

@ AV_FRAME_DATA_LCEVC

Raw LCEVC payload data, as a uint8_t array, with NAL emulation bytes intact.

Definition: frame.h:236

ff_hevc_clear_refs

void ff_hevc_clear_refs(HEVCLayerContext *l)

Mark all frames in DPB as unused for reference.

Definition: refs.c:64

SliceHeader::collocated_ref_idx

unsigned int collocated_ref_idx

Definition: hevcdec.h:245

AVFrameSideData::data

uint8_t * data

Definition: frame.h:267

HEVC_FRAME_FLAG_OUTPUT

#define HEVC_FRAME_FLAG_OUTPUT

Definition: hevcdec.h:352

HEVC_FRAME_FLAG_UNAVAILABLE

#define HEVC_FRAME_FLAG_UNAVAILABLE

Definition: hevcdec.h:355

HEVCSPS::hshift

int hshift[3]

Definition: ps.h:360

AV_FRAME_DATA_VIEW_ID

@ AV_FRAME_DATA_VIEW_ID

This side data must be associated with a video frame.

Definition: frame.h:245

FF_THREAD_FRAME

#define FF_THREAD_FRAME

Decode more than one frame at once.

Definition: avcodec.h:1604

flag

#define flag(name)

Definition: cbs_av1.c:474

SliceHeader

Definition: hevcdec.h:203

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

Definition: cbs_h2645.c:256

HEVCFrame

Definition: hevcdec.h:357

init_slice_rpl

static int init_slice_rpl(HEVCContext *s)

Definition: refs.c:284

HEVCLayerContext

Definition: hevcdec.h:449

RefPicList::list

int list[HEVC_MAX_REFS]

Definition: hevcdec.h:194

HEVCSEITDRDI::num_ref_displays

uint8_t num_ref_displays

Definition: sei.h:86

FFMIN

#define FFMIN(a, b)

Definition: macros.h:49

av_frame_unref

void av_frame_unref(AVFrame *frame)

Unreference all the buffers referenced by frame and reset the frame fields.

Definition: frame.c:610

HEVCSPS::width

int width

Definition: ps.h:347

SliceHeader::list_entry_lx

unsigned int list_entry_lx[2][32]

Definition: hevcdec.h:229

HEVCFrame::poc

int poc

Definition: hevcdec.h:370

AV_FRAME_FLAG_INTERLACED

#define AV_FRAME_FLAG_INTERLACED

A flag to mark frames whose content is interlaced.

Definition: frame.h:648

SliceHeader::short_term_rps

const ShortTermRPS * short_term_rps

Definition: hevcdec.h:226

HEVCLayerContext::sps

const HEVCSPS * sps

Definition: hevcdec.h:453

ret

Definition: filter_design.txt:187

ff_hevc_get_ref_list

const RefPicList * ff_hevc_get_ref_list(const HEVCFrame *ref, int x0, int y0)

Definition: refs.c:54

frame

these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame

Definition: filter_design.txt:264

ST_CURR_BEF

@ ST_CURR_BEF

Definition: hevcdec.h:82

AVStereo3D::type

enum AVStereo3DType type

How views are packed within the video.

Definition: stereo3d.h:207

sps

static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)

Definition: cbs_h264_syntax_template.c:260

LongTermRPS