FFmpeg: libavcodec/h264_refs.c Source File

FFmpeg

[フレーム]

libavcodec

h264_refs.c

Go to the documentation of this file.

1 /*

2 * H.26L/H.264/AVC/JVT/14496-10/... reference picture handling

4 *

5 * This file is part of FFmpeg.

6 *

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

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

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

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

11 *

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

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

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

15 * Lesser General Public License for more details.

16 *

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

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

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

20 */

22 /**

23 * @file

24 * H.264 / AVC / MPEG-4 part10 reference picture handling.

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

26 */

28 #include <inttypes.h>

30 #include "libavutil/avassert.h"

31 #include "internal.h"

32 #include "avcodec.h"

33 #include "h264.h"

34 #include "h264dec.h"

35 #include "golomb.h"

36 #include "mpegutils.h"

38 #include <assert.h>

40 static void pic_as_field(H264Ref *pic, const int parity)

41 {

42 int i;

43 for (i = 0; i < FF_ARRAY_ELEMS(pic->data); ++i) {

44 if (parity == PICT_BOTTOM_FIELD)

45 pic->data[i] += pic->linesize[i];

46 pic->reference = parity;

47 pic->linesize[i] *= 2;

48 }

49 pic->poc = pic->parent->field_poc[parity == PICT_BOTTOM_FIELD];

50 }

52 static void ref_from_h264pic(H264Ref *dst, H264Picture *src)

53 {

54 memcpy(dst->data, src->f->data, sizeof(dst->data));

55 memcpy(dst->linesize, src->f->linesize, sizeof(dst->linesize));

56 dst->reference = src->reference;

57 dst->poc = src->poc;

58 dst->pic_id = src->pic_id;

59 dst->parent = src;

60 }

62 static int split_field_copy(H264Ref *dest, H264Picture *src, int parity, int id_add)

63 {

64 int match = !!(src->reference & parity);

66 if (match) {

67 ref_from_h264pic(dest, src);

68 if (parity != PICT_FRAME) {

69 pic_as_field(dest, parity);

70 dest->pic_id *= 2;

71 dest->pic_id += id_add;

72 }

73 }

75 return match;

76 }

78 static int build_def_list(H264Ref *def, int def_len,

79 H264Picture * const *in, int len, int is_long, int sel)

80 {

81 int i[2] = { 0 };

82 int index = 0;

84 while (i[0] < len || i[1] < len) {

85 while (i[0] < len && !(in[i[0]] && (in[i[0]]->reference & sel)))

86 i[0]++;

87 while (i[1] < len && !(in[i[1]] && (in[i[1]]->reference & (sel ^ 3))))

88 i[1]++;

89 if (i[0] < len) {

90 av_assert0(index < def_len);

91 in[i[0]]->pic_id = is_long ? i[0] : in[i[0]]->frame_num;

92 split_field_copy(&def[index++], in[i[0]++], sel, 1);

93 }

94 if (i[1] < len) {

95 av_assert0(index < def_len);

96 in[i[1]]->pic_id = is_long ? i[1] : in[i[1]]->frame_num;

97 split_field_copy(&def[index++], in[i[1]++], sel ^ 3, 0);

98 }

99 }

100

101 return index;

102 }

103

104 static int add_sorted(H264Picture **sorted, H264Picture * const *src,

105 int len, int limit, int dir)

106 {

107 int i, best_poc;

108 int out_i = 0;

109

110 for (;;) {

111 best_poc = dir ? INT_MIN : INT_MAX;

112

113 for (i = 0; i < len; i++) {

114 const int poc = src[i]->poc;

115 if (((poc > limit) ^ dir) && ((poc < best_poc) ^ dir)) {

116 best_poc = poc;

117 sorted[out_i] = src[i];

118 }

119 }

120 if (best_poc == (dir ? INT_MIN : INT_MAX))

121 break;

122 limit = sorted[out_i++]->poc - dir;

123 }

124 return out_i;

125 }

126

127 static int mismatches_ref(const H264Context *h, const H264Picture *pic)

128 {

129 const AVFrame *f = pic->f;

130 return (h->cur_pic_ptr->f->width != f->width ||

131 h->cur_pic_ptr->f->height != f->height ||

132 h->cur_pic_ptr->f->format != f->format);

133 }

134

135 static void h264_initialise_ref_list(H264Context *h, H264SliceContext *sl)

