FFmpeg: libavcodec/hevc_refs.c Source File

FFmpeg

[フレーム]

libavcodec

hevc_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/avassert.h"

26 #include "thread.h"

27 #include "hevc.h"

28 #include "hevcdec.h"

29 #include "threadframe.h"

31 void ff_hevc_unref_frame(HEVCContext *s, HEVCFrame *frame, int flags)

32 {

33 /* frame->frame can be NULL if context init failed */

34 if (!frame->frame || !frame->frame->buf[0])

35 return;

37 frame->flags &= ~flags;

38 if (!frame->flags) {

39 ff_thread_release_ext_buffer(s->avctx, &frame->tf);

40 ff_thread_release_buffer(s->avctx, frame->frame_grain);

41 frame->needs_fg = 0;

43 av_buffer_unref(&frame->tab_mvf_buf);

44 frame->tab_mvf = NULL;

46 av_buffer_unref(&frame->rpl_buf);

47 av_buffer_unref(&frame->rpl_tab_buf);

48 frame->rpl_tab = NULL;

49 frame->refPicList = NULL;

51 frame->collocated_ref = NULL;

53 av_buffer_unref(&frame->hwaccel_priv_buf);

54 frame->hwaccel_picture_private = NULL;

55 }

56 }

58 const RefPicList *ff_hevc_get_ref_list(const HEVCContext *s,

59 const HEVCFrame *ref, int x0, int y0)

60 {

61 int x_cb = x0 >> s->ps.sps->log2_ctb_size;

62 int y_cb = y0 >> s->ps.sps->log2_ctb_size;

63 int pic_width_cb = s->ps.sps->ctb_width;

64 int ctb_addr_ts = s->ps.pps->ctb_addr_rs_to_ts[y_cb * pic_width_cb + x_cb];

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

66 }

68 void ff_hevc_clear_refs(HEVCContext *s)

69 {

70 int i;

71 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++)

72 ff_hevc_unref_frame(s, &s->DPB[i],

73 HEVC_FRAME_FLAG_SHORT_REF |

74 HEVC_FRAME_FLAG_LONG_REF);

75 }

77 void ff_hevc_flush_dpb(HEVCContext *s)

78 {

79 int i;

80 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++)

81 ff_hevc_unref_frame(s, &s->DPB[i], ~0);

82 }

84 static HEVCFrame *alloc_frame(HEVCContext *s)

85 {

86 int i, j, ret;

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

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

89 if (frame->frame->buf[0])

90 continue;

92 ret = ff_thread_get_ext_buffer(s->avctx, &frame->tf,

93 AV_GET_BUFFER_FLAG_REF);

94 if (ret < 0)

95 return NULL;

97 frame->rpl_buf = av_buffer_allocz(s->pkt.nb_nals * sizeof(RefPicListTab));

98 if (!frame->rpl_buf)

99 goto fail;

100

101 frame->tab_mvf_buf = av_buffer_pool_get(s->tab_mvf_pool);

102 if (!frame->tab_mvf_buf)

103 goto fail;

104 frame->tab_mvf = (MvField *)frame->tab_mvf_buf->data;

105

106 frame->rpl_tab_buf = av_buffer_pool_get(s->rpl_tab_pool);

107 if (!frame->rpl_tab_buf)

108 goto fail;

109 frame->rpl_tab = (RefPicListTab **)frame->rpl_tab_buf->data;

110 frame->ctb_count = s->ps.sps->ctb_width * s->ps.sps->ctb_height;

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

112 frame->rpl_tab[j] = (RefPicListTab *)frame->rpl_buf->data;

113

114 frame->frame->top_field_first = s->sei.picture_timing.picture_struct == AV_PICTURE_STRUCTURE_TOP_FIELD;

115 frame->frame->interlaced_frame = (s->sei.picture_timing.picture_struct == AV_PICTURE_STRUCTURE_TOP_FIELD) || (s->sei.picture_timing.picture_struct == AV_PICTURE_STRUCTURE_BOTTOM_FIELD);

116

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

118 const AVHWAccel *hwaccel = s->avctx->hwaccel;

119 av_assert0(!frame->hwaccel_picture_private);

120 if (hwaccel->frame_priv_data_size) {

121 frame->hwaccel_priv_buf = av_buffer_allocz(hwaccel->frame_priv_data_size);

122 if (!frame->hwaccel_priv_buf)

123 goto fail;

124 frame->hwaccel_picture_private = frame->hwaccel_priv_buf->data;

125 }

126 }

