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"

25 #include "libavutil/pixdesc.h"

27 #include "internal.h"

28 #include "thread.h"

29 #include "hevc.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_buffer(s->avctx, &frame->tf);

41 av_buffer_unref(&frame->tab_mvf_buf);

42 frame->tab_mvf = NULL;

44 av_buffer_unref(&frame->rpl_buf);

45 av_buffer_unref(&frame->rpl_tab_buf);

46 frame->rpl_tab = NULL;

47 frame->refPicList = NULL;

49 frame->collocated_ref = NULL;

51 av_buffer_unref(&frame->hwaccel_priv_buf);

52 frame->hwaccel_picture_private = NULL;

53 }

54 }

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

57 {

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

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

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

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

62 return (RefPicList *)ref->rpl_tab[ctb_addr_ts];

63 }

65 void ff_hevc_clear_refs(HEVCContext *s)

66 {

67 int i;

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

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

70 HEVC_FRAME_FLAG_SHORT_REF |

71 HEVC_FRAME_FLAG_LONG_REF);

72 }

74 void ff_hevc_flush_dpb(HEVCContext *s)

75 {

76 int i;

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

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

79 }

81 static HEVCFrame *alloc_frame(HEVCContext *s)

82 {

83 int i, j, ret;

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

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

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

87 continue;

89 ret = ff_thread_get_buffer(s->avctx, &frame->tf,

90 AV_GET_BUFFER_FLAG_REF);

91 if (ret < 0)

92 return NULL;

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

95 if (!frame->rpl_buf)

96 goto fail;

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

99 if (!frame->tab_mvf_buf)

100 goto fail;

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

102

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

104 if (!frame->rpl_tab_buf)

105 goto fail;

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

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

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

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

110

111 frame->frame->top_field_first = s->picture_struct == AV_PICTURE_STRUCTURE_TOP_FIELD;

112 frame->frame->interlaced_frame = (s->picture_struct == AV_PICTURE_STRUCTURE_TOP_FIELD) || (s->picture_struct == AV_PICTURE_STRUCTURE_BOTTOM_FIELD);

113

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

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

116 av_assert0(!frame->hwaccel_picture_private);

117 if (hwaccel->frame_priv_data_size) {

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

119 if (!frame->hwaccel_priv_buf)

120 goto fail;

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

122 }

123 }

124

125 return frame;

126 fail:

127 ff_hevc_unref_frame(s, frame, ~0);

128 return NULL;

129 }

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

131 return NULL;

132 }

133

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

135 {

136 HEVCFrame *ref;

137 int i;

138

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

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

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

142

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

144 frame->poc == poc) {

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

146 poc);

147 return AVERROR_INVALIDDATA;

148 }

149 }

150

151 ref = alloc_frame(s);

152 if (!ref)

153 return AVERROR(ENOMEM);

154

155 *frame = ref->frame;

156 s->ref = ref;

157

158 if (s->sh.pic_output_flag)

159 ref->flags = HEVC_FRAME_FLAG_OUTPUT | HEVC_FRAME_FLAG_SHORT_REF;

160 else

161 ref->flags = HEVC_FRAME_FLAG_SHORT_REF;

162

163 ref->poc = poc;

164 ref->sequence = s->seq_decode;

165 ref->window = s->ps.sps->output_window;

166

167 return 0;

168 }

169

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

171 {

172 do {

173 int nb_output = 0;

174 int min_poc = INT_MAX;

175 int i, min_idx, ret;

176

177 if (s->sh.no_output_of_prior_pics_flag == 1 && s->no_rasl_output_flag == 1) {

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

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

180 if (!(frame->flags & HEVC_FRAME_FLAG_BUMPING) && frame->poc != s->poc &&

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

182 ff_hevc_unref_frame(s, frame, HEVC_FRAME_FLAG_OUTPUT);

183 }

184 }

185 }

186

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

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

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

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

191 nb_output++;

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

193 min_poc = frame->poc;

194 min_idx = i;

195 }