136 {

137 int i, len;

138 int j;

139

140 if (sl->slice_type_nos == AV_PICTURE_TYPE_B) {

141 H264Picture *sorted[32];

142 int cur_poc, list;

143 int lens[2];

144

145 if (FIELD_PICTURE(h))

146 cur_poc = h->cur_pic_ptr->field_poc[h->picture_structure == PICT_BOTTOM_FIELD];

147 else

148 cur_poc = h->cur_pic_ptr->poc;

149

150 for (list = 0; list < 2; list++) {

151 len = add_sorted(sorted, h->short_ref, h->short_ref_count, cur_poc, 1 ^ list);

152 len += add_sorted(sorted + len, h->short_ref, h->short_ref_count, cur_poc, 0 ^ list);

153 av_assert0(len <= 32);

154

155 len = build_def_list(sl->ref_list[list], FF_ARRAY_ELEMS(sl->ref_list[0]),

156 sorted, len, 0, h->picture_structure);

157 len += build_def_list(sl->ref_list[list] + len,

158 FF_ARRAY_ELEMS(sl->ref_list[0]) - len,

159 h->long_ref, 16, 1, h->picture_structure);

160 av_assert0(len <= 32);

161

162 if (len < sl->ref_count[list])

163 memset(&sl->ref_list[list][len], 0, sizeof(H264Ref) * (sl->ref_count[list] - len));

164 lens[list] = len;

165 }

166

167 if (lens[0] == lens[1] && lens[1] > 1) {

168 for (i = 0; i < lens[0] &&

169 sl->ref_list[0][i].parent->f->buf[0]->buffer ==

170 sl->ref_list[1][i].parent->f->buf[0]->buffer; i++);

171 if (i == lens[0]) {

172 FFSWAP(H264Ref, sl->ref_list[1][0], sl->ref_list[1][1]);

173 }

174 }

175 } else {

176 len = build_def_list(sl->ref_list[0], FF_ARRAY_ELEMS(sl->ref_list[0]),

177 h->short_ref, h->short_ref_count, 0, h->picture_structure);

178 len += build_def_list(sl->ref_list[0] + len,

179 FF_ARRAY_ELEMS(sl->ref_list[0]) - len,

180 h-> long_ref, 16, 1, h->picture_structure);

181 av_assert0(len <= 32);

182

183 if (len < sl->ref_count[0])

184 memset(&sl->ref_list[0][len], 0, sizeof(H264Ref) * (sl->ref_count[0] - len));

185 }

186 #ifdef TRACE

187 for (i = 0; i < sl->ref_count[0]; i++) {

188 ff_tlog(h->avctx, "List0: %s fn:%d 0x%p\n",

189 (sl->ref_list[0][i].parent ? (sl->ref_list[0][i].parent->long_ref ? "LT" : "ST") : "??"),

190 sl->ref_list[0][i].pic_id,

191 sl->ref_list[0][i].data[0]);

192 }

193 if (sl->slice_type_nos == AV_PICTURE_TYPE_B) {

194 for (i = 0; i < sl->ref_count[1]; i++) {

195 ff_tlog(h->avctx, "List1: %s fn:%d 0x%p\n",

196 (sl->ref_list[1][i].parent ? (sl->ref_list[1][i].parent->long_ref ? "LT" : "ST") : "??"),

197 sl->ref_list[1][i].pic_id,

198 sl->ref_list[1][i].data[0]);

199 }

200 }

201 #endif

202

203 for (j = 0; j<1+(sl->slice_type_nos == AV_PICTURE_TYPE_B); j++) {

204 for (i = 0; i < sl->ref_count[j]; i++) {

205 if (sl->ref_list[j][i].parent) {

206 if (mismatches_ref(h, sl->ref_list[j][i].parent)) {

207 av_log(h->avctx, AV_LOG_ERROR, "Discarding mismatching reference\n");

208 memset(&sl->ref_list[j][i], 0, sizeof(sl->ref_list[j][i]));

209 }

210 }

211 }

212 }

213 for (i = 0; i < sl->list_count; i++)

214 h->default_ref[i] = sl->ref_list[i][0];

215 }

216

217 /**

218 * print short term list

219 */

220 static void print_short_term(const H264Context *h)

221 {

222 uint32_t i;

223 if (h->avctx->debug & FF_DEBUG_MMCO) {

224 av_log(h->avctx, AV_LOG_DEBUG, "short term list:\n");

225 for (i = 0; i < h->short_ref_count; i++) {

226 H264Picture *pic = h->short_ref[i];

227 av_log(h->avctx, AV_LOG_DEBUG, "%"PRIu32" fn:%d poc:%d %p\n",

228 i, pic->frame_num, pic->poc, pic->f->data[0]);

229 }

230 }

231 }

232

233 /**

234 * print long term list

235 */

236 static void print_long_term(const H264Context *h)

237 {

238 uint32_t i;

239 if (h->avctx->debug & FF_DEBUG_MMCO) {

240 av_log(h->avctx, AV_LOG_DEBUG, "long term list:\n");

241 for (i = 0; i < 16; i++) {

242 H264Picture *pic = h->long_ref[i];

243 if (pic) {

244 av_log(h->avctx, AV_LOG_DEBUG, "%"PRIu32" fn:%d poc:%d %p\n",

245 i, pic->frame_num, pic->poc, pic->f->data[0]);

246 }

247 }

248 }

249 }

250

251 /**

252 * Extract structure information about the picture described by pic_num in

253 * the current decoding context (frame or field). Note that pic_num is

254 * picture number without wrapping (so, 0<=pic_num<max_pic_num).

255 * @param pic_num picture number for which to extract structure information

256 * @param structure one of PICT_XXX describing structure of picture

257 * with pic_num

258 * @return frame number (short term) or long term index of picture

259 * described by pic_num

260 */

261 static int pic_num_extract(const H264Context *h, int pic_num, int *structure)

262 {

263 *structure = h->picture_structure;

264 if (FIELD_PICTURE(h)) {

265 if (!(pic_num & 1))

266 /* opposite field */

267 *structure ^= PICT_FRAME;

268 pic_num >>= 1;

269 }

270

271 return pic_num;

272 }

273

274 static void h264_fill_mbaff_ref_list(H264SliceContext *sl)

275 {

276 int list, i, j;

277 for (list = 0; list < sl->list_count; list++) {

278 for (i = 0; i < sl->ref_count[list]; i++) {

279 H264Ref *frame = &sl->ref_list[list][i];

280 H264Ref *field = &sl->ref_list[list][16 + 2 * i];

281

282 field[0] = *frame;

283

284 for (j = 0; j < 3; j++)

285 field[0].linesize[j] <<= 1;

286 field[0].reference = PICT_TOP_FIELD;

287 field[0].poc = field[0].parent->field_poc[0];

288

289 field[1] = field[0];

290

291 for (j = 0; j < 3; j++)

292 field[1].data[j] += frame->parent->f->linesize[j];

293 field[1].reference = PICT_BOTTOM_FIELD;

294 field[1].poc = field[1].parent->field_poc[1];

295 }

296 }

297 }

298

299 int ff_h264_build_ref_list(H264Context *h, H264SliceContext *sl)

