FFmpeg: libavcodec/h264_parser.c Source File

FFmpeg

[フレーム]

libavcodec

h264_parser.c

Go to the documentation of this file.

1 /*

2 * H.26L/H.264/AVC/JVT/14496-10/... parser

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 / MPEG4 part10 parser.

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

26 */

28 #define UNCHECKED_BITSTREAM_READER 1

30 #include "libavutil/attributes.h"

31 #include "parser.h"

32 #include "h264data.h"

33 #include "golomb.h"

34 #include "internal.h"

35 #include "mpegutils.h"

37 typedef struct H264ParseContext {

38 H264Context h;

39 ParseContext pc;

40 int got_first;

41 } H264ParseContext;

44 static int h264_find_frame_end(H264ParseContext *p, const uint8_t *buf,

45 int buf_size)

46 {

47 H264Context *h = &p->h;

48 int i, j;

49 uint32_t state;

50 ParseContext *pc = &p->pc;

52 int next_avc= h->is_avc ? 0 : buf_size;

53 // mb_addr= pc->mb_addr - 1;

54 state = pc->state;

55 if (state > 13)

56 state = 7;

58 if (h->is_avc && !h->nal_length_size)

59 av_log(h->avctx, AV_LOG_ERROR, "AVC-parser: nal length size invalid\n");

61 for (i = 0; i < buf_size; i++) {

62 if (i >= next_avc) {

63 int nalsize = 0;

64 i = next_avc;

65 for (j = 0; j < h->nal_length_size; j++)

66 nalsize = (nalsize << 8) | buf[i++];

67 if (nalsize <= 0 || nalsize > buf_size - i) {

68 av_log(h->avctx, AV_LOG_ERROR, "AVC-parser: nal size %d remaining %d\n", nalsize, buf_size - i);

69 return buf_size;

70 }

71 next_avc = i + nalsize;

72 state = 5;

73 }

75 if (state == 7) {

76 i += h->h264dsp.startcode_find_candidate(buf + i, next_avc - i);

77 if (i < next_avc)

78 state = 2;

79 } else if (state <= 2) {

80 if (buf[i] == 1)

81 state ^= 5; // 2->7, 1->4, 0->5

82 else if (buf[i])

83 state = 7;

84 else

85 state >>= 1; // 2->1, 1->0, 0->0

86 } else if (state <= 5) {

87 int nalu_type = buf[i] & 0x1F;

88 if (nalu_type == NAL_SEI || nalu_type == NAL_SPS ||

89 nalu_type == NAL_PPS || nalu_type == NAL_AUD) {

90 if (pc->frame_start_found) {

91 i++;

92 goto found;

93 }

94 } else if (nalu_type == NAL_SLICE || nalu_type == NAL_DPA ||

95 nalu_type == NAL_IDR_SLICE) {

96 state += 8;

97 continue;

98 }

99 state = 7;

100 } else {

101 h->parse_history[h->parse_history_count++]= buf[i];

102 if (h->parse_history_count>5) {

103 unsigned int mb, last_mb= h->parse_last_mb;

104 GetBitContext gb;

105

106 init_get_bits(&gb, h->parse_history, 8*h->parse_history_count);

107 h->parse_history_count=0;

108 mb= get_ue_golomb_long(&gb);

109 h->parse_last_mb= mb;

110 if (pc->frame_start_found) {

111 if (mb <= last_mb)

112 goto found;

113 } else

114 pc->frame_start_found = 1;

115 state = 7;

116 }

117 }

118 }

119 pc->state = state;

120 if (h->is_avc)

121 return next_avc;

122 return END_NOT_FOUND;

123

124 found:

125 pc->state = 7;

126 pc->frame_start_found = 0;

127 if (h->is_avc)

128 return next_avc;

129 return i - (state & 5) - 5 * (state > 7);

130 }

131

132 static int scan_mmco_reset(AVCodecParserContext *s)