196 }

197 }

198

199 /* wait for more frames before output */

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

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

202 return 0;

203

204 if (nb_output) {

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

206 AVFrame *dst = out;

207 AVFrame *src = frame->frame;

208 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(src->format);

209 int pixel_shift = !!(desc->comp[0].depth > 8);

210

211 ret = av_frame_ref(out, src);

212 if (frame->flags & HEVC_FRAME_FLAG_BUMPING)

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

214 else

215 ff_hevc_unref_frame(s, frame, HEVC_FRAME_FLAG_OUTPUT);

216 if (ret < 0)

217 return ret;

218

219 for (i = 0; i < 3; i++) {

220 int hshift = (i > 0) ? desc->log2_chroma_w : 0;

221 int vshift = (i > 0) ? desc->log2_chroma_h : 0;

222 int off = ((frame->window.left_offset >> hshift) << pixel_shift) +

223 (frame->window.top_offset >> vshift) * dst->linesize[i];

224 dst->data[i] += off;

225 }

226 av_log(s->avctx, AV_LOG_DEBUG,

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

228 return 1;

229 }

230

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

232 s->seq_output = (s->seq_output + 1) & 0xff;

233 else

234 break;

235 } while (1);

236

237 return 0;

238 }

239

240 void ff_hevc_bump_frame(HEVCContext *s)

241 {

242 int dpb = 0;

243 int min_poc = INT_MAX;

244 int i;

245

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

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

248 if ((frame->flags) &&

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

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

251 dpb++;

252 }

253 }

254

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

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

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

258 if ((frame->flags) &&

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

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

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

262 min_poc = frame->poc;

263 }

264 }

265 }

266

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

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

269 if (frame->flags & HEVC_FRAME_FLAG_OUTPUT &&

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

271 frame->poc <= min_poc) {

272 frame->flags |= HEVC_FRAME_FLAG_BUMPING;

273 }

274 }

275

276 dpb--;

277 }

278 }

279

280 static int init_slice_rpl(HEVCContext *s)

281 {

282 HEVCFrame *frame = s->ref;

283 int ctb_count = frame->ctb_count;

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

285 int i;

286

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

288 return AVERROR_INVALIDDATA;

289

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

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

292

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

294

295 return 0;

296 }

297

298 int ff_hevc_slice_rpl(HEVCContext *s)

299 {

300 SliceHeader *sh = &s->sh;

301

302 uint8_t nb_list = sh->slice_type == B_SLICE ? 2 : 1;

303 uint8_t list_idx;

304 int i, j, ret;

305

306 ret = init_slice_rpl(s);

307 if (ret < 0)

308 return ret;

309

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

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

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

313 return AVERROR_INVALIDDATA;

314 }

315

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

317 RefPicList rpl_tmp = { { 0 } };

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

319

320 /* The order of the elements is

321 * ST_CURR_BEF - ST_CURR_AFT - LT_CURR for the L0 and

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

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

324 list_idx ? ST_CURR_BEF : ST_CURR_AFT,

325 LT_CURR };

326

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

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

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

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

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

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

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

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

335 rpl_tmp.nb_refs++;

336 }

337 }

338 }

339

340 /* reorder the references if necessary */

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

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

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

344

345 if (idx >= rpl_tmp.nb_refs) {

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

347 return AVERROR_INVALIDDATA;

348 }

349

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

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

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

353 rpl->nb_refs++;

354 }

355 } else {

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

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

358 }

359

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

361 sh->collocated_ref_idx < rpl->nb_refs)

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

363 }

364

365 return 0;

366 }

367

368 static HEVCFrame *find_ref_idx(HEVCContext *s, int poc)

369 {

370 int i;

371 int LtMask = (1 << s->ps.sps->log2_max_poc_lsb) - 1;

372

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

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

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

376 if ((ref->poc & LtMask) == poc)

377 return ref;

378 }

379 }

380

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

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

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