300 {

301 int list, index, pic_structure;

302

303 print_short_term(h);

304 print_long_term(h);

305

306 h264_initialise_ref_list(h, sl);

307

308 for (list = 0; list < sl->list_count; list++) {

309 int pred = sl->curr_pic_num;

310

311 for (index = 0; index < sl->nb_ref_modifications[list]; index++) {

312 unsigned int modification_of_pic_nums_idc = sl->ref_modifications[list][index].op;

313 unsigned int val = sl->ref_modifications[list][index].val;

314 unsigned int pic_id;

315 int i;

316 H264Picture *ref = NULL;

317

318 switch (modification_of_pic_nums_idc) {

319 case 0:

320 case 1: {

321 const unsigned int abs_diff_pic_num = val + 1;

322 int frame_num;

323

324 if (abs_diff_pic_num > sl->max_pic_num) {

325 av_log(h->avctx, AV_LOG_ERROR,

326 "abs_diff_pic_num overflow\n");

327 return AVERROR_INVALIDDATA;

328 }

329

330 if (modification_of_pic_nums_idc == 0)

331 pred -= abs_diff_pic_num;

332 else

333 pred += abs_diff_pic_num;

334 pred &= sl->max_pic_num - 1;

335

336 frame_num = pic_num_extract(h, pred, &pic_structure);

337

338 for (i = h->short_ref_count - 1; i >= 0; i--) {

339 ref = h->short_ref[i];

340 assert(ref->reference);

341 assert(!ref->long_ref);

342 if (ref->frame_num == frame_num &&

343 (ref->reference & pic_structure))

344 break;

345 }

346 if (i >= 0)

347 ref->pic_id = pred;

348 break;

349 }

350 case 2: {

351 int long_idx;

352 pic_id = val; // long_term_pic_idx

353

354 long_idx = pic_num_extract(h, pic_id, &pic_structure);

355

356 if (long_idx > 31U) {

357 av_log(h->avctx, AV_LOG_ERROR,

358 "long_term_pic_idx overflow\n");

359 return AVERROR_INVALIDDATA;

360 }

361 ref = h->long_ref[long_idx];

362 assert(!(ref && !ref->reference));

363 if (ref && (ref->reference & pic_structure)) {

364 ref->pic_id = pic_id;

365 assert(ref->long_ref);

366 i = 0;

367 } else {

368 i = -1;

369 }

370 break;

371 }

372 default:

373 av_assert0(0);

374 }

375

376 if (i < 0 || mismatches_ref(h, ref)) {

377 av_log(h->avctx, AV_LOG_ERROR,

378 i < 0 ? "reference picture missing during reorder\n" :

379 "mismatching reference\n"

380 );

381 memset(&sl->ref_list[list][index], 0, sizeof(sl->ref_list[0][0])); // FIXME

382 } else {

383 for (i = index; i + 1 < sl->ref_count[list]; i++) {

384 if (sl->ref_list[list][i].parent &&

385 ref->long_ref == sl->ref_list[list][i].parent->long_ref &&

386 ref->pic_id == sl->ref_list[list][i].pic_id)

387 break;

388 }

389 for (; i > index; i--) {

390 sl->ref_list[list][i] = sl->ref_list[list][i - 1];

391 }

392 ref_from_h264pic(&sl->ref_list[list][index], ref);

393 if (FIELD_PICTURE(h)) {

394 pic_as_field(&sl->ref_list[list][index], pic_structure);

395 }

396 }

397 }

398 }

399 for (list = 0; list < sl->list_count; list++) {

400 for (index = 0; index < sl->ref_count[list]; index++) {

401 if ( !sl->ref_list[list][index].parent

402 || (!FIELD_PICTURE(h) && (sl->ref_list[list][index].reference&3) != 3)) {

403 int i;

404 av_log(h->avctx, AV_LOG_ERROR, "Missing reference picture, default is %d\n", h->default_ref[list].poc);

405 for (i = 0; i < FF_ARRAY_ELEMS(h->last_pocs); i++)

406 h->last_pocs[i] = INT_MIN;

407 if (h->default_ref[list].parent

408 && !(!FIELD_PICTURE(h) && (h->default_ref[list].reference&3) != 3))

409 sl->ref_list[list][index] = h->default_ref[list];

410 else

411 return -1;

412 }

413 av_assert0(av_buffer_get_ref_count(sl->ref_list[list][index].parent->f->buf[0]) > 0);

414 }

415 }

416

417 if (FRAME_MBAFF(h))

418 h264_fill_mbaff_ref_list(sl);

419

420 return 0;

421 }

422

423 int ff_h264_decode_ref_pic_list_reordering(H264SliceContext *sl, void *logctx)

424 {

425 int list, index;

426

427 sl->nb_ref_modifications[0] = 0;

428 sl->nb_ref_modifications[1] = 0;

429

430 for (list = 0; list < sl->list_count; list++) {

431 if (!get_bits1(&sl->gb)) // ref_pic_list_modification_flag_l[01]

432 continue;

433

434 for (index = 0; ; index++) {

435 unsigned int op = get_ue_golomb_31(&sl->gb);

436

437 if (op == 3)

438 break;

439

440 if (index >= sl->ref_count[list]) {

441 av_log(logctx, AV_LOG_ERROR, "reference count overflow\n");

442 return AVERROR_INVALIDDATA;

443 } else if (op > 2) {

444 av_log(logctx, AV_LOG_ERROR,

445 "illegal modification_of_pic_nums_idc %u\n",

446 op);

447 return AVERROR_INVALIDDATA;

448 }

449 sl->ref_modifications[list][index].val = get_ue_golomb_long(&sl->gb);

450 sl->ref_modifications[list][index].op = op;

451 sl->nb_ref_modifications[list]++;

452 }

453 }

454

455 return 0;

456 }

457