133 {

134 H264ParseContext *p = s->priv_data;

135 H264Context *h = &p->h;

136

137 h->slice_type_nos = s->pict_type & 3;

138

139 if (h->pps.redundant_pic_cnt_present)

140 get_ue_golomb(&h->gb); // redundant_pic_count

141

142 if (ff_set_ref_count(h) < 0)

143 return AVERROR_INVALIDDATA;

144

145 if (h->slice_type_nos != AV_PICTURE_TYPE_I) {

146 int list;

147 for (list = 0; list < h->list_count; list++) {

148 if (get_bits1(&h->gb)) {

149 int index;

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

151 unsigned int reordering_of_pic_nums_idc = get_ue_golomb_31(&h->gb);

152

153 if (reordering_of_pic_nums_idc < 3)

154 get_ue_golomb(&h->gb);

155 else if (reordering_of_pic_nums_idc > 3) {

156 av_log(h->avctx, AV_LOG_ERROR,

157 "illegal reordering_of_pic_nums_idc %d\n",

158 reordering_of_pic_nums_idc);

159 return AVERROR_INVALIDDATA;

160 } else

161 break;

162

163 if (index >= h->ref_count[list]) {

164 av_log(h->avctx, AV_LOG_ERROR,

165 "reference count %d overflow\n", index);

166 return AVERROR_INVALIDDATA;

167 }

168 }

169 }

170 }

171 }

172

173 if ((h->pps.weighted_pred && h->slice_type_nos == AV_PICTURE_TYPE_P) ||

174 (h->pps.weighted_bipred_idc == 1 && h->slice_type_nos == AV_PICTURE_TYPE_B))

175 ff_pred_weight_table(h);

176

177 if (get_bits1(&h->gb)) { // adaptive_ref_pic_marking_mode_flag

178 int i;

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

180 MMCOOpcode opcode = get_ue_golomb_31(&h->gb);

181 if (opcode > (unsigned) MMCO_LONG) {

182 av_log(h->avctx, AV_LOG_ERROR,

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

184 opcode);

185 return AVERROR_INVALIDDATA;

186 }

187 if (opcode == MMCO_END)

188 return 0;

189 else if (opcode == MMCO_RESET)

190 return 1;

191

192 if (opcode == MMCO_SHORT2UNUSED || opcode == MMCO_SHORT2LONG)

193 get_ue_golomb(&h->gb);

194 if (opcode == MMCO_SHORT2LONG || opcode == MMCO_LONG2UNUSED ||

195 opcode == MMCO_LONG || opcode == MMCO_SET_MAX_LONG)

196 get_ue_golomb_31(&h->gb);

197 }

198 }

199

200 return 0;

201 }

202

203 /**

204 * Parse NAL units of found picture and decode some basic information.

205 *

206 * @param s parser context.

207 * @param avctx codec context.

208 * @param buf buffer with field/frame data.

209 * @param buf_size size of the buffer.

210 */

211 static inline int parse_nal_units(AVCodecParserContext *s,

212 AVCodecContext *avctx,

213 const uint8_t * const buf, int buf_size)