384 if (ref->poc == poc || (ref->poc & LtMask) == poc)

385 return ref;

386 }

387 }

388

389 if (s->nal_unit_type != NAL_CRA_NUT && !IS_BLA(s))

390 av_log(s->avctx, AV_LOG_ERROR,

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

392 return NULL;

393 }

394

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

396 {

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

398 frame->flags |= flag;

399 }

400

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

402 {

403 HEVCFrame *frame;

404 int i, x, y;

405

406 frame = alloc_frame(s);

407 if (!frame)

408 return NULL;

409

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

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

412 for (i = 0; frame->frame->buf[i]; i++)

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

414 frame->frame->buf[i]->size);

415 } else {

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

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

418 for (x = 0; x < (s->ps.sps->width >> s->ps.sps->hshift[i]); x++) {

419 AV_WN16(frame->frame->data[i] + y * frame->frame->linesize[i] + 2 * x,

420 1 << (s->ps.sps->bit_depth - 1));

421 }

422 }

423 }

424

425 frame->poc = poc;

426 frame->sequence = s->seq_decode;

427 frame->flags = 0;

428

429 if (s->threads_type == FF_THREAD_FRAME)

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

431

432 return frame;

433 }

434

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

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

437 int poc, int ref_flag)

438 {

439 HEVCFrame *ref = find_ref_idx(s, poc);

440

441 if (ref == s->ref)

442 return AVERROR_INVALIDDATA;

443

444 if (!ref) {

445 ref = generate_missing_ref(s, poc);

446 if (!ref)

447 return AVERROR(ENOMEM);

448 }

449

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

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

452 list->nb_refs++;

453

454 mark_ref(ref, ref_flag);

455 return 0;

456 }

457

458 int ff_hevc_frame_rps(HEVCContext *s)

459 {

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

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

462 RefPicList *rps = s->rps;

463 int i, ret = 0;

464

465 if (!short_rps) {

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

467 return 0;

468 }

469

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

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

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

473

474 if (frame == s->ref)

475 continue;

476

477 mark_ref(frame, 0);

478 }

479

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

481 rps[i].nb_refs = 0;

482

483 /* add the short refs */

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

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

486 int list;

487

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

489 list = ST_FOLL;

490 else if (i < short_rps->num_negative_pics)

491 list = ST_CURR_BEF;

492 else

493 list = ST_CURR_AFT;

494

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

496 if (ret < 0)

497 goto fail;

498 }

499

500 /* add the long refs */

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

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

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

504

505 ret = add_candidate_ref(s, &rps[list], poc, HEVC_FRAME_FLAG_LONG_REF);

506 if (ret < 0)

507 goto fail;

508 }

509

510 fail:

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

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

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

514

515 return ret;

516 }

517

518 int ff_hevc_compute_poc(HEVCContext *s, int poc_lsb)

519 {

520 int max_poc_lsb = 1 << s->ps.sps->log2_max_poc_lsb;

521 int prev_poc_lsb = s->pocTid0 % max_poc_lsb;

522 int prev_poc_msb = s->pocTid0 - prev_poc_lsb;

523 int poc_msb;

524

525 if (poc_lsb < prev_poc_lsb && prev_poc_lsb - poc_lsb >= max_poc_lsb / 2)

526 poc_msb = prev_poc_msb + max_poc_lsb;

527 else if (poc_lsb > prev_poc_lsb && poc_lsb - prev_poc_lsb > max_poc_lsb / 2)

528 poc_msb = prev_poc_msb - max_poc_lsb;

529 else

530 poc_msb = prev_poc_msb;

531

532 // For BLA picture types, POCmsb is set to 0.

533 if (s->nal_unit_type == NAL_BLA_W_LP ||

534 s->nal_unit_type == NAL_BLA_W_RADL ||

535 s->nal_unit_type == NAL_BLA_N_LP)

536 poc_msb = 0;

537

538 return poc_msb + poc_lsb;

539 }

540

541 int ff_hevc_frame_nb_refs(HEVCContext *s)