458 /**

459 * Mark a picture as no longer needed for reference. The refmask

460 * argument allows unreferencing of individual fields or the whole frame.

461 * If the picture becomes entirely unreferenced, but is being held for

462 * display purposes, it is marked as such.

463 * @param refmask mask of fields to unreference; the mask is bitwise

464 * anded with the reference marking of pic

465 * @return non-zero if pic becomes entirely unreferenced (except possibly

466 * for display purposes) zero if one of the fields remains in

467 * reference

468 */

469 static inline int unreference_pic(H264Context *h, H264Picture *pic, int refmask)

470 {

471 int i;

472 if (pic->reference &= refmask) {

473 return 0;

474 } else {

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

476 if(pic == h->delayed_pic[i]){

477 pic->reference = DELAYED_PIC_REF;

478 break;

479 }

480 return 1;

481 }

482 }

483

484 /**

485 * Find a H264Picture in the short term reference list by frame number.

486 * @param frame_num frame number to search for

487 * @param idx the index into h->short_ref where returned picture is found

488 * undefined if no picture found.

489 * @return pointer to the found picture, or NULL if no pic with the provided

490 * frame number is found

491 */

492 static H264Picture *find_short(H264Context *h, int frame_num, int *idx)

493 {

494 int i;

495

496 for (i = 0; i < h->short_ref_count; i++) {

497 H264Picture *pic = h->short_ref[i];

498 if (h->avctx->debug & FF_DEBUG_MMCO)

499 av_log(h->avctx, AV_LOG_DEBUG, "%d %d %p\n", i, pic->frame_num, pic);

500 if (pic->frame_num == frame_num) {

501 *idx = i;

502 return pic;

503 }

504 }

505 return NULL;

506 }

507

508 /**

509 * Remove a picture from the short term reference list by its index in

510 * that list. This does no checking on the provided index; it is assumed

511 * to be valid. Other list entries are shifted down.

512 * @param i index into h->short_ref of picture to remove.

513 */

514 static void remove_short_at_index(H264Context *h, int i)

515 {

516 assert(i >= 0 && i < h->short_ref_count);

517 h->short_ref[i] = NULL;

518 if (--h->short_ref_count)

519 memmove(&h->short_ref[i], &h->short_ref[i + 1],

520 (h->short_ref_count - i) * sizeof(H264Picture*));

521 }

522

523 /**

524 * @return the removed picture or NULL if an error occurs

525 */

526 static H264Picture *remove_short(H264Context *h, int frame_num, int ref_mask)

527 {

528 H264Picture *pic;

529 int i;

530

531 if (h->avctx->debug & FF_DEBUG_MMCO)

532 av_log(h->avctx, AV_LOG_DEBUG, "remove short %d count %d\n", frame_num, h->short_ref_count);

533

534 pic = find_short(h, frame_num, &i);

535 if (pic) {

536 if (unreference_pic(h, pic, ref_mask))

537 remove_short_at_index(h, i);

538 }

539

540 return pic;

541 }

542

543 /**

544 * Remove a picture from the long term reference list by its index in

545 * that list.

546 * @return the removed picture or NULL if an error occurs

547 */

548 static H264Picture *remove_long(H264Context *h, int i, int ref_mask)

549 {

550 H264Picture *pic;

551

552 pic = h->long_ref[i];

553 if (pic) {

554 if (unreference_pic(h, pic, ref_mask)) {

555 assert(h->long_ref[i]->long_ref == 1);

556 h->long_ref[i]->long_ref = 0;

557 h->long_ref[i] = NULL;

558 h->long_ref_count--;

559 }

560 }

561

562 return pic;

563 }

564

565 void ff_h264_remove_all_refs(H264Context *h)

566 {

567 int i;

568

569 for (i = 0; i < 16; i++) {

570 remove_long(h, i, 0);

571 }

572 assert(h->long_ref_count == 0);

573

574 if (h->short_ref_count && !h->last_pic_for_ec.f->data[0]) {

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

576 ff_h264_ref_picture(h, &h->last_pic_for_ec, h->short_ref[0]);

577 }

578

579 for (i = 0; i < h->short_ref_count; i++) {

580 unreference_pic(h, h->short_ref[i], 0);

581 h->short_ref[i] = NULL;

582 }

583 h->short_ref_count = 0;

584

585 memset(h->default_ref, 0, sizeof(h->default_ref));

586 }

587

588 static void generate_sliding_window_mmcos(H264Context *h)

589 {

590 MMCO *mmco = h->mmco;

591 int nb_mmco = 0;

592

593 if (h->short_ref_count &&

594 h->long_ref_count + h->short_ref_count >= h->ps.sps->ref_frame_count &&

595 !(FIELD_PICTURE(h) && !h->first_field && h->cur_pic_ptr->reference)) {

596 mmco[0].opcode = MMCO_SHORT2UNUSED;

597 mmco[0].short_pic_num = h->short_ref[h->short_ref_count - 1]->frame_num;

598 nb_mmco = 1;

599 if (FIELD_PICTURE(h)) {

600 mmco[0].short_pic_num *= 2;

601 mmco[1].opcode = MMCO_SHORT2UNUSED;

602 mmco[1].short_pic_num = mmco[0].short_pic_num + 1;

603 nb_mmco = 2;

604 }

605 }

606

607 h->nb_mmco = nb_mmco;

608 }

609

610 int ff_h264_execute_ref_pic_marking(H264Context *h)

