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->sps->log2_ctb_size;

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

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

61 int ctb_addr_ts = s->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->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->sps->ctb_width * s->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->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) {

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->sps &&

201 nb_output <= s->sps->temporal_layer[s->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_minus1 > 7);

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->sps && dpb >= s->sps->temporal_layer[s->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->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->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 av_log(s->avctx, AV_LOG_ERROR,

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

391 return NULL;

392 }

393

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

395 {

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

397 frame->flags |= flag;

398 }

399

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

401 {

402 HEVCFrame *frame;

403 int i, x, y;

404

405 frame = alloc_frame(s);

406 if (!frame)

407 return NULL;

408

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

410 if (!s->sps->pixel_shift) {

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

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

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

414 } else {

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

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

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

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

419 1 << (s->sps->bit_depth - 1));

420 }

421 }

422 }

423

424 frame->poc = poc;

425 frame->sequence = s->seq_decode;

426 frame->flags = 0;

427

428 if (s->threads_type == FF_THREAD_FRAME)

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

430

431 return frame;

432 }

433

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

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

436 int poc, int ref_flag)

437 {

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

439

440 if (ref == s->ref)

441 return AVERROR_INVALIDDATA;

442

443 if (!ref) {

444 ref = generate_missing_ref(s, poc);

445 if (!ref)

446 return AVERROR(ENOMEM);

447 }

448

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

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

451 list->nb_refs++;

452

453 mark_ref(ref, ref_flag);

454 return 0;

455 }

456

457 int ff_hevc_frame_rps(HEVCContext *s)

458 {

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

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

461 RefPicList *rps = s->rps;

462 int i, ret = 0;

463

464 if (!short_rps) {

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

466 return 0;

467 }

468

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

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

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

472

473 if (frame == s->ref)

474 continue;

475

476 mark_ref(frame, 0);

477 }

478

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

480 rps[i].nb_refs = 0;

481

482 /* add the short refs */

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

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

485 int list;

486

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

488 list = ST_FOLL;

489 else if (i < short_rps->num_negative_pics)

490 list = ST_CURR_BEF;

491 else

492 list = ST_CURR_AFT;

493

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

495 if (ret < 0)

496 goto fail;

497 }

498

499 /* add the long refs */

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

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

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

503

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

505 if (ret < 0)

506 goto fail;

507 }

508

509 fail:

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

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

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

513

514 return ret;

515 }

516

517 int ff_hevc_compute_poc(HEVCContext *s, int poc_lsb)

518 {

519 int max_poc_lsb = 1 << s->sps->log2_max_poc_lsb;

520 int prev_poc_lsb = s->pocTid0 % max_poc_lsb;

521 int prev_poc_msb = s->pocTid0 - prev_poc_lsb;

522 int poc_msb;

523

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

525 poc_msb = prev_poc_msb + max_poc_lsb;

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

527 poc_msb = prev_poc_msb - max_poc_lsb;

528 else

529 poc_msb = prev_poc_msb;

530

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

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

533 s->nal_unit_type == NAL_BLA_W_RADL ||

534 s->nal_unit_type == NAL_BLA_N_LP)

535 poc_msb = 0;

536

537 return poc_msb + poc_lsb;

538 }

539

540 int ff_hevc_frame_nb_refs(HEVCContext *s)

541 {

542 int ret = 0;

543 int i;

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

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

546

547 if (rps) {

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

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

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

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

552 }

553

554 if (long_rps) {

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

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

557 }

558 return ret;

559 }

Generated on Sun Mar 8 2015 02:34:53 for FFmpeg by doxygen 1.8.2