127

128 return frame;

129 fail:

130 ff_hevc_unref_frame(s, frame, ~0);

131 return NULL;

132 }

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

134 return NULL;

135 }

136

137 int ff_hevc_set_new_ref(HEVCContext *s, AVFrame **frame, int poc)

138 {

139 HEVCFrame *ref;

140 int i;

141

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

143 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {

144 HEVCFrame *frame = &s->DPB[i];

145

146 if (frame->frame->buf[0] && frame->sequence == s->seq_decode &&

147 frame->poc == poc) {

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

149 poc);

150 return AVERROR_INVALIDDATA;

151 }

152 }

153

154 ref = alloc_frame(s);

155 if (!ref)

156 return AVERROR(ENOMEM);

157

158 *frame = ref->frame;

159 s->ref = ref;

160

161 if (s->sh.pic_output_flag)

162 ref->flags = HEVC_FRAME_FLAG_OUTPUT | HEVC_FRAME_FLAG_SHORT_REF;

163 else

164 ref->flags = HEVC_FRAME_FLAG_SHORT_REF;

165

166 ref->poc = poc;

167 ref->sequence = s->seq_decode;

168 ref->frame->crop_left = s->ps.sps->output_window.left_offset;

169 ref->frame->crop_right = s->ps.sps->output_window.right_offset;

170 ref->frame->crop_top = s->ps.sps->output_window.top_offset;

171 ref->frame->crop_bottom = s->ps.sps->output_window.bottom_offset;

172

173 return 0;

174 }

175

176 static void unref_missing_refs(HEVCContext *s)