611 {

612 MMCO *mmco = h->mmco;

613 int mmco_count;

614 int i, av_uninit(j);

615 int pps_ref_count[2] = {0};

616 int current_ref_assigned = 0, err = 0;

617 H264Picture *av_uninit(pic);

618

619 if (!h->ps.sps) {

620 av_log(h->avctx, AV_LOG_ERROR, "SPS is unset\n");

621 err = AVERROR_INVALIDDATA;

622 goto out;

623 }

624

625 if (!h->explicit_ref_marking)

626 generate_sliding_window_mmcos(h);

627 mmco_count = h->nb_mmco;

628

629 if ((h->avctx->debug & FF_DEBUG_MMCO) && mmco_count == 0)

630 av_log(h->avctx, AV_LOG_DEBUG, "no mmco here\n");

631

632 for (i = 0; i < mmco_count; i++) {

633 int av_uninit(structure), av_uninit(frame_num);

634 if (h->avctx->debug & FF_DEBUG_MMCO)

635 av_log(h->avctx, AV_LOG_DEBUG, "mmco:%d %d %d\n", h->mmco[i].opcode,

636 h->mmco[i].short_pic_num, h->mmco[i].long_arg);

637

638 if (mmco[i].opcode == MMCO_SHORT2UNUSED ||

639 mmco[i].opcode == MMCO_SHORT2LONG) {

640 frame_num = pic_num_extract(h, mmco[i].short_pic_num, &structure);

641 pic = find_short(h, frame_num, &j);

642 if (!pic) {

643 if (mmco[i].opcode != MMCO_SHORT2LONG ||

644 !h->long_ref[mmco[i].long_arg] ||

645 h->long_ref[mmco[i].long_arg]->frame_num != frame_num) {

646 av_log(h->avctx, h->short_ref_count ? AV_LOG_ERROR : AV_LOG_DEBUG, "mmco: unref short failure\n");

647 err = AVERROR_INVALIDDATA;

648 }

649 continue;

650 }

651 }

652

653 switch (mmco[i].opcode) {

654 case MMCO_SHORT2UNUSED:

655 if (h->avctx->debug & FF_DEBUG_MMCO)

656 av_log(h->avctx, AV_LOG_DEBUG, "mmco: unref short %d count %d\n",

657 h->mmco[i].short_pic_num, h->short_ref_count);

658 remove_short(h, frame_num, structure ^ PICT_FRAME);

659 break;

660 case MMCO_SHORT2LONG:

661 if (h->long_ref[mmco[i].long_arg] != pic)

662 remove_long(h, mmco[i].long_arg, 0);

663

664 remove_short_at_index(h, j);

665 h->long_ref[ mmco[i].long_arg ] = pic;

666 if (h->long_ref[mmco[i].long_arg]) {

667 h->long_ref[mmco[i].long_arg]->long_ref = 1;

668 h->long_ref_count++;

669 }

670 break;

671 case MMCO_LONG2UNUSED:

672 j = pic_num_extract(h, mmco[i].long_arg, &structure);

673 pic = h->long_ref[j];

674 if (pic) {

675 remove_long(h, j, structure ^ PICT_FRAME);

676 } else if (h->avctx->debug & FF_DEBUG_MMCO)

677 av_log(h->avctx, AV_LOG_DEBUG, "mmco: unref long failure\n");

678 break;

679 case MMCO_LONG:

680 // Comment below left from previous code as it is an interesting note.

681 /* First field in pair is in short term list or

682 * at a different long term index.

683 * This is not allowed; see 7.4.3.3, notes 2 and 3.

684 * Report the problem and keep the pair where it is,

685 * and mark this field valid.

686 */

687 if (h->short_ref[0] == h->cur_pic_ptr) {

688 av_log(h->avctx, AV_LOG_ERROR, "mmco: cannot assign current picture to short and long at the same time\n");

689 remove_short_at_index(h, 0);

690 }

691

692 /* make sure the current picture is not already assigned as a long ref */

693 if (h->cur_pic_ptr->long_ref) {

694 for (j = 0; j < FF_ARRAY_ELEMS(h->long_ref); j++) {

695 if (h->long_ref[j] == h->cur_pic_ptr) {

696 if (j != mmco[i].long_arg)

697 av_log(h->avctx, AV_LOG_ERROR, "mmco: cannot assign current picture to 2 long term references\n");

698 remove_long(h, j, 0);

699 }

700 }

701 }

702

703 if (h->long_ref[mmco[i].long_arg] != h->cur_pic_ptr) {

704 av_assert0(!h->cur_pic_ptr->long_ref);

705 remove_long(h, mmco[i].long_arg, 0);

706

707 h->long_ref[mmco[i].long_arg] = h->cur_pic_ptr;

708 h->long_ref[mmco[i].long_arg]->long_ref = 1;

709 h->long_ref_count++;

710 }

711

712 h->cur_pic_ptr->reference |= h->picture_structure;

713 current_ref_assigned = 1;

714 break;

715 case MMCO_SET_MAX_LONG:

716 assert(mmco[i].long_arg <= 16);

717 // just remove the long term which index is greater than new max

718 for (j = mmco[i].long_arg; j < 16; j++) {

719 remove_long(h, j, 0);

720 }

721 break;

722 case MMCO_RESET:

723 while (h->short_ref_count) {

724 remove_short(h, h->short_ref[0]->frame_num, 0);

725 }

726 for (j = 0; j < 16; j++) {

727 remove_long(h, j, 0);

728 }

729 h->poc.frame_num = h->cur_pic_ptr->frame_num = 0;

730 h->mmco_reset = 1;

731 h->cur_pic_ptr->mmco_reset = 1;

732 for (j = 0; j < MAX_DELAYED_PIC_COUNT; j++)

733 h->last_pocs[j] = INT_MIN;

734 break;

735 default: av_assert0(0);

736 }

737 }

738

739 if (!current_ref_assigned) {

740 /* Second field of complementary field pair; the first field of

741 * which is already referenced. If short referenced, it

742 * should be first entry in short_ref. If not, it must exist

743 * in long_ref; trying to put it on the short list here is an

744 * error in the encoded bit stream (ref: 7.4.3.3, NOTE 2 and 3).

745 */

746 if (h->short_ref_count && h->short_ref[0] == h->cur_pic_ptr) {

747 /* Just mark the second field valid */

748 h->cur_pic_ptr->reference |= h->picture_structure;

749 } else if (h->cur_pic_ptr->long_ref) {

750 av_log(h->avctx, AV_LOG_ERROR, "illegal short term reference "

751 "assignment for second field "

752 "in complementary field pair "

753 "(first field is long term)\n");

754 err = AVERROR_INVALIDDATA;

755 } else {

756 pic = remove_short(h, h->cur_pic_ptr->frame_num, 0);

757 if (pic) {

758 av_log(h->avctx, AV_LOG_ERROR, "illegal short term buffer state detected\n");

759 err = AVERROR_INVALIDDATA;

760 }

761

762 if (h->short_ref_count)

763 memmove(&h->short_ref[1], &h->short_ref[0],

764 h->short_ref_count * sizeof(H264Picture*));

765

766 h->short_ref[0] = h->cur_pic_ptr;

767 h->short_ref_count++;

768 h->cur_pic_ptr->reference |= h->picture_structure;

769 }

770 }

771

772 if (h->long_ref_count + h->short_ref_count > FFMAX(h->ps.sps->ref_frame_count, 1)) {

773

774 /* We have too many reference frames, probably due to corrupted

775 * stream. Need to discard one frame. Prevents overrun of the

776 * short_ref and long_ref buffers.

777 */

778 av_log(h->avctx, AV_LOG_ERROR,

779 "number of reference frames (%d+%d) exceeds max (%d; probably "

780 "corrupt input), discarding one\n",

781 h->long_ref_count, h->short_ref_count, h->ps.sps->ref_frame_count);

782 err = AVERROR_INVALIDDATA;

783

784 if (h->long_ref_count && !h->short_ref_count) {

785 for (i = 0; i < 16; ++i)

786 if (h->long_ref[i])

787 break;

788

789 assert(i < 16);

790 remove_long(h, i, 0);

791 } else {

792 pic = h->short_ref[h->short_ref_count - 1];

793 remove_short(h, pic->frame_num, 0);

794 }

795 }

796

797 for (i = 0; i<h->short_ref_count; i++) {

798 pic = h->short_ref[i];

799 if (pic->invalid_gap) {

800 int d = av_mod_uintp2(h->cur_pic_ptr->frame_num - pic->frame_num, h->ps.sps->log2_max_frame_num);

801 if (d > h->ps.sps->ref_frame_count)

802 remove_short(h, pic->frame_num, 0);

803 }

804 }

805

806 print_short_term(h);

807 print_long_term(h);

808

809 for (i = 0; i < FF_ARRAY_ELEMS(h->ps.pps_list); i++) {

810 if (h->ps.pps_list[i]) {

811 const PPS *pps = (const PPS *)h->ps.pps_list[i]->data;

812 pps_ref_count[0] = FFMAX(pps_ref_count[0], pps->ref_count[0]);

813 pps_ref_count[1] = FFMAX(pps_ref_count[1], pps->ref_count[1]);

814 }

815 }

816

817 // Detect unmarked random access points

818 if ( err >= 0

819 && h->long_ref_count==0

820 && ( h->short_ref_count<=2

821 || pps_ref_count[0] <= 2 && pps_ref_count[1] <= 1 && h->avctx->has_b_frames

822 || pps_ref_count[0] <= 1 + (h->picture_structure != PICT_FRAME) && pps_ref_count[1] <= 1)

823 && pps_ref_count[0]<=2 + (h->picture_structure != PICT_FRAME) + (2*!h->has_recovery_point)

824 && h->cur_pic_ptr->f->pict_type == AV_PICTURE_TYPE_I){

825 h->cur_pic_ptr->recovered |= 1;

826 if(!h->avctx->has_b_frames)

827 h->frame_recovered |= FRAME_RECOVERED_SEI;

828 }

829

830 out:

831 return (h->avctx->err_recognition & AV_EF_EXPLODE) ? err : 0;

832 }