214 {

215 H264ParseContext *p = s->priv_data;

216 H264Context *h = &p->h;

217 int buf_index, next_avc;

218 unsigned int pps_id;

219 unsigned int slice_type;

220 int state = -1, got_reset = 0;

221 const uint8_t *ptr;

222 int q264 = buf_size >=4 && !memcmp("Q264", buf, 4);

223 int field_poc[2];

224

225 /* set some sane default values */

226 s->pict_type = AV_PICTURE_TYPE_I;

227 s->key_frame = 0;

228 s->picture_structure = AV_PICTURE_STRUCTURE_UNKNOWN;

229

230 h->avctx = avctx;

231 ff_h264_reset_sei(h);

232 h->sei_fpa.frame_packing_arrangement_cancel_flag = -1;

233

234 if (!buf_size)

235 return 0;

236

237 buf_index = 0;

238 next_avc = h->is_avc ? 0 : buf_size;

239 for (;;) {

240 int src_length, dst_length, consumed, nalsize = 0;

241

242 if (buf_index >= next_avc) {

243 nalsize = get_avc_nalsize(h, buf, buf_size, &buf_index);

244 if (nalsize < 0)

245 break;

246 next_avc = buf_index + nalsize;

247 } else {

248 buf_index = find_start_code(buf, buf_size, buf_index, next_avc);

249 if (buf_index >= buf_size)

250 break;

251 if (buf_index >= next_avc)

252 continue;

253 }

254 src_length = next_avc - buf_index;

255

256 state = buf[buf_index];

257 switch (state & 0x1f) {

258 case NAL_SLICE:

259 case NAL_IDR_SLICE:

260 // Do not walk the whole buffer just to decode slice header

261 if ((state & 0x1f) == NAL_IDR_SLICE || ((state >> 5) & 0x3) == 0) {

262 /* IDR or disposable slice

263 * No need to decode many bytes because MMCOs shall not be present. */

264 if (src_length > 60)

265 src_length = 60;

266 } else {

267 /* To decode up to MMCOs */

268 if (src_length > 1000)

269 src_length = 1000;

270 }

271 break;

272 }

273 ptr = ff_h264_decode_nal(h, buf + buf_index, &dst_length,

274 &consumed, src_length);

275 if (!ptr || dst_length < 0)

276 break;

277

278 buf_index += consumed;

279

280 init_get_bits(&h->gb, ptr, 8 * dst_length);

281 switch (h->nal_unit_type) {

282 case NAL_SPS:

283 ff_h264_decode_seq_parameter_set(h);

284 break;

285 case NAL_PPS:

286 ff_h264_decode_picture_parameter_set(h, h->gb.size_in_bits);

287 break;

288 case NAL_SEI:

289 ff_h264_decode_sei(h);

290 break;

291 case NAL_IDR_SLICE:

292 s->key_frame = 1;

293

294 h->prev_frame_num = 0;

295 h->prev_frame_num_offset = 0;

296 h->prev_poc_msb =

297 h->prev_poc_lsb = 0;

298 /* fall through */

299 case NAL_SLICE:

300 get_ue_golomb_long(&h->gb); // skip first_mb_in_slice

301 slice_type = get_ue_golomb_31(&h->gb);

302 s->pict_type = golomb_to_pict_type[slice_type % 5];

303 if (h->sei_recovery_frame_cnt >= 0) {

304 /* key frame, since recovery_frame_cnt is set */

305 s->key_frame = 1;

306 }

307 pps_id = get_ue_golomb(&h->gb);

308 if (pps_id >= MAX_PPS_COUNT) {

309 av_log(h->avctx, AV_LOG_ERROR,

310 "pps_id %u out of range\n", pps_id);

311 return -1;

312 }

313 if (!h->pps_buffers[pps_id]) {

314 av_log(h->avctx, AV_LOG_ERROR,

315 "non-existing PPS %u referenced\n", pps_id);

316 return -1;

317 }

318 h->pps = *h->pps_buffers[pps_id];

319 if (!h->sps_buffers[h->pps.sps_id]) {

320 av_log(h->avctx, AV_LOG_ERROR,

321 "non-existing SPS %u referenced\n", h->pps.sps_id);

322 return -1;

323 }

324 h->sps = *h->sps_buffers[h->pps.sps_id];

325 h->frame_num = get_bits(&h->gb, h->sps.log2_max_frame_num);

326

327 if(h->sps.ref_frame_count <= 1 && h->pps.ref_count[0] <= 1 && s->pict_type == AV_PICTURE_TYPE_I)

328 s->key_frame = 1;

329

330 s->coded_width = 16 * h->sps.mb_width;

331 s->coded_height = 16 * h->sps.mb_height;

332 s->width = s->coded_width - (h->sps.crop_right + h->sps.crop_left);

333 s->height = s->coded_height - (h->sps.crop_top + h->sps.crop_bottom);

334 if (s->width <= 0 || s->height <= 0) {

335 s->width = s->coded_width;

336 s->height = s->coded_height;

337 }

338

339 switch (h->sps.bit_depth_luma) {

340 case 9:

341 if (CHROMA444(h)) s->format = AV_PIX_FMT_YUV444P9;

342 else if (CHROMA422(h)) s->format = AV_PIX_FMT_YUV422P9;

343 else s->format = AV_PIX_FMT_YUV420P9;

344 break;

345 case 10:

346 if (CHROMA444(h)) s->format = AV_PIX_FMT_YUV444P10;

347 else if (CHROMA422(h)) s->format = AV_PIX_FMT_YUV422P10;

348 else s->format = AV_PIX_FMT_YUV420P10;

349 break;

350 case 8:

351 if (CHROMA444(h)) s->format = AV_PIX_FMT_YUV444P;

352 else if (CHROMA422(h)) s->format = AV_PIX_FMT_YUV422P;

353 else s->format = AV_PIX_FMT_YUV420P;

354 break;

355 default:

356 s->format = AV_PIX_FMT_NONE;

357 }

358

359 avctx->profile = ff_h264_get_profile(&h->sps);

360 avctx->level = h->sps.level_idc;

361

362 if (h->sps.frame_mbs_only_flag) {

363 h->picture_structure = PICT_FRAME;

364 } else {

365 if (get_bits1(&h->gb)) { // field_pic_flag

366 h->picture_structure = PICT_TOP_FIELD + get_bits1(&h->gb); // bottom_field_flag

367 } else {

368 h->picture_structure = PICT_FRAME;

369 }

370 }

371

372 if (h->nal_unit_type == NAL_IDR_SLICE)

373 get_ue_golomb(&h->gb); /* idr_pic_id */

374 if (h->sps.poc_type == 0) {

375 h->poc_lsb = get_bits(&h->gb, h->sps.log2_max_poc_lsb);

376

377 if (h->pps.pic_order_present == 1 &&

378 h->picture_structure == PICT_FRAME)

379 h->delta_poc_bottom = get_se_golomb(&h->gb);

380 }

381

382 if (h->sps.poc_type == 1 &&

383 !h->sps.delta_pic_order_always_zero_flag) {

384 h->delta_poc[0] = get_se_golomb(&h->gb);

385

386 if (h->pps.pic_order_present == 1 &&

387 h->picture_structure == PICT_FRAME)

388 h->delta_poc[1] = get_se_golomb(&h->gb);

389 }

390

391 /* Decode POC of this picture.

392 * The prev_ values needed for decoding POC of the next picture are not set here. */

393 field_poc[0] = field_poc[1] = INT_MAX;

394 ff_init_poc(h, field_poc, &s->output_picture_number);

395

396 /* Continue parsing to check if MMCO_RESET is present.

397 * FIXME: MMCO_RESET could appear in non-first slice.

398 * Maybe, we should parse all undisposable non-IDR slice of this

399 * picture until encountering MMCO_RESET in a slice of it. */

400 if (h->nal_ref_idc && h->nal_unit_type != NAL_IDR_SLICE) {

401 got_reset = scan_mmco_reset(s);

402 if (got_reset < 0)

403 return got_reset;

404 }

405

406 /* Set up the prev_ values for decoding POC of the next picture. */

407 h->prev_frame_num = got_reset ? 0 : h->frame_num;

408 h->prev_frame_num_offset = got_reset ? 0 : h->frame_num_offset;

409 if (h->nal_ref_idc != 0) {

410 if (!got_reset) {

411 h->prev_poc_msb = h->poc_msb;

412 h->prev_poc_lsb = h->poc_lsb;

413 } else {

414 h->prev_poc_msb = 0;

415 h->prev_poc_lsb =

416 h->picture_structure == PICT_BOTTOM_FIELD ? 0 : field_poc[0];

417 }

418 }

419

420 if (h->sps.pic_struct_present_flag) {

421 switch (h->sei_pic_struct) {

422 case SEI_PIC_STRUCT_TOP_FIELD:

423 case SEI_PIC_STRUCT_BOTTOM_FIELD:

424 s->repeat_pict = 0;

425 break;

426 case SEI_PIC_STRUCT_FRAME:

427 case SEI_PIC_STRUCT_TOP_BOTTOM:

428 case SEI_PIC_STRUCT_BOTTOM_TOP:

429 s->repeat_pict = 1;

430 break;

431 case SEI_PIC_STRUCT_TOP_BOTTOM_TOP:

432 case SEI_PIC_STRUCT_BOTTOM_TOP_BOTTOM:

433 s->repeat_pict = 2;

434 break;

435 case SEI_PIC_STRUCT_FRAME_DOUBLING:

436 s->repeat_pict = 3;

437 break;

438 case SEI_PIC_STRUCT_FRAME_TRIPLING:

439 s->repeat_pict = 5;

440 break;

441 default:

442 s->repeat_pict = h->picture_structure == PICT_FRAME ? 1 : 0;

443 break;

444 }

445 } else {

446 s->repeat_pict = h->picture_structure == PICT_FRAME ? 1 : 0;

447 }

448

449 if (h->picture_structure == PICT_FRAME) {

450 s->picture_structure = AV_PICTURE_STRUCTURE_FRAME;

451 if (h->sps.pic_struct_present_flag) {

452 switch (h->sei_pic_struct) {

453 case SEI_PIC_STRUCT_TOP_BOTTOM:

454 case SEI_PIC_STRUCT_TOP_BOTTOM_TOP:

455 s->field_order = AV_FIELD_TT;

456 break;

457 case SEI_PIC_STRUCT_BOTTOM_TOP:

458 case SEI_PIC_STRUCT_BOTTOM_TOP_BOTTOM:

459 s->field_order = AV_FIELD_BB;

460 break;

461 default:

462 s->field_order = AV_FIELD_PROGRESSIVE;

463 break;

464 }

465 } else {

466 if (field_poc[0] < field_poc[1])

467 s->field_order = AV_FIELD_TT;

468 else if (field_poc[0] > field_poc[1])

469 s->field_order = AV_FIELD_BB;

470 else

471 s->field_order = AV_FIELD_PROGRESSIVE;

472 }

473 } else {

474 if (h->picture_structure == PICT_TOP_FIELD)

475 s->picture_structure = AV_PICTURE_STRUCTURE_TOP_FIELD;

476 else

477 s->picture_structure = AV_PICTURE_STRUCTURE_BOTTOM_FIELD;

478 s->field_order = AV_FIELD_UNKNOWN;

479 }

480

481 return 0; /* no need to evaluate the rest */

482 }

483 }

484 if (q264)

485 return 0;

486 /* didn't find a picture! */

487 av_log(h->avctx, AV_LOG_ERROR, "missing picture in access unit with size %d\n", buf_size);

488 return -1;

489 }