177 {

178 for (int i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {

179 HEVCFrame *frame = &s->DPB[i];

180 if (frame->sequence == HEVC_SEQUENCE_COUNTER_INVALID) {

181 ff_hevc_unref_frame(s, frame, ~0);

182 }

183 }

184 }

185

186 int ff_hevc_output_frame(HEVCContext *s, AVFrame *out, int flush)

187 {

188 if (IS_IRAP(s) && s->no_rasl_output_flag == 1) {

189 const static int mask = HEVC_FRAME_FLAG_BUMPING | HEVC_FRAME_FLAG_OUTPUT;

190 for (int i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {

191 HEVCFrame *frame = &s->DPB[i];

192 if ((frame->flags & mask) == HEVC_FRAME_FLAG_OUTPUT &&

193 frame->sequence != s->seq_decode) {

194 if (s->sh.no_output_of_prior_pics_flag == 1)

195 ff_hevc_unref_frame(s, frame, HEVC_FRAME_FLAG_OUTPUT);

196 else

197 frame->flags |= HEVC_FRAME_FLAG_BUMPING;

198 }

199 }

200 }

201 do {

202 int nb_output = 0;

203 int min_poc = INT_MAX;

204 int i, min_idx, ret;

205

206 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {

207 HEVCFrame *frame = &s->DPB[i];

208 if ((frame->flags & HEVC_FRAME_FLAG_OUTPUT) &&

209 frame->sequence == s->seq_output) {

210 nb_output++;

211 if (frame->poc < min_poc || nb_output == 1) {

212 min_poc = frame->poc;

213 min_idx = i;

214 }

215 }

216 }

217

218 /* wait for more frames before output */

219 if (!flush && s->seq_output == s->seq_decode && s->ps.sps &&

220 nb_output <= s->ps.sps->temporal_layer[s->ps.sps->max_sub_layers - 1].num_reorder_pics)

221 return 0;

222

223 if (nb_output) {

224 HEVCFrame *frame = &s->DPB[min_idx];

225

226 ret = av_frame_ref(out, frame->needs_fg ? frame->frame_grain : frame->frame);

227 if (frame->flags & HEVC_FRAME_FLAG_BUMPING)

228 ff_hevc_unref_frame(s, frame, HEVC_FRAME_FLAG_OUTPUT | HEVC_FRAME_FLAG_BUMPING);

229 else

230 ff_hevc_unref_frame(s, frame, HEVC_FRAME_FLAG_OUTPUT);

231 if (ret < 0)

232 return ret;

233

234 if (frame->needs_fg && (ret = av_frame_copy_props(out, frame->frame)) < 0)

235 return ret;

236

237 if (!(s->avctx->export_side_data & AV_CODEC_EXPORT_DATA_FILM_GRAIN))

238 av_frame_remove_side_data(out, AV_FRAME_DATA_FILM_GRAIN_PARAMS);

239

240 av_log(s->avctx, AV_LOG_DEBUG,

241 "Output frame with POC %d.\n", frame->poc);

242 return 1;

243 }

244

245 if (s->seq_output != s->seq_decode)

246 s->seq_output = (s->seq_output + 1) & HEVC_SEQUENCE_COUNTER_MASK;

247 else

248 break;

249 } while (1);

250

251 return 0;

252 }

253

254 void ff_hevc_bump_frame(HEVCContext *s)

255 {

256 int dpb = 0;

257 int min_poc = INT_MAX;

258 int i;

259

260 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {

261 HEVCFrame *frame = &s->DPB[i];

262 if ((frame->flags) &&

263 frame->sequence == s->seq_output &&

264 frame->poc != s->poc) {

265 dpb++;

266 }

267 }

268

269 if (s->ps.sps && dpb >= s->ps.sps->temporal_layer[s->ps.sps->max_sub_layers - 1].max_dec_pic_buffering) {

270 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {

271 HEVCFrame *frame = &s->DPB[i];

272 if ((frame->flags) &&

273 frame->sequence == s->seq_output &&

274 frame->poc != s->poc) {

275 if (frame->flags == HEVC_FRAME_FLAG_OUTPUT && frame->poc < min_poc) {

276 min_poc = frame->poc;

277 }

278 }

279 }

280

281 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {

282 HEVCFrame *frame = &s->DPB[i];

283 if (frame->flags & HEVC_FRAME_FLAG_OUTPUT &&

284 frame->sequence == s->seq_output &&

285 frame->poc <= min_poc) {

286 frame->flags |= HEVC_FRAME_FLAG_BUMPING;

287 }

288 }

289

290 dpb--;

291 }

292 }

293

294 static int init_slice_rpl(HEVCContext *s)

295 {

296 HEVCFrame *frame = s->ref;

297 int ctb_count = frame->ctb_count;

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

299 int i;

300

301 if (s->slice_idx >= frame->rpl_buf->size / sizeof(RefPicListTab))

302 return AVERROR_INVALIDDATA;

303

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

305 frame->rpl_tab[i] = (RefPicListTab *)frame->rpl_buf->data + s->slice_idx;

306

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

308

309 return 0;

310 }

311

312 int ff_hevc_slice_rpl(HEVCContext *s)

313 {

314 SliceHeader *sh = &s->sh;

315

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

317 uint8_t list_idx;

318 int i, j, ret;

319

320 ret = init_slice_rpl(s);

321 if (ret < 0)

322 return ret;

323

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

325 s->rps[LT_CURR].nb_refs)) {

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

327 return AVERROR_INVALIDDATA;

328 }

329

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

331 RefPicList rpl_tmp = { { 0 } };

332 RefPicList *rpl = &s->ref->refPicList[list_idx];

333

334 /* The order of the elements is

335 * ST_CURR_BEF - ST_CURR_AFT - LT_CURR for the L0 and

336 * ST_CURR_AFT - ST_CURR_BEF - LT_CURR for the L1 */

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

338 list_idx ? ST_CURR_BEF : ST_CURR_AFT,

339 LT_CURR };

340

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

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

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

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

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

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

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

348 rpl_tmp.isLongTerm[rpl_tmp.nb_refs] = i == 2;

349 rpl_tmp.nb_refs++;

350 }

351 }

352 }

353

354 /* reorder the references if necessary */

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

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

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

358

359 if (idx >= rpl_tmp.nb_refs) {

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

361 return AVERROR_INVALIDDATA;

362 }

363

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

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

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

367 rpl->nb_refs++;

368 }

369 } else {

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

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

372 }

373

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

375 sh->collocated_ref_idx < rpl->nb_refs)

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

377 }

378

379 return 0;

380 }

381

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