833

834 int ff_h264_decode_ref_pic_marking(H264SliceContext *sl, GetBitContext *gb,

835 const H2645NAL *nal, void *logctx)

836 {

837 int i;

838 MMCO *mmco = sl->mmco;

839 int nb_mmco = 0;

840

841 if (nal->type == H264_NAL_IDR_SLICE) { // FIXME fields

842 skip_bits1(gb); // broken_link

843 if (get_bits1(gb)) {

844 mmco[0].opcode = MMCO_LONG;

845 mmco[0].long_arg = 0;

846 nb_mmco = 1;

847 }

848 sl->explicit_ref_marking = 1;

849 } else {

850 sl->explicit_ref_marking = get_bits1(gb);

851 if (sl->explicit_ref_marking) {

852 for (i = 0; i < MAX_MMCO_COUNT; i++) {

853 MMCOOpcode opcode = get_ue_golomb_31(gb);

854

855 mmco[i].opcode = opcode;

856 if (opcode == MMCO_SHORT2UNUSED || opcode == MMCO_SHORT2LONG) {

857 mmco[i].short_pic_num =

858 (sl->curr_pic_num - get_ue_golomb_long(gb) - 1) &

859 (sl->max_pic_num - 1);

860 }

861 if (opcode == MMCO_SHORT2LONG || opcode == MMCO_LONG2UNUSED ||

862 opcode == MMCO_LONG || opcode == MMCO_SET_MAX_LONG) {

863 unsigned int long_arg = get_ue_golomb_31(gb);

864 if (long_arg >= 32 ||

865 (long_arg >= 16 && !(opcode == MMCO_SET_MAX_LONG &&

866 long_arg == 16) &&

867 !(opcode == MMCO_LONG2UNUSED && FIELD_PICTURE(sl)))) {

868 av_log(logctx, AV_LOG_ERROR,

869 "illegal long ref in memory management control "

870 "operation %d\n", opcode);

871 sl->nb_mmco = i;

872 return -1;

873 }

874 mmco[i].long_arg = long_arg;

875 }

876

877 if (opcode > (unsigned) MMCO_LONG) {

878 av_log(logctx, AV_LOG_ERROR,

879 "illegal memory management control operation %d\n",

880 opcode);

881 sl->nb_mmco = i;

882 return -1;

883 }

884 if (opcode == MMCO_END)

885 break;

886 }

887 nb_mmco = i;

888 }

889 }

890

891 sl->nb_mmco = nb_mmco;

892

893 return 0;

894 }

