path: root/libavcodec/h264_parser.c (plain)
blob: bc35a6146e29cb5b7d983023aa39f54b5792c9ce

1	/*
2	* H.26L/H.264/AVC/JVT/14496-10/... parser
3	* Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
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	*/
21
22	/**
23	* @file
24	* H.264 / AVC / MPEG-4 part10 parser.
25	* @author Michael Niedermayer <michaelni@gmx.at>
26	*/
27
28	#define UNCHECKED_BITSTREAM_READER 1
29
30	#include <assert.h>
31	#include <stdint.h>
32
33	#include "libavutil/avutil.h"
34	#include "libavutil/error.h"
35	#include "libavutil/log.h"
36	#include "libavutil/mem.h"
37	#include "libavutil/pixfmt.h"
38
39	#include "avcodec.h"
40	#include "get_bits.h"
41	#include "golomb.h"
42	#include "h264.h"
43	#include "h264_sei.h"
44	#include "h264_ps.h"
45	#include "h264data.h"
46	#include "internal.h"
47	#include "mpegutils.h"
48	#include "parser.h"
49
50	typedef struct H264ParseContext {
51	ParseContext pc;
52	H264ParamSets ps;
53	H264DSPContext h264dsp;
54	H264POCContext poc;
55	H264SEIContext sei;
56	int is_avc;
57	int nal_length_size;
58	int got_first;
59	int picture_structure;
60	uint8_t parse_history[6];
61	int parse_history_count;
62	int parse_last_mb;
63	int64_t reference_dts;
64	int last_frame_num, last_picture_structure;
65	} H264ParseContext;
66
67
68	static int h264_find_frame_end(H264ParseContext *p, const uint8_t *buf,
69	int buf_size, void *logctx)
70	{
71	int i, j;
72	uint32_t state;
73	ParseContext *pc = &p->pc;
74
75	int next_avc = p->is_avc ? 0 : buf_size;
76	// mb_addr= pc->mb_addr - 1;
77	state = pc->state;
78	if (state > 13)
79	state = 7;
80
81	if (p->is_avc && !p->nal_length_size)
82	av_log(logctx, AV_LOG_ERROR, "AVC-parser: nal length size invalid\n");
83
84	for (i = 0; i < buf_size; i++) {
85	if (i >= next_avc) {
86	int nalsize = 0;
87	i = next_avc;
88	for (j = 0; j < p->nal_length_size; j++)
89	nalsize = (nalsize << 8) | buf[i++];
90	if (nalsize <= 0 || nalsize > buf_size - i) {
91	av_log(logctx, AV_LOG_ERROR, "AVC-parser: nal size %d remaining %d\n", nalsize, buf_size - i);
92	return buf_size;
93	}
94	next_avc = i + nalsize;
95	state = 5;
96	}
97
98	if (state == 7) {
99	i += p->h264dsp.startcode_find_candidate(buf + i, next_avc - i);
100	if (i < next_avc)
101	state = 2;
102	} else if (state <= 2) {
103	if (buf[i] == 1)
104	state ^= 5; // 2->7, 1->4, 0->5
105	else if (buf[i])
106	state = 7;
107	else
108	state >>= 1; // 2->1, 1->0, 0->0
109	} else if (state <= 5) {
110	int nalu_type = buf[i] & 0x1F;
111	if (nalu_type == H264_NAL_SEI || nalu_type == H264_NAL_SPS ||
112	nalu_type == H264_NAL_PPS || nalu_type == H264_NAL_AUD) {
113	if (pc->frame_start_found) {
114	i++;
115	goto found;
116	}
117	} else if (nalu_type == H264_NAL_SLICE || nalu_type == H264_NAL_DPA ||
118	nalu_type == H264_NAL_IDR_SLICE) {
119	state += 8;
120	continue;
121	}
122	state = 7;
123	} else {
124	p->parse_history[p->parse_history_count++] = buf[i];
125	if (p->parse_history_count > 5) {
126	unsigned int mb, last_mb = p->parse_last_mb;
127	GetBitContext gb;
128
129	init_get_bits(&gb, p->parse_history, 8*p->parse_history_count);
130	p->parse_history_count = 0;
131	mb= get_ue_golomb_long(&gb);
132	p->parse_last_mb = mb;
133	if (pc->frame_start_found) {
134	if (mb <= last_mb)
135	goto found;
136	} else
137	pc->frame_start_found = 1;
138	state = 7;
139	}
140	}
141	}
142	pc->state = state;
143	if (p->is_avc)
144	return next_avc;
145	return END_NOT_FOUND;
146
147	found:
148	pc->state = 7;
149	pc->frame_start_found = 0;
150	if (p->is_avc)
151	return next_avc;
152	return i - (state & 5) - 5 * (state > 7);
153	}
154
155	static int scan_mmco_reset(AVCodecParserContext *s, GetBitContext *gb,
156	void *logctx)
157	{
158	H264PredWeightTable pwt;
159	int slice_type_nos = s->pict_type & 3;
160	H264ParseContext *p = s->priv_data;
161	int list_count, ref_count[2];
162
163
164	if (p->ps.pps->redundant_pic_cnt_present)
165	get_ue_golomb(gb); // redundant_pic_count
166
167	if (slice_type_nos == AV_PICTURE_TYPE_B)
168	get_bits1(gb); // direct_spatial_mv_pred
169
170	if (ff_h264_parse_ref_count(&list_count, ref_count, gb, p->ps.pps,
171	slice_type_nos, p->picture_structure, logctx) < 0)
172	return AVERROR_INVALIDDATA;
173
174	if (slice_type_nos != AV_PICTURE_TYPE_I) {
175	int list;
176	for (list = 0; list < list_count; list++) {
177	if (get_bits1(gb)) {
178	int index;
179	for (index = 0; ; index++) {
180	unsigned int reordering_of_pic_nums_idc = get_ue_golomb_31(gb);
181
182	if (reordering_of_pic_nums_idc < 3)
183	get_ue_golomb_long(gb);
184	else if (reordering_of_pic_nums_idc > 3) {
185	av_log(logctx, AV_LOG_ERROR,
186	"illegal reordering_of_pic_nums_idc %d\n",
187	reordering_of_pic_nums_idc);
188	return AVERROR_INVALIDDATA;
189	} else
190	break;
191
192	if (index >= ref_count[list]) {
193	av_log(logctx, AV_LOG_ERROR,
194	"reference count %d overflow\n", index);
195	return AVERROR_INVALIDDATA;
196	}
197	}
198	}
199	}
200	}
201
202	if ((p->ps.pps->weighted_pred && slice_type_nos == AV_PICTURE_TYPE_P) ||
203	(p->ps.pps->weighted_bipred_idc == 1 && slice_type_nos == AV_PICTURE_TYPE_B))
204	ff_h264_pred_weight_table(gb, p->ps.sps, ref_count, slice_type_nos,
205	&pwt, logctx);
206
207	if (get_bits1(gb)) { // adaptive_ref_pic_marking_mode_flag
208	int i;
209	for (i = 0; i < MAX_MMCO_COUNT; i++) {
210	MMCOOpcode opcode = get_ue_golomb_31(gb);
211	if (opcode > (unsigned) MMCO_LONG) {
212	av_log(logctx, AV_LOG_ERROR,
213	"illegal memory management control operation %d\n",
214	opcode);
215	return AVERROR_INVALIDDATA;
216	}
217	if (opcode == MMCO_END)
218	return 0;
219	else if (opcode == MMCO_RESET)
220	return 1;
221
222	if (opcode == MMCO_SHORT2UNUSED || opcode == MMCO_SHORT2LONG)
223	get_ue_golomb_long(gb); // difference_of_pic_nums_minus1
224	if (opcode == MMCO_SHORT2LONG || opcode == MMCO_LONG2UNUSED ||
225	opcode == MMCO_LONG || opcode == MMCO_SET_MAX_LONG)
226	get_ue_golomb_31(gb);
227	}
228	}
229
230	return 0;
231	}
232
233	/**
234	* Parse NAL units of found picture and decode some basic information.
235	*
236	* @param s parser context.
237	* @param avctx codec context.
238	* @param buf buffer with field/frame data.
239	* @param buf_size size of the buffer.
240	*/
241	static inline int parse_nal_units(AVCodecParserContext *s,
242	AVCodecContext *avctx,
243	const uint8_t * const buf, int buf_size)
244	{
245	H264ParseContext *p = s->priv_data;
246	H2645NAL nal = { NULL };
247	int buf_index, next_avc;
248	unsigned int pps_id;
249	unsigned int slice_type;
250	int state = -1, got_reset = 0;
251	int q264 = buf_size >=4 && !memcmp("Q264", buf, 4);
252	int field_poc[2];
253	int ret;
254
255	/* set some sane default values */
256	s->pict_type = AV_PICTURE_TYPE_I;
257	s->key_frame = 0;
258	s->picture_structure = AV_PICTURE_STRUCTURE_UNKNOWN;
259
260	ff_h264_sei_uninit(&p->sei);
261	p->sei.frame_packing.frame_packing_arrangement_cancel_flag = -1;
262
263	if (!buf_size)
264	return 0;
265
266	buf_index = 0;
267	next_avc = p->is_avc ? 0 : buf_size;
268	for (;;) {
269	const SPS *sps;
270	int src_length, consumed, nalsize = 0;
271
272	if (buf_index >= next_avc) {
273	nalsize = get_nalsize(p->nal_length_size, buf, buf_size, &buf_index, avctx);
274	if (nalsize < 0)
275	break;
276	next_avc = buf_index + nalsize;
277	} else {
278	buf_index = find_start_code(buf, buf_size, buf_index, next_avc);
279	if (buf_index >= buf_size)
280	break;
281	if (buf_index >= next_avc)
282	continue;
283	}
284	src_length = next_avc - buf_index;
285
286	state = buf[buf_index];
287	switch (state & 0x1f) {
288	case H264_NAL_SLICE:
289	case H264_NAL_IDR_SLICE:
290	// Do not walk the whole buffer just to decode slice header
291	if ((state & 0x1f) == H264_NAL_IDR_SLICE || ((state >> 5) & 0x3) == 0) {
292	/* IDR or disposable slice
293	* No need to decode many bytes because MMCOs shall not be present. */
294	if (src_length > 60)
295	src_length = 60;
296	} else {
297	/* To decode up to MMCOs */
298	if (src_length > 1000)
299	src_length = 1000;
300	}
301	break;
302	}
303	consumed = ff_h2645_extract_rbsp(buf + buf_index, src_length, &nal, 1);
304	if (consumed < 0)
305	break;
306
307	buf_index += consumed;
308
309	ret = init_get_bits8(&nal.gb, nal.data, nal.size);
310	if (ret < 0)
311	goto fail;
312	get_bits1(&nal.gb);
313	nal.ref_idc = get_bits(&nal.gb, 2);
314	nal.type = get_bits(&nal.gb, 5);
315
316	switch (nal.type) {
317	case H264_NAL_SPS:
318	ff_h264_decode_seq_parameter_set(&nal.gb, avctx, &p->ps, 0);
319	break;
320	case H264_NAL_PPS:
321	ff_h264_decode_picture_parameter_set(&nal.gb, avctx, &p->ps,
322	nal.size_bits);
323	break;
324	case H264_NAL_SEI:
325	ff_h264_sei_decode(&p->sei, &nal.gb, &p->ps, avctx);
326	break;
327	case H264_NAL_IDR_SLICE:
328	s->key_frame = 1;
329
330	p->poc.prev_frame_num = 0;
331	p->poc.prev_frame_num_offset = 0;
332	p->poc.prev_poc_msb =
333	p->poc.prev_poc_lsb = 0;
334	/* fall through */
335	case H264_NAL_SLICE:
336	get_ue_golomb_long(&nal.gb); // skip first_mb_in_slice
337	slice_type = get_ue_golomb_31(&nal.gb);
338	s->pict_type = ff_h264_golomb_to_pict_type[slice_type % 5];
339	if (p->sei.recovery_point.recovery_frame_cnt >= 0) {
340	/* key frame, since recovery_frame_cnt is set */
341	s->key_frame = 1;
342	}
343	pps_id = get_ue_golomb(&nal.gb);
344	if (pps_id >= MAX_PPS_COUNT) {
345	av_log(avctx, AV_LOG_ERROR,
346	"pps_id %u out of range\n", pps_id);
347	goto fail;
348	}
349	if (!p->ps.pps_list[pps_id]) {
350	av_log(avctx, AV_LOG_ERROR,
351	"non-existing PPS %u referenced\n", pps_id);
352	goto fail;
353	}
354
355	av_buffer_unref(&p->ps.pps_ref);
356	av_buffer_unref(&p->ps.sps_ref);
357	p->ps.pps = NULL;
358	p->ps.sps = NULL;
359	p->ps.pps_ref = av_buffer_ref(p->ps.pps_list[pps_id]);
360	if (!p->ps.pps_ref)
361	goto fail;
362	p->ps.pps = (const PPS*)p->ps.pps_ref->data;
363
364	if (!p->ps.sps_list[p->ps.pps->sps_id]) {
365	av_log(avctx, AV_LOG_ERROR,
366	"non-existing SPS %u referenced\n", p->ps.pps->sps_id);
367	goto fail;
368	}
369
370	p->ps.sps_ref = av_buffer_ref(p->ps.sps_list[p->ps.pps->sps_id]);
371	if (!p->ps.sps_ref)
372	goto fail;
373	p->ps.sps = (const SPS*)p->ps.sps_ref->data;
374
375	sps = p->ps.sps;
376
377	// heuristic to detect non marked keyframes
378	if (p->ps.sps->ref_frame_count <= 1 && p->ps.pps->ref_count[0] <= 1 && s->pict_type == AV_PICTURE_TYPE_I)
379	s->key_frame = 1;
380
381	p->poc.frame_num = get_bits(&nal.gb, sps->log2_max_frame_num);
382
383	s->coded_width = 16 * sps->mb_width;
384	s->coded_height = 16 * sps->mb_height;
385	s->width = s->coded_width - (sps->crop_right + sps->crop_left);
386	s->height = s->coded_height - (sps->crop_top + sps->crop_bottom);
387	if (s->width <= 0 || s->height <= 0) {
388	s->width = s->coded_width;
389	s->height = s->coded_height;
390	}
391
392	switch (sps->bit_depth_luma) {
393	case 9:
394	if (sps->chroma_format_idc == 3) s->format = AV_PIX_FMT_YUV444P9;
395	else if (sps->chroma_format_idc == 2) s->format = AV_PIX_FMT_YUV422P9;
396	else s->format = AV_PIX_FMT_YUV420P9;
397	break;
398	case 10:
399	if (sps->chroma_format_idc == 3) s->format = AV_PIX_FMT_YUV444P10;
400	else if (sps->chroma_format_idc == 2) s->format = AV_PIX_FMT_YUV422P10;
401	else s->format = AV_PIX_FMT_YUV420P10;
402	break;
403	case 8:
404	if (sps->chroma_format_idc == 3) s->format = AV_PIX_FMT_YUV444P;
405	else if (sps->chroma_format_idc == 2) s->format = AV_PIX_FMT_YUV422P;
406	else s->format = AV_PIX_FMT_YUV420P;
407	break;
408	default:
409	s->format = AV_PIX_FMT_NONE;
410	}
411
412	avctx->profile = ff_h264_get_profile(sps);
413	avctx->level = sps->level_idc;
414
415	if (sps->frame_mbs_only_flag) {
416	p->picture_structure = PICT_FRAME;
417	} else {
418	if (get_bits1(&nal.gb)) { // field_pic_flag
419	p->picture_structure = PICT_TOP_FIELD + get_bits1(&nal.gb); // bottom_field_flag
420	} else {
421	p->picture_structure = PICT_FRAME;
422	}
423	}
424
425	if (nal.type == H264_NAL_IDR_SLICE)
426	get_ue_golomb_long(&nal.gb); /* idr_pic_id */
427	if (sps->poc_type == 0) {
428	p->poc.poc_lsb = get_bits(&nal.gb, sps->log2_max_poc_lsb);
429
430	if (p->ps.pps->pic_order_present == 1 &&
431	p->picture_structure == PICT_FRAME)
432	p->poc.delta_poc_bottom = get_se_golomb(&nal.gb);
433	}
434
435	if (sps->poc_type == 1 &&
436	!sps->delta_pic_order_always_zero_flag) {
437	p->poc.delta_poc[0] = get_se_golomb(&nal.gb);
438
439	if (p->ps.pps->pic_order_present == 1 &&
440	p->picture_structure == PICT_FRAME)
441	p->poc.delta_poc[1] = get_se_golomb(&nal.gb);
442	}
443
444	/* Decode POC of this picture.
445	* The prev_ values needed for decoding POC of the next picture are not set here. */
446	field_poc[0] = field_poc[1] = INT_MAX;
447	ff_h264_init_poc(field_poc, &s->output_picture_number, sps,
448	&p->poc, p->picture_structure, nal.ref_idc);
449
450	/* Continue parsing to check if MMCO_RESET is present.
451	* FIXME: MMCO_RESET could appear in non-first slice.
452	* Maybe, we should parse all undisposable non-IDR slice of this
453	* picture until encountering MMCO_RESET in a slice of it. */
454	if (nal.ref_idc && nal.type != H264_NAL_IDR_SLICE) {
455	got_reset = scan_mmco_reset(s, &nal.gb, avctx);
456	if (got_reset < 0)
457	goto fail;
458	}
459
460	/* Set up the prev_ values for decoding POC of the next picture. */
461	p->poc.prev_frame_num = got_reset ? 0 : p->poc.frame_num;
462	p->poc.prev_frame_num_offset = got_reset ? 0 : p->poc.frame_num_offset;
463	if (nal.ref_idc != 0) {
464	if (!got_reset) {
465	p->poc.prev_poc_msb = p->poc.poc_msb;
466	p->poc.prev_poc_lsb = p->poc.poc_lsb;
467	} else {
468	p->poc.prev_poc_msb = 0;
469	p->poc.prev_poc_lsb =
470	p->picture_structure == PICT_BOTTOM_FIELD ? 0 : field_poc[0];
471	}
472	}
473
474	if (sps->pic_struct_present_flag && p->sei.picture_timing.present) {
475	switch (p->sei.picture_timing.pic_struct) {
476	case SEI_PIC_STRUCT_TOP_FIELD:
477	case SEI_PIC_STRUCT_BOTTOM_FIELD:
478	s->repeat_pict = 0;
479	break;
480	case SEI_PIC_STRUCT_FRAME:
481	case SEI_PIC_STRUCT_TOP_BOTTOM:
482	case SEI_PIC_STRUCT_BOTTOM_TOP:
483	s->repeat_pict = 1;
484	break;
485	case SEI_PIC_STRUCT_TOP_BOTTOM_TOP:
486	case SEI_PIC_STRUCT_BOTTOM_TOP_BOTTOM:
487	s->repeat_pict = 2;
488	break;
489	case SEI_PIC_STRUCT_FRAME_DOUBLING:
490	s->repeat_pict = 3;
491	break;
492	case SEI_PIC_STRUCT_FRAME_TRIPLING:
493	s->repeat_pict = 5;
494	break;
495	default:
496	s->repeat_pict = p->picture_structure == PICT_FRAME ? 1 : 0;
497	break;
498	}
499	} else {
500	s->repeat_pict = p->picture_structure == PICT_FRAME ? 1 : 0;
501	}
502
503	if (p->picture_structure == PICT_FRAME) {
504	s->picture_structure = AV_PICTURE_STRUCTURE_FRAME;
505	if (sps->pic_struct_present_flag && p->sei.picture_timing.present) {
506	switch (p->sei.picture_timing.pic_struct) {
507	case SEI_PIC_STRUCT_TOP_BOTTOM:
508	case SEI_PIC_STRUCT_TOP_BOTTOM_TOP:
509	s->field_order = AV_FIELD_TT;
510	break;
511	case SEI_PIC_STRUCT_BOTTOM_TOP:
512	case SEI_PIC_STRUCT_BOTTOM_TOP_BOTTOM:
513	s->field_order = AV_FIELD_BB;
514	break;
515	default:
516	s->field_order = AV_FIELD_PROGRESSIVE;
517	break;
518	}
519	} else {
520	if (field_poc[0] < field_poc[1])
521	s->field_order = AV_FIELD_TT;
522	else if (field_poc[0] > field_poc[1])
523	s->field_order = AV_FIELD_BB;
524	else
525	s->field_order = AV_FIELD_PROGRESSIVE;
526	}
527	} else {
528	if (p->picture_structure == PICT_TOP_FIELD)
529	s->picture_structure = AV_PICTURE_STRUCTURE_TOP_FIELD;
530	else
531	s->picture_structure = AV_PICTURE_STRUCTURE_BOTTOM_FIELD;
532	if (p->poc.frame_num == p->last_frame_num &&
533	p->last_picture_structure != AV_PICTURE_STRUCTURE_UNKNOWN &&
534	p->last_picture_structure != AV_PICTURE_STRUCTURE_FRAME &&
535	p->last_picture_structure != s->picture_structure) {
536	if (p->last_picture_structure == AV_PICTURE_STRUCTURE_TOP_FIELD)
537	s->field_order = AV_FIELD_TT;
538	else
539	s->field_order = AV_FIELD_BB;
540	} else {
541	s->field_order = AV_FIELD_UNKNOWN;
542	}
543	p->last_picture_structure = s->picture_structure;
544	p->last_frame_num = p->poc.frame_num;
545	}
546
547	av_freep(&nal.rbsp_buffer);
548	return 0; /* no need to evaluate the rest */
549	}
550	}
551	if (q264) {
552	av_freep(&nal.rbsp_buffer);
553	return 0;
554	}
555	/* didn't find a picture! */
556	av_log(avctx, AV_LOG_ERROR, "missing picture in access unit with size %d\n", buf_size);
557	fail:
558	av_freep(&nal.rbsp_buffer);
559	return -1;
560	}
561
562	static int h264_parse(AVCodecParserContext *s,
563	AVCodecContext *avctx,
564	const uint8_t **poutbuf, int *poutbuf_size,
565	const uint8_t *buf, int buf_size)
566	{
567	H264ParseContext *p = s->priv_data;
568	ParseContext *pc = &p->pc;
569	int next;
570
571	if (!p->got_first) {
572	p->got_first = 1;
573	if (avctx->extradata_size) {
574	ff_h264_decode_extradata(avctx->extradata, avctx->extradata_size,
575	&p->ps, &p->is_avc, &p->nal_length_size,
576	avctx->err_recognition, avctx);
577	}
578	}
579
580	if (s->flags & PARSER_FLAG_COMPLETE_FRAMES) {
581	next = buf_size;
582	} else {
583	next = h264_find_frame_end(p, buf, buf_size, avctx);
584
585	if (ff_combine_frame(pc, next, &buf, &buf_size) < 0) {
586	*poutbuf = NULL;
587	*poutbuf_size = 0;
588	return buf_size;
589	}
590
591	if (next < 0 && next != END_NOT_FOUND) {
592	av_assert1(pc->last_index + next >= 0);
593	h264_find_frame_end(p, &pc->buffer[pc->last_index + next], -next, avctx); // update state
594	}
595	}
596
597	parse_nal_units(s, avctx, buf, buf_size);
598
599	if (avctx->framerate.num)
600	avctx->time_base = av_inv_q(av_mul_q(avctx->framerate, (AVRational){avctx->ticks_per_frame, 1}));
601	if (p->sei.picture_timing.cpb_removal_delay >= 0) {
602	s->dts_sync_point = p->sei.buffering_period.present;
603	s->dts_ref_dts_delta = p->sei.picture_timing.cpb_removal_delay;
604	s->pts_dts_delta = p->sei.picture_timing.dpb_output_delay;
605	} else {
606	s->dts_sync_point = INT_MIN;
607	s->dts_ref_dts_delta = INT_MIN;
608	s->pts_dts_delta = INT_MIN;
609	}
610
611	if (s->flags & PARSER_FLAG_ONCE) {
612	s->flags &= PARSER_FLAG_COMPLETE_FRAMES;
613	}
614
615	if (s->dts_sync_point >= 0) {
616	int64_t den = avctx->time_base.den * (int64_t)avctx->pkt_timebase.num;
617	if (den > 0) {
618	int64_t num = avctx->time_base.num * (int64_t)avctx->pkt_timebase.den;
619	if (s->dts != AV_NOPTS_VALUE) {
620	// got DTS from the stream, update reference timestamp
621	p->reference_dts = s->dts - av_rescale(s->dts_ref_dts_delta, num, den);
622	} else if (p->reference_dts != AV_NOPTS_VALUE) {
623	// compute DTS based on reference timestamp
624	s->dts = p->reference_dts + av_rescale(s->dts_ref_dts_delta, num, den);
625	}
626
627	if (p->reference_dts != AV_NOPTS_VALUE && s->pts == AV_NOPTS_VALUE)
628	s->pts = s->dts + av_rescale(s->pts_dts_delta, num, den);
629
630	if (s->dts_sync_point > 0)
631	p->reference_dts = s->dts; // new reference
632	}
633	}
634
635	*poutbuf = buf;
636	*poutbuf_size = buf_size;
637	return next;
638	}
639
640	static int h264_split(AVCodecContext *avctx,
641	const uint8_t *buf, int buf_size)
642	{
643	uint32_t state = -1;
644	int has_sps = 0;
645	int has_pps = 0;
646	const uint8_t *ptr = buf, *end = buf + buf_size;
647	int nalu_type;
648
649	while (ptr < end) {
650	ptr = avpriv_find_start_code(ptr, end, &state);
651	if ((state & 0xFFFFFF00) != 0x100)
652	break;
653	nalu_type = state & 0x1F;
654	if (nalu_type == H264_NAL_SPS) {
655	has_sps = 1;
656	} else if (nalu_type == H264_NAL_PPS)
657	has_pps = 1;
658	/* else if (nalu_type == 0x01 ||
659	* nalu_type == 0x02 ||
660	* nalu_type == 0x05) {
661	* }
662	*/
663	else if ((nalu_type != H264_NAL_SEI || has_pps) &&
664	nalu_type != H264_NAL_AUD && nalu_type != H264_NAL_SPS_EXT &&
665	nalu_type != 0x0f) {
666	if (has_sps) {
667	while (ptr - 4 > buf && ptr[-5] == 0)
668	ptr--;
669	return ptr - 4 - buf;
670	}
671	}
672	}
673
674	return 0;
675	}
676
677	static void h264_close(AVCodecParserContext *s)
678	{
679	H264ParseContext *p = s->priv_data;
680	ParseContext *pc = &p->pc;
681
682	av_freep(&pc->buffer);
683
684	ff_h264_sei_uninit(&p->sei);
685	ff_h264_ps_uninit(&p->ps);
686	}
687
688	static av_cold int init(AVCodecParserContext *s)
689	{
690	H264ParseContext *p = s->priv_data;
691
692	p->reference_dts = AV_NOPTS_VALUE;
693	p->last_frame_num = INT_MAX;
694	ff_h264dsp_init(&p->h264dsp, 8, 1);
695	return 0;
696	}
697
698	AVCodecParser ff_h264_parser = {
699	.codec_ids = { AV_CODEC_ID_H264 },
700	.priv_data_size = sizeof(H264ParseContext),
701	.parser_init = init,
702	.parser_parse = h264_parse,
703	.parser_close = h264_close,
704	.split = h264_split,
705	};
706