383 {

384 int mask = use_msb ? ~0 : (1 << s->ps.sps->log2_max_poc_lsb) - 1;

385 int i;

386

387 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {

388 HEVCFrame *ref = &s->DPB[i];

389 if (ref->frame->buf[0] && ref->sequence == s->seq_decode) {

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

391 return ref;

392 }

393 }

394

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

396 av_log(s->avctx, AV_LOG_ERROR,

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

398 return NULL;

399 }

400

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

402 {

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

404 frame->flags |= flag;

405 }

406

407 static HEVCFrame *generate_missing_ref(HEVCContext *s, int poc)

408 {

409 HEVCFrame *frame;

410 int i, y;

411

412 frame = alloc_frame(s);

413 if (!frame)

414 return NULL;

415

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

417 if (!s->ps.sps->pixel_shift) {

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

419 memset(frame->frame->data[i], 1 << (s->ps.sps->bit_depth - 1),

420 frame->frame->linesize[i] * AV_CEIL_RSHIFT(s->ps.sps->height, s->ps.sps->vshift[i]));

421 } else {

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

423 for (y = 0; y < (s->ps.sps->height >> s->ps.sps->vshift[i]); y++) {

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

425 AV_WN16(dst, 1 << (s->ps.sps->bit_depth - 1));

426 av_memcpy_backptr(dst + 2, 2, 2*(s->ps.sps->width >> s->ps.sps->hshift[i]) - 2);

427 }

428 }

429 }

430

431 frame->poc = poc;

432 frame->sequence = HEVC_SEQUENCE_COUNTER_INVALID;

433 frame->flags = 0;

434

435 if (s->threads_type == FF_THREAD_FRAME)

436 ff_thread_report_progress(&frame->tf, INT_MAX, 0);

437

438 return frame;

439 }

440

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

442 static int add_candidate_ref(HEVCContext *s, RefPicList *list,

443 int poc, int ref_flag, uint8_t use_msb)

444 {

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

446

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

448 return AVERROR_INVALIDDATA;

449

450 if (!ref) {

451 ref = generate_missing_ref(s, poc);

452 if (!ref)

453 return AVERROR(ENOMEM);

454 }

455

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

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

458 list->nb_refs++;

459

460 mark_ref(ref, ref_flag);

461 return 0;

462 }

463

464 int ff_hevc_frame_rps(HEVCContext *s)

465 {

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

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

468 RefPicList *rps = s->rps;

469 int i, ret = 0;

470

471 if (!short_rps) {

472 rps[0].nb_refs = rps[1].nb_refs = 0;

473 return 0;

474 }

475

476 unref_missing_refs(s);

477

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

479 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {

480 HEVCFrame *frame = &s->DPB[i];

481

482 if (frame == s->ref)

483 continue;

484

485 mark_ref(frame, 0);

486 }

487

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

489 rps[i].nb_refs = 0;

490

491 /* add the short refs */

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

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

494 int list;

495

496 if (!short_rps->used[i])

497 list = ST_FOLL;

498 else if (i < short_rps->num_negative_pics)

499 list = ST_CURR_BEF;

500 else

501 list = ST_CURR_AFT;

502

503 ret = add_candidate_ref(s, &rps[list], poc, HEVC_FRAME_FLAG_SHORT_REF, 1);

504 if (ret < 0)

505 goto fail;

506 }

507

508 /* add the long refs */

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

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

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

512

513 ret = add_candidate_ref(s, &rps[list], poc, HEVC_FRAME_FLAG_LONG_REF, long_rps->poc_msb_present[i]);

514 if (ret < 0)

515 goto fail;

516 }

517

518 fail:

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

520 for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++)

521 ff_hevc_unref_frame(s, &s->DPB[i], 0);

522

523 return ret;

524 }

525

526 int ff_hevc_frame_nb_refs(const HEVCContext *s)

527 {

528 int ret = 0;

529 int i;

530 const ShortTermRPS *rps = s->sh.short_term_rps;

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

532

533 if (rps) {

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

535 ret += !!rps->used[i];

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

537 ret += !!rps->used[i];

538 }

539

540 if (long_rps) {

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

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

543 }

544 return ret;

545 }

ShortTermRPS::used

uint8_t used[32]

Definition: hevc_ps.h:40

LT_FOLL

@ LT_FOLL

Definition: hevcdec.h:85

AVERROR

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

ff_hevc_get_ref_list

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

Definition: hevc_refs.c:58

ff_thread_release_ext_buffer

void ff_thread_release_ext_buffer(AVCodecContext *avctx, ThreadFrame *f)

Unref a ThreadFrame.