PICT_FRAME

#define PICT_FRAME

Definition: mpegutils.h:38

MMCO::opcode

MMCOOpcode opcode

Definition: h264dec.h:125

remove_short_at_index

static void remove_short_at_index(H264Context *h, int i)

Remove a picture from the short term reference list by its index in that list.

Definition: h264_refs.c:514

ff_h264_unref_picture

void ff_h264_unref_picture(H264Context *h, H264Picture *pic)

Definition: h264_picture.c:44

H264SliceContext::nb_ref_modifications

int nb_ref_modifications[2]

Definition: h264dec.h:288

MMCO::long_arg

int long_arg

index, pic_num, or num long refs depending on opcode

Definition: h264dec.h:127

MMCO_RESET

@ MMCO_RESET

Definition: h264dec.h:117

mismatches_ref

static int mismatches_ref(const H264Context *h, const H264Picture *pic)

Definition: h264_refs.c:127

H264_NAL_IDR_SLICE

@ H264_NAL_IDR_SLICE

Definition: h264.h:39

H264SliceContext::max_pic_num

int max_pic_num

Definition: h264dec.h:344

H264SliceContext::nb_mmco

int nb_mmco

Definition: h264dec.h:335

print_long_term

static void print_long_term(const H264Context *h)

print long term list

Definition: h264_refs.c:236

H264Picture::poc

int poc

frame POC

Definition: h264dec.h:153

H264Picture::f

AVFrame * f

Definition: h264dec.h:131

out

FILE * out

Definition: movenc.c:54

split_field_copy

static int split_field_copy(H264Ref *dest, H264Picture *src, int parity, int id_add)

Definition: h264_refs.c:62

H264Ref

Definition: h264dec.h:178

ref_from_h264pic

static void ref_from_h264pic(H264Ref *dst, H264Picture *src)

Definition: h264_refs.c:52

av_mod_uintp2

#define av_mod_uintp2

Definition: common.h:123

AVFrame

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

Definition: frame.h:317

index

fg index

Definition: ffmpeg_filter.c:167

internal.h

H264SliceContext::mmco

MMCO mmco[MAX_MMCO_COUNT]

Definition: h264dec.h:334

H264SliceContext::val

uint32_t val

Definition: h264dec.h:286

H264Ref::pic_id

int pic_id

Definition: h264dec.h:184

data

const char data[16]

Definition: mxf.c:143

H264SliceContext::ref_count

unsigned int ref_count[2]

num_ref_idx_l0/1_active_minus1 + 1

Definition: h264dec.h:279

PICT_BOTTOM_FIELD

#define PICT_BOTTOM_FIELD

Definition: mpegutils.h:37

build_def_list

static int build_def_list(H264Ref *def, int def_len, H264Picture *const *in, int len, int is_long, int sel)

Definition: h264_refs.c:78

FFMAX

#define FFMAX(a, b)

Definition: macros.h:47

FRAME_RECOVERED_SEI

#define FRAME_RECOVERED_SEI

Sufficient number of frames have been decoded since a SEI recovery point, so all the following frames...

Definition: h264dec.h:542

ff_h264_decode_ref_pic_list_reordering

int ff_h264_decode_ref_pic_list_reordering(H264SliceContext *sl, void *logctx)

Definition: h264_refs.c:423

mpegutils.h

AVFrame::buf

AVBufferRef * buf[AV_NUM_DATA_POINTERS]

AVBuffer references backing the data for this frame.

Definition: frame.h:513

remove_long

static H264Picture * remove_long(H264Context *h, int i, int ref_mask)

Remove a picture from the long term reference list by its index in that list.

Definition: h264_refs.c:548

MMCO_LONG

@ MMCO_LONG

Definition: h264dec.h:118

AVFrame::data

uint8_t * data[AV_NUM_DATA_POINTERS]

pointer to the picture/channel planes.

Definition: frame.h:338

H264Picture::frame_num

int frame_num

frame_num (raw frame_num from slice header)

Definition: h264dec.h:154

H264SliceContext

Definition: h264dec.h:189

golomb.h

exp golomb vlc stuff

#define U(x)

Definition: vp56_arith.h:37

GetBitContext

Definition: get_bits.h:62

val

static double val(void *priv, double ch)

Definition: aeval.c:76

H264Ref::data

uint8_t * data[3]

Definition: h264dec.h:179

find_short

static H264Picture * find_short(H264Context *h, int frame_num, int *idx)

Find a H264Picture in the short term reference list by frame number.

Definition: h264_refs.c:492

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

static int op(uint8_t **dst, const uint8_t *dst_end, GetByteContext *gb, int pixel, int count, int *x, int width, int linesize)

Perform decode operation.

Definition: anm.c:75

FIELD_PICTURE

#define FIELD_PICTURE(h)

Definition: h264dec.h:76

ff_h264_execute_ref_pic_marking

int ff_h264_execute_ref_pic_marking(H264Context *h)

Execute the reference picture marking (memory management control operations).

Definition: h264_refs.c:610

ff_h264_decode_ref_pic_marking