490

491 static int h264_parse(AVCodecParserContext *s,

492 AVCodecContext *avctx,

493 const uint8_t **poutbuf, int *poutbuf_size,

494 const uint8_t *buf, int buf_size)

495 {

496 H264ParseContext *p = s->priv_data;

497 H264Context *h = &p->h;

498 ParseContext *pc = &p->pc;

499 int next;

500

501 if (!p->got_first) {

502 p->got_first = 1;

503 if (avctx->extradata_size) {

504 h->avctx = avctx;

505 // must be done like in decoder, otherwise opening the parser,

506 // letting it create extradata and then closing and opening again

507 // will cause has_b_frames to be always set.

508 // Note that estimate_timings_from_pts does exactly this.

509 if (!avctx->has_b_frames)

510 h->low_delay = 1;

511 ff_h264_decode_extradata(h, avctx->extradata, avctx->extradata_size);

512 }

513 }

514

515 if (s->flags & PARSER_FLAG_COMPLETE_FRAMES) {

516 next = buf_size;

517 } else {

518 next = h264_find_frame_end(p, buf, buf_size);

519

520 if (ff_combine_frame(pc, next, &buf, &buf_size) < 0) {

521 *poutbuf = NULL;

522 *poutbuf_size = 0;

523 return buf_size;

524 }

525

526 if (next < 0 && next != END_NOT_FOUND) {

527 av_assert1(pc->last_index + next >= 0);

528 h264_find_frame_end(p, &pc->buffer[pc->last_index + next], -next); // update state

529 }

530 }

531

532 parse_nal_units(s, avctx, buf, buf_size);

533

534 if (avctx->framerate.num)

535 avctx->time_base = av_inv_q(av_mul_q(avctx->framerate, (AVRational){avctx->ticks_per_frame, 1}));

536 if (h->sei_cpb_removal_delay >= 0) {

537 s->dts_sync_point = h->sei_buffering_period_present;

538 s->dts_ref_dts_delta = h->sei_cpb_removal_delay;

539 s->pts_dts_delta = h->sei_dpb_output_delay;

540 } else {

541 s->dts_sync_point = INT_MIN;

542 s->dts_ref_dts_delta = INT_MIN;

543 s->pts_dts_delta = INT_MIN;

544 }

545

546 if (s->flags & PARSER_FLAG_ONCE) {

547 s->flags &= PARSER_FLAG_COMPLETE_FRAMES;

548 }

549

550 *poutbuf = buf;

551 *poutbuf_size = buf_size;

552 return next;

553 }