Definition: pthread_frame.c:972

out

FILE * out

Definition: movenc.c:54

HEVC_MAX_REFS

@ HEVC_MAX_REFS

Definition: hevc.h:119

find_ref_idx

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

Definition: hevc_refs.c:382

AV_FRAME_DATA_FILM_GRAIN_PARAMS

@ AV_FRAME_DATA_FILM_GRAIN_PARAMS

Film grain parameters for a frame, described by AVFilmGrainParams.

Definition: frame.h:184

AVFrame

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

Definition: frame.h:330

RefPicList

Definition: hevcdec.h:241

thread.h

add_candidate_ref

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

Definition: hevc_refs.c:442

AVHWAccel

Definition: avcodec.h:2076

HEVC_FRAME_FLAG_LONG_REF

#define HEVC_FRAME_FLAG_LONG_REF

Definition: hevcdec.h:395

ff_hevc_clear_refs

void ff_hevc_clear_refs(HEVCContext *s)

Mark all frames in DPB as unused for reference.

Definition: hevc_refs.c:68

fail

#define fail()

Definition: checkasm.h:134

mark_ref

static void mark_ref(HEVCFrame *frame, int flag)

Definition: hevc_refs.c:401

ff_hevc_output_frame

int ff_hevc_output_frame(HEVCContext *s, AVFrame *out, int flush)

Find next frame in output order and put a reference to it in frame.

Definition: hevc_refs.c:186

RefPicList::nb_refs

int nb_refs

Definition: hevcdec.h:245

ShortTermRPS::num_delta_pocs

int num_delta_pocs

Definition: hevc_ps.h:37

avassert.h

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:180

FF_ARRAY_ELEMS

#define FF_ARRAY_ELEMS(a)

Definition: sinewin_tablegen.c:29

HEVC_SEQUENCE_COUNTER_INVALID

#define HEVC_SEQUENCE_COUNTER_INVALID

Definition: hevcdec.h:399

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

HEVC_FRAME_FLAG_BUMPING

#define HEVC_FRAME_FLAG_BUMPING

Definition: hevcdec.h:396

mask

static const uint16_t mask[17]

Definition: lzw.c:38

av_memcpy_backptr

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

Overlapping memcpy() implementation.

Definition: mem.c:445

av_buffer_pool_get

AVBufferRef * av_buffer_pool_get(AVBufferPool *pool)

Allocate a new AVBuffer, reusing an old buffer from the pool when available.

Definition: buffer.c:384

#define s(width, name)

Definition: cbs_vp9.c:256

AV_CEIL_RSHIFT

#define AV_CEIL_RSHIFT(a, b)

Definition: common.h:50

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

init_slice_rpl

static int init_slice_rpl(HEVCContext *s)

Definition: hevc_refs.c:294

ff_hevc_set_new_ref

int ff_hevc_set_new_ref(HEVCContext *s, AVFrame **frame, int poc)

Definition: hevc_refs.c:137

av_assert0

#define av_assert0(cond)

assert() equivalent, that is always enabled.

Definition: avassert.h:37

AV_LOG_DEBUG

#define AV_LOG_DEBUG

Stuff which is only useful for libav* developers.

Definition: log.h:201

HEVC_FRAME_FLAG_SHORT_REF

#define HEVC_FRAME_FLAG_SHORT_REF

Definition: hevcdec.h:394

ff_hevc_slice_rpl

int ff_hevc_slice_rpl(HEVCContext *s)

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

Definition: hevc_refs.c:312

RefPicList::ref

struct HEVCFrame * ref[HEVC_MAX_REFS]

Definition: hevcdec.h:242

SliceHeader::collocated_list

uint8_t collocated_list

Definition: hevcdec.h:290

generate_missing_ref

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

Definition: hevc_refs.c:407

AV_PICTURE_STRUCTURE_BOTTOM_FIELD

@ AV_PICTURE_STRUCTURE_BOTTOM_FIELD

coded as bottom field

Definition: avcodec.h:2808

threadframe.h

IS_BLA

#define IS_BLA(s)

Definition: hevcdec.h:76

HEVC_SLICE_B

@ HEVC_SLICE_B

Definition: hevc.h:96

NULL

#define NULL

Definition: coverity.c:32

HEVC_SEQUENCE_COUNTER_MASK

#define HEVC_SEQUENCE_COUNTER_MASK