int ff_h264_decode_ref_pic_marking(H264SliceContext *sl, GetBitContext *gb, const H2645NAL *nal, void *logctx)

Definition: h264_refs.c:834

av_assert0

#define av_assert0(cond)

assert() equivalent, that is always enabled.

Definition: avassert.h:37

ff_h264_remove_all_refs

void ff_h264_remove_all_refs(H264Context *h)

Definition: h264_refs.c:565

AV_LOG_DEBUG

#define AV_LOG_DEBUG

Stuff which is only useful for libav* developers.

Definition: log.h:201

H264Ref::parent

H264Picture * parent

Definition: h264dec.h:186

MMCO_SHORT2LONG

@ MMCO_SHORT2LONG

Definition: h264dec.h:115

PICT_TOP_FIELD

#define PICT_TOP_FIELD

Definition: mpegutils.h:36

field

it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this field

Definition: writing_filters.txt:78

FF_DEBUG_MMCO

#define FF_DEBUG_MMCO

Definition: avcodec.h:1312

pic_num_extract

static int pic_num_extract(const H264Context *h, int pic_num, int *structure)

Extract structure information about the picture described by pic_num in the current decoding context ...

Definition: h264_refs.c:261

MMCO::short_pic_num

int short_pic_num

pic_num without wrapping (pic_num & max_pic_num)

Definition: h264dec.h:126

#define f(width, name)

Definition: cbs_vp9.c:255

H2645NAL::type

int type

NAL unit type.

Definition: h2645_parse.h:52

H264SliceContext::curr_pic_num

int curr_pic_num

Definition: h264dec.h:343

if(ret)

Definition: filter_design.txt:179

NULL

#define NULL

Definition: coverity.c:32

H264Ref::linesize

int linesize[3]

Definition: h264dec.h:180

AV_PICTURE_TYPE_I

@ AV_PICTURE_TYPE_I

Intra.

Definition: avutil.h:274

get_bits1

static unsigned int get_bits1(GetBitContext *s)

Definition: get_bits.h:499

src

#define src

Definition: vp8dsp.c:255

PPS

Picture parameter set.

Definition: h264_ps.h:111

list

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 list

Definition: filter_design.txt:25

AV_EF_EXPLODE

#define AV_EF_EXPLODE

abort decoding on minor error detection

Definition: avcodec.h:1335

print_short_term

static void print_short_term(const H264Context *h)

print short term list

Definition: h264_refs.c:220

DELAYED_PIC_REF

#define DELAYED_PIC_REF

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

Definition: diracdec.c:68

H264Picture::pic_id

int pic_id

pic_num (short -> no wrap version of pic_num, pic_num & max_pic_num; long -> long_pic_num)

Definition: h264dec.h:157

H264Picture::reference

int reference

Definition: h264dec.h:165

pps

static int FUNC() pps(CodedBitstreamContext *ctx, RWContext *rw, H264RawPPS *current)

Definition: cbs_h264_syntax_template.c:404

MMCO_LONG2UNUSED

@ MMCO_LONG2UNUSED

Definition: h264dec.h:114

MAX_DELAYED_PIC_COUNT

#define MAX_DELAYED_PIC_COUNT

Definition: h264dec.h:58

MMCOOpcode

Memory management control operation opcode.

Definition: h264dec.h:111

H2645NAL

Definition: h2645_parse.h:34

parity

mcdeint parity

Definition: vf_mcdeint.c:266

H264SliceContext::explicit_ref_marking

int explicit_ref_marking

Definition: h264dec.h:336

MMCO_SET_MAX_LONG

@ MMCO_SET_MAX_LONG

Definition: h264dec.h:116

unreference_pic

static int unreference_pic(H264Context *h, H264Picture *pic, int refmask)

Mark a picture as no longer needed for reference.

Definition: h264_refs.c:469

av_buffer_get_ref_count

int av_buffer_get_ref_count(const AVBufferRef *buf)

Definition: buffer.c:160

AVBufferRef::buffer

AVBuffer * buffer

Definition: buffer.h:83

skip_bits1

static void skip_bits1(GetBitContext *s)

Definition: get_bits.h:539

H264SliceContext::slice_type_nos

int slice_type_nos

S free slice type (SI/SP are remapped to I/P)

Definition: h264dec.h:196

FRAME_MBAFF

#define FRAME_MBAFF(h)

Definition: h264dec.h:75

h264dec.h

H264Context

H264Context.

Definition: h264dec.h:350

h264_initialise_ref_list

static void h264_initialise_ref_list(H264Context *h, H264SliceContext *sl)

Definition: h264_refs.c:135

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

Definition: cbs_h2645.c:271

len

int len

Definition: vorbis_enc_data.h:426

H264SliceContext::list_count

unsigned int list_count

Definition: h264dec.h:280

avcodec.h

limit

static double limit(double x)

Definition: vf_pseudocolor.c:128

av_uninit

#define av_uninit(x)

Definition: attributes.h:154

ff_h264_ref_picture

int ff_h264_ref_picture(H264Context *h, H264Picture *dst, H264Picture *src)

Definition: h264_picture.c:100

MMCO_END

@ MMCO_END

Definition: h264dec.h:112

pred

static const float pred[4]

Definition: siprdata.h:259

FFSWAP

#define FFSWAP(type, a, b)

Definition: macros.h:52

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

remove_short

static H264Picture * remove_short(H264Context *h, int frame_num, int ref_mask)

Definition: h264_refs.c:526

get_ue_golomb_31

static int get_ue_golomb_31(GetBitContext *gb)

read unsigned exp golomb code, constraint to a max of 31.

Definition: golomb.h:122

ff_h264_build_ref_list

int ff_h264_build_ref_list(H264Context *h, H264SliceContext *sl)

Definition: h264_refs.c:299

generate_sliding_window_mmcos