542 {

543 int ret = 0;

544 int i;

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

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

547

548 if (rps) {

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

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

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

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

553 }

554

555 if (long_rps) {

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

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

558 }

559 return ret;

560 }

HEVCParamSets::pps

const HEVCPPS * pps

Definition: hevc.h:569

HEVCFrame::frame

AVFrame * frame

Definition: hevc.h:719

NULL

#define NULL

Definition: coverity.c:32

const char * s

Definition: avisynth_c.h:631

AVERROR_INVALIDDATA

#define AVERROR_INVALIDDATA

Invalid data found when processing input.

Definition: error.h:59

ST_CURR_AFT

Definition: hevc.h:123

LT_FOLL

Definition: hevc.h:126

ST_CURR_BEF

Definition: hevc.h:122

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

av_pix_fmt_desc_get

const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)

Definition: pixdesc.c:2157

AVFrame

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

Definition: frame.h:181

HEVCContext::ref

HEVCFrame * ref

Definition: hevc.h:857

MvField

Definition: hevc.h:667

HEVCSPS::ctb_height

int ctb_height

Definition: hevc.h:471

flush

static void flush(AVCodecContext *avctx)

Definition: aacdec_template.c:496

HEVCSPS::max_dec_pic_buffering

int max_dec_pic_buffering

Definition: hevc.h:418

ff_hevc_set_new_ref

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

Definition: hevc_refs.c:134

AVFrame::buf

AVBufferRef * buf[AV_NUM_DATA_POINTERS]

AVBuffer references backing the data for this frame.

Definition: frame.h:357

HEVCFrame::hwaccel_picture_private

void * hwaccel_picture_private

Definition: hevc.h:735

MAX_REFS

#define MAX_REFS

Definition: hevc.h:40

LongTermRPS::nb_refs

uint8_t nb_refs

Definition: hevc.h:287

HEVCFrame::tab_mvf

MvField * tab_mvf

Definition: hevc.h:721

HEVCSPS::vshift

int vshift[3]

Definition: hevc.h:482

ff_hevc_flush_dpb

void ff_hevc_flush_dpb(HEVCContext *s)

Drop all frames currently in DPB.

Definition: hevc_refs.c:74

ff_hevc_frame_rps

int ff_hevc_frame_rps(HEVCContext *s)

Construct the reference picture sets for the current frame.

Definition: hevc_refs.c:458

HEVCWindow::left_offset

unsigned int left_offset

Definition: hevc.h:302

RefPicList::isLongTerm

int isLongTerm[MAX_REFS]

Definition: hevc.h:293

NAL_CRA_NUT

Definition: hevc.h:109

HEVCContext::ps

HEVCParamSets ps

Definition: hevc.h:844

find_ref_idx

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

Definition: hevc_refs.c:368

RefPicList::ref

struct HEVCFrame * ref[MAX_REFS]

Definition: hevc.h:291

RefPicList::list

int list[MAX_REFS]

Definition: hevc.h:292

NB_RPS_TYPE

Definition: hevc.h:127

HEVCSPS::width

int width

Definition: hevc.h:468

AVPixFmtDescriptor::log2_chroma_w

uint8_t log2_chroma_w

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

Definition: pixdesc.h:92

HEVCContext::seq_decode

uint16_t seq_decode

Sequence counters for decoded and output frames, so that old frames are output first after a POC rese...

Definition: hevc.h:901

ShortTermRPS

Definition: hevc.h:276

HEVCContext::threads_type

uint8_t threads_type

Definition: hevc.h:828

HEVCSPS::pixel_shift

int pixel_shift

Definition: hevc.h:410

HEVCSPS::output_window

HEVCWindow output_window

Definition: hevc.h:405

alloc_frame

static HEVCFrame * alloc_frame(HEVCContext *s)

Definition: hevc_refs.c:81

HEVCContext::rpl_tab_pool

AVBufferPool * rpl_tab_pool

candidate references for the current frame