Definition: hevcdec.h:398

av_frame_copy_props

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

Copy only "metadata" fields from src to dst.

Definition: frame.c:594

av_buffer_unref

void av_buffer_unref(AVBufferRef **buf)

Free a given reference and automatically free the buffer if there are no more references to it.

Definition: buffer.c:139

LongTermRPS::poc

int poc[32]

Definition: hevcdec.h:235

AV_PICTURE_STRUCTURE_TOP_FIELD

@ AV_PICTURE_STRUCTURE_TOP_FIELD

coded as top field

Definition: avcodec.h:2807

list

Definition: filter_design.txt:25

LongTermRPS::poc_msb_present

uint8_t poc_msb_present[32]

Definition: hevcdec.h:236

HEVC_NAL_CRA_NUT

@ HEVC_NAL_CRA_NUT

Definition: hevc.h:50

RefPicListTab

Definition: hevcdec.h:248

SliceHeader::nb_refs

unsigned int nb_refs[2]

Definition: hevcdec.h:282

ff_hevc_frame_rps

int ff_hevc_frame_rps(HEVCContext *s)

Construct the reference picture sets for the current frame.

Definition: hevc_refs.c:464

IS_IRAP

#define IS_IRAP(s)

Definition: hevcdec.h:78

LongTermRPS::used

uint8_t used[32]

Definition: hevcdec.h:237

ST_FOLL

@ ST_FOLL

Definition: hevcdec.h:83

hevcdec.h

av_frame_ref

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

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

Definition: frame.c:344

for

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

Definition: h264pred_template.c:425

SliceHeader::collocated_ref_idx

unsigned int collocated_ref_idx

Definition: hevcdec.h:292

HEVC_FRAME_FLAG_OUTPUT

#define HEVC_FRAME_FLAG_OUTPUT

Definition: hevcdec.h:393

MvField

Definition: hevcdec.h:347

ff_hevc_unref_frame

void ff_hevc_unref_frame(HEVCContext *s, HEVCFrame *frame, int flags)

Definition: hevc_refs.c:31

alloc_frame

static HEVCFrame * alloc_frame(HEVCContext *s)

Definition: hevc_refs.c:84

av_frame_remove_side_data

void av_frame_remove_side_data(AVFrame *frame, enum AVFrameSideDataType type)

Remove and free all side data instances of the given type.

Definition: frame.c:782

FF_THREAD_FRAME

#define FF_THREAD_FRAME

Decode more than one frame at once.

Definition: avcodec.h:1513

ff_thread_release_buffer

void ff_thread_release_buffer(AVCodecContext *avctx, AVFrame *f)

Wrapper around release_buffer() frame-for multithreaded codecs.

Definition: pthread_frame.c:961

ShortTermRPS::num_negative_pics

unsigned int num_negative_pics

Definition: hevc_ps.h:36

flag

#define flag(name)

Definition: cbs_av1.c:553

SliceHeader

Definition: hevcdec.h:252

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

Definition: cbs_h2645.c:269

HEVCFrame

Definition: hevcdec.h:401

unref_missing_refs

static void unref_missing_refs(HEVCContext *s)

Definition: hevc_refs.c:176

RefPicList::list

int list[HEVC_MAX_REFS]

Definition: hevcdec.h:243

ff_hevc_bump_frame

void ff_hevc_bump_frame(HEVCContext *s)

Definition: hevc_refs.c:254

FFMIN

#define FFMIN(a, b)

Definition: macros.h:49

SliceHeader::list_entry_lx

unsigned int list_entry_lx[2][32]

Definition: hevcdec.h:276

ff_thread_get_ext_buffer

int ff_thread_get_ext_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)

Wrapper around ff_get_buffer() for frame-multithreaded codecs.

Definition: pthread_frame.c:930

hevc.h

av_buffer_allocz

AVBufferRef * av_buffer_allocz(size_t size)

Same as av_buffer_alloc(), except the returned buffer will be initialized to zero.

Definition: buffer.c:93

ret

Definition: filter_design.txt:187

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

ff_hevc_frame_nb_refs

int ff_hevc_frame_nb_refs(const HEVCContext *s)

Get the number of candidate references for the current frame.

Definition: hevc_refs.c:526

LongTermRPS

Definition: hevcdec.h:234

SliceHeader::slice_type

enum HEVCSliceType slice_type