554

555 static int h264_split(AVCodecContext *avctx,

556 const uint8_t *buf, int buf_size)

557 {

558 uint32_t state = -1;

559 int has_sps = 0;

560 int has_pps = 0;

561 const uint8_t *ptr = buf, *end = buf + buf_size;

562 int nalu_type;

563

564 while (ptr < end) {

565 ptr = avpriv_find_start_code(ptr, end, &state);

566 if ((state & 0xFFFFFF00) != 0x100)

567 break;

568 nalu_type = state & 0x1F;

569 if (nalu_type == NAL_SPS) {

570 has_sps = 1;

571 } else if (nalu_type == NAL_PPS)

572 has_pps = 1;

573 /* else if (nalu_type == 0x01 ||

574 * nalu_type == 0x02 ||

575 * nalu_type == 0x05) {

576 * }

577 */

578 else if ((nalu_type != NAL_SEI || has_pps) &&

579 nalu_type != NAL_AUD && nalu_type != NAL_SPS_EXT &&

580 nalu_type != 0x0f) {

581 if (has_sps) {

582 while (ptr - 4 > buf && ptr[-5] == 0)

583 ptr--;

584 return ptr - 4 - buf;

585 }

586 }

587 }

588

589 return 0;

590 }

591

592 static void h264_close(AVCodecParserContext *s)

593 {

594 H264ParseContext *p = s->priv_data;

595 H264Context *h = &p->h;

596 ParseContext *pc = &p->pc;

597

598 av_freep(&pc->buffer);

599 ff_h264_free_context(h);

600 }

601

602 static av_cold int init(AVCodecParserContext *s)

603 {

604 H264ParseContext *p = s->priv_data;

605 H264Context *h = &p->h;

606 h->thread_context[0] = h;

607 h->slice_context_count = 1;

608 ff_h264dsp_init(&h->h264dsp, 8, 1);

609 return 0;

610 }

611

612 AVCodecParser ff_h264_parser = {

613 .codec_ids = { AV_CODEC_ID_H264 },

614 .priv_data_size = sizeof(H264ParseContext),

615 .parser_init = init,

616 .parser_parse = h264_parse,

617 .parser_close = h264_close,

618 .split = h264_split,

619 };

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