Definition: hevc.h:847

AVCodecContext::hwaccel

struct AVHWAccel * hwaccel

Hardware accelerator in use.

Definition: avcodec.h:2843

RefPicList::nb_refs

int nb_refs

Definition: hevc.h:294

av_assert0

#define av_assert0(cond)

assert() equivalent, that is always enabled.

Definition: avassert.h:37

SliceHeader::slice_segment_addr

unsigned int slice_segment_addr

address (in raster order) of the first block in the current slice

Definition: hevc.h:576

HEVCContext::pkt

HEVCPacket pkt

Definition: hevc.h:909

ff_hevc_unref_frame

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

Definition: hevc_refs.c:31

ShortTermRPS::num_negative_pics

unsigned int num_negative_pics

Definition: hevc.h:277

AVPixFmtDescriptor::comp

AVComponentDescriptor comp[4]

Parameters that describe how pixels are packed.

Definition: pixdesc.h:117

uint8_t

Definition: audio_convert.c:194

SliceHeader::long_term_rps

LongTermRPS long_term_rps

Definition: hevc.h:595

LongTermRPS::poc

int poc[32]

Definition: hevc.h:285

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

HEVCContext::avctx

AVCodecContext * avctx

Definition: hevc.h:821

frame

static AVFrame * frame

Definition: demuxing_decoding.c:53

HEVCContext

Definition: hevc.h:819

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

HEVCFrame::tf

ThreadFrame tf

Definition: hevc.h:720

AVFrame::interlaced_frame

int interlaced_frame

The content of the picture is interlaced.

Definition: frame.h:312

NAL_BLA_W_LP

Definition: hevc.h:104

SliceHeader::pic_output_flag

uint8_t pic_output_flag

Definition: hevc.h:586

av_log

#define av_log(a,...)

Definition: tableprint_vlc.h:28

LongTermRPS::used

uint8_t used[32]

Definition: hevc.h:286

flag

int flag

Definition: checkasm.c:115

HEVCFrame::ctb_count

int ctb_count

Definition: hevc.h:724

SliceHeader::no_output_of_prior_pics_flag

uint8_t no_output_of_prior_pics_flag

Definition: hevc.h:599

HEVC_FRAME_FLAG_LONG_REF

#define HEVC_FRAME_FLAG_LONG_REF

Definition: hevc.h:715

HEVCContext::slice_idx

int slice_idx

number of the slice being currently decoded

Definition: hevc.h:861

mark_ref

static void mark_ref(HEVCFrame *frame, int flag)

Definition: hevc_refs.c:395

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:176

LT_CURR

Definition: hevc.h:125

HEVCSPS::log2_max_poc_lsb

unsigned int log2_max_poc_lsb

Definition: hevc.h:413

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

HEVCPacket::nb_nals

int nb_nals

Definition: hevc.h:772

ff_thread_release_buffer

void ff_thread_release_buffer(AVCodecContext *avctx, ThreadFrame *f)

Wrapper around release_buffer() frame-for multithreaded codecs.

Definition: pthread_frame.c:851

HEVCFrame::rpl_tab_buf

AVBufferRef * rpl_tab_buf

Definition: hevc.h:731

AVERROR

#define AVERROR(e)

Definition: error.h:43

SliceHeader::rpl_modification_flag

uint8_t rpl_modification_flag[2]

Definition: hevc.h:598

HEVCFrame::refPicList

RefPicList * refPicList

Definition: hevc.h:722

AV_PICTURE_STRUCTURE_BOTTOM_FIELD

Definition: avcodec.h:4417

AV_LOG_DEBUG

#define AV_LOG_DEBUG

Stuff which is only useful for libav* developers.

Definition: log.h:197

HEVCSPS::log2_ctb_size

unsigned int log2_ctb_size

Definition: hevc.h:454

LongTermRPS

Definition: hevc.h:284

HEVCContext::picture_struct

int picture_struct

Definition: hevc.h:939

avassert.h

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

