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