SliceHeader::short_term_rps

const ShortTermRPS * short_term_rps

Definition: hevc.h:593

NAL_BLA_N_LP

Definition: hevc.h:106

fail

#define fail()

Definition: checkasm.h:80

HEVCFrame::sequence

uint16_t sequence

A sequence counter, so that old frames are output first after a POC reset.

Definition: hevc.h:741

ShortTermRPS::used

uint8_t used[32]

Definition: hevc.h:281

ff_hevc_compute_poc

int ff_hevc_compute_poc(HEVCContext *s, int poc_lsb)

Compute POC of the current frame and return it.

Definition: hevc_refs.c:518

HEVCParamSets::sps

const HEVCSPS * sps

Definition: hevc.h:568

AV_PICTURE_STRUCTURE_TOP_FIELD

Definition: avcodec.h:4416

HEVCFrame::tab_mvf_buf

AVBufferRef * tab_mvf_buf

Definition: hevc.h:730

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

SliceHeader

Definition: hevc.h:572

hevc.h

pixdesc.h

HEVC_FRAME_FLAG_SHORT_REF

#define HEVC_FRAME_FLAG_SHORT_REF

Definition: hevc.h:714

FF_THREAD_FRAME

#define FF_THREAD_FRAME

Decode more than one frame at once.

Definition: avcodec.h:2965

FFMIN

#define FFMIN(a, b)

Definition: common.h:96

HEVCFrame

Definition: hevc.h:718

HEVCWindow::top_offset

unsigned int top_offset

Definition: hevc.h:304

HEVCSPS::hshift

int hshift[3]

Definition: hevc.h:481

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

HEVCSPS::ctb_width

int ctb_width

Definition: hevc.h:470

HEVCFrame::collocated_ref

struct HEVCFrame * collocated_ref

Definition: hevc.h:726

ShortTermRPS::delta_poc

int32_t delta_poc[32]

Definition: hevc.h:280

HEVCSPS::height

int height

Definition: hevc.h:469

HEVCContext::seq_output

uint16_t seq_output

Definition: hevc.h:902

add_candidate_ref

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

Definition: hevc_refs.c:436

src

#define src

Definition: vp9dsp.c:530

FF_ARRAY_ELEMS

#define FF_ARRAY_ELEMS(a)

Definition: sinewin_tablegen_template.c:36

init_slice_rpl

static int init_slice_rpl(HEVCContext *s)

Definition: hevc_refs.c:280

IS_BLA

#define IS_BLA(s)

Definition: hevc.h:86

out

FILE * out

Definition: movenc-test.c:54

NAL_BLA_W_RADL

Definition: hevc.h:105

HEVCContext::DPB

HEVCFrame DPB[32]

Definition: hevc.h:858

generate_missing_ref

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

Definition: hevc_refs.c:401

AVFrame::format

int format

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

Definition: frame.h:242

HEVCFrame::rpl_tab

RefPicListTab ** rpl_tab

Definition: hevc.h:723

HEVC_FRAME_FLAG_OUTPUT

#define HEVC_FRAME_FLAG_OUTPUT

Definition: hevc.h:713

ff_hevc_clear_refs

void ff_hevc_clear_refs(HEVCContext *s)

Mark all frames in DPB as unused for reference.

Definition: hevc_refs.c:65

RefPicListTab

Definition: hevc.h:297

AVHWAccel

Definition: avcodec.h:3497

HEVCPPS::ctb_addr_rs_to_ts

int * ctb_addr_rs_to_ts

CtbAddrRSToTS.

Definition: hevc.h:553

AVFrame::linesize

int linesize[AV_NUM_DATA_POINTERS]

For video, size in bytes of each picture line.

Definition: frame.h:209

HEVCSPS::max_sub_layers

int max_sub_layers

Definition: hevc.h:416

AVPixFmtDescriptor

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

Definition: pixdesc.h:81

ff_thread_get_buffer

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

Wrapper around get_buffer() for frame-multithreaded codecs.

Definition: pthread_frame.c:843

HEVCFrame::hwaccel_priv_buf

AVBufferRef * hwaccel_priv_buf

Definition: hevc.h:734

AVBufferRef::data

uint8_t * data

The data buffer.

Definition: buffer.h:89

RefPicList

Definition: hevc.h:290

av_buffer_allocz

AVBufferRef * av_buffer_allocz(int size)

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

Definition: buffer.c:82

ff_hevc_bump_frame

void ff_hevc_bump_frame(HEVCContext *s)

Definition: hevc_refs.c:240

HEVCFrame::poc

int poc

Definition: hevc.h:725

HEVCContext::poc

int poc

Definition: hevc.h:859

HEVCContext::nal_unit_type

enum NALUnitType nal_unit_type

Definition: hevc.h:855

HEVCFrame::window

HEVCWindow window

Definition: hevc.h:728

HEVCSPS::temporal_layer

struct HEVCSPS::@52 temporal_layer[MAX_SUB_LAYERS]

HEVCContext::pocTid0

int pocTid0

Definition: hevc.h:860

HEVCFrame::flags

uint8_t flags

A combination of HEVC_FRAME_FLAG_*.

Definition: hevc.h:746

AVBufferRef::size

int size

Size of data in bytes.

Definition: buffer.h:93

ff_hevc_get_ref_list

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

Definition: hevc_refs.c:56

flags

static int flags

Definition: cpu.c:47

AVFrame::data

uint8_t * data[AV_NUM_DATA_POINTERS]

pointer to the picture/channel planes.

Definition: frame.h:192

internal.h

common internal api header.

SliceHeader::nb_refs

unsigned int nb_refs[2]

Definition: hevc.h:602

SliceHeader::collocated_list

uint8_t collocated_list

Definition: hevc.h:610

HEVCContext::tab_mvf_pool

AVBufferPool * tab_mvf_pool

Definition: hevc.h:846

ShortTermRPS::num_delta_pocs

int num_delta_pocs

Definition: hevc.h:278

HEVCContext::rps

RefPicList rps[5]

Definition: hevc.h:850

SliceHeader::collocated_ref_idx

unsigned int collocated_ref_idx

Definition: hevc.h:612

AVFrame::top_field_first

int top_field_first

If the content is interlaced, is top field displayed first.

Definition: frame.h:317

AVHWAccel::frame_priv_data_size

int frame_priv_data_size

Size of per-frame hardware accelerator private data.

Definition: avcodec.h:3594

ST_FOLL

Definition: hevc.h:124

SliceHeader::list_entry_lx

unsigned int list_entry_lx[2][32]

Definition: hevc.h:596

ff_hevc_frame_nb_refs

int ff_hevc_frame_nb_refs(HEVCContext *s)

Get the number of candidate references for the current frame.

Definition: hevc_refs.c:541

B_SLICE

Definition: hevc.h:131

HEVCSPS::num_reorder_pics

int num_reorder_pics

Definition: hevc.h:419

AV_WN16

#define AV_WN16(p, v)

Definition: intreadwrite.h:372

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

HEVCFrame::rpl_buf

AVBufferRef * rpl_buf

Definition: hevc.h:732

HEVCSPS::bit_depth

int bit_depth

Definition: hevc.h:409

SliceHeader::slice_type

enum SliceType slice_type

Definition: hevc.h:580

AVComponentDescriptor::depth

int depth

Number of bits in the component.

Definition: pixdesc.h:58

HEVC_FRAME_FLAG_BUMPING

#define HEVC_FRAME_FLAG_BUMPING

Definition: hevc.h:716

HEVCContext::sh

SliceHeader sh

Definition: hevc.h:852

HEVCContext::no_rasl_output_flag

int no_rasl_output_flag

Definition: hevc.h:869

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

for

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

Definition: h264pred_template.c:469

Generated on Mon Feb 15 2016 15:20:38 for FFmpeg by doxygen 1.8.6