?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Update translations from 2.2.x branch
[vlc.git] / modules / packetizer / h264.c
blobdf137115503065cc7c11ee9638387b2a7038277b
1 /*****************************************************************************
2 * h264.c: h264/avc video packetizer
3 *****************************************************************************
4 * Copyright (C) 2001, 2002, 2006 VLC authors and VideoLAN
5 * $Id$
6 *
7 * Authors: Laurent Aimar <fenrir@via.ecp.fr>
8 * Eric Petit <titer@videolan.org>
9 * Gildas Bazin <gbazin@videolan.org>
10 * Derk-Jan Hartman <hartman at videolan dot org>
11 *
12 * This program is free software; you can redistribute it and/or modify it
13 * under the terms of the GNU Lesser General Public License as published by
14 * the Free Software Foundation; either version 2.1 of the License, or
15 * (at your option) any later version.
16 *
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU Lesser General Public License for more details.
21 *
22 * You should have received a copy of the GNU Lesser General Public License
23 * along with this program; if not, write to the Free Software Foundation,
24 * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
25 *****************************************************************************/
26
27 /*****************************************************************************
28 * Preamble
29 *****************************************************************************/
30
31 #ifdef HAVE_CONFIG_H
32 # include "config.h"
33 #endif
34
35 #include <vlc_common.h>
36 #include <vlc_plugin.h>
37 #include <vlc_sout.h>
38 #include <vlc_codec.h>
39 #include <vlc_block.h>
40
41 #include <vlc_block_helper.h>
42 #include <vlc_bits.h>
43 #include "h264_nal.h"
44 #include "h264_slice.h"
45 #include "hxxx_nal.h"
46 #include "hxxx_sei.h"
47 #include "hxxx_common.h"
48 #include "packetizer_helper.h"
49 #include "startcode_helper.h"
50
51 #include <limits.h>
52
53 /*****************************************************************************
54 * Module descriptor
55 *****************************************************************************/
56 static int Open ( vlc_object_t * );
57 static void Close( vlc_object_t * );
58
59 vlc_module_begin ()
60 set_category( CAT_SOUT )
61 set_subcategory( SUBCAT_SOUT_PACKETIZER )
62 set_description( N_("H.264 video packetizer") )
63 set_capability( "packetizer", 50 )
64 set_callbacks( Open, Close )
65 vlc_module_end ()
66
67
68 /****************************************************************************
69 * Local prototypes
70 ****************************************************************************/
71
72 struct decoder_sys_t
73 {
74 /* */
75 packetizer_t packetizer;
76
77 /* */
78 bool b_slice;
79 struct
80 {
81 block_t *p_head;
82 block_t **pp_append;
83 } frame, leading;
84
85 /* a new sps/pps can be transmitted outside of iframes */
86 bool b_new_sps;
87 bool b_new_pps;
88
89 struct
90 {
91 block_t *p_block;
92 h264_sequence_parameter_set_t *p_sps;
93 } sps[H264_SPS_ID_MAX + 1];
94 struct
95 {
96 block_t *p_block;
97 h264_picture_parameter_set_t *p_pps;
98 } pps[H264_PPS_ID_MAX + 1];
99 const h264_sequence_parameter_set_t *p_active_sps;
100 const h264_picture_parameter_set_t *p_active_pps;
101
102 /* avcC data */
103 uint8_t i_avcC_length_size;
104
105 /* From SEI for current frame */
106 uint8_t i_pic_struct;
107 uint8_t i_dpb_output_delay;
108 unsigned i_recovery_frame_cnt;
109
110 /* Useful values of the Slice Header */
111 h264_slice_t slice;
112
113 /* */
114 int i_next_block_flags;
115 bool b_recovered;
116 unsigned i_recoveryfnum;
117
118 /* POC */
119 h264_poc_context_t pocctx;
120 struct
121 {
122 mtime_t pts;
123 int num;
124 } prevdatedpoc;
125
126 mtime_t i_frame_pts;
127 mtime_t i_frame_dts;
128
129 date_t dts;
130
131 /* */
132 cc_storage_t *p_ccs;
133 };
134
135 #define BLOCK_FLAG_PRIVATE_AUD (1 << BLOCK_FLAG_PRIVATE_SHIFT)
136 #define BLOCK_FLAG_PRIVATE_SEI (2 << BLOCK_FLAG_PRIVATE_SHIFT)
137 #define BLOCK_FLAG_DROP (4 << BLOCK_FLAG_PRIVATE_SHIFT)
138
139 static block_t *Packetize( decoder_t *, block_t ** );
140 static block_t *PacketizeAVC1( decoder_t *, block_t ** );
141 static block_t *GetCc( decoder_t *p_dec, decoder_cc_desc_t * );
142 static void PacketizeFlush( decoder_t * );
143
144 static void PacketizeReset( void *p_private, bool b_broken );
145 static block_t *PacketizeParse( void *p_private, bool *pb_ts_used, block_t * );
146 static int PacketizeValidate( void *p_private, block_t * );
147
148 static block_t *ParseNALBlock( decoder_t *, bool *pb_ts_used, block_t * );
149
150 static block_t *OutputPicture( decoder_t *p_dec );
151 static void PutSPS( decoder_t *p_dec, block_t *p_frag );
152 static void PutPPS( decoder_t *p_dec, block_t *p_frag );
153 static bool ParseSliceHeader( decoder_t *p_dec, const block_t *p_frag, h264_slice_t *p_slice );
154 static bool ParseSeiCallback( const hxxx_sei_data_t *, void * );
155
156
157 static const uint8_t p_h264_startcode[3] = { 0x00, 0x00, 0x01 };
158
159 /*****************************************************************************
160 * Helpers
161 *****************************************************************************/
162
163 static void StoreSPS( decoder_sys_t *p_sys, uint8_t i_id,
164 block_t *p_block, h264_sequence_parameter_set_t *p_sps )
165 {
166 if( p_sys->sps[i_id].p_block )
167 block_Release( p_sys->sps[i_id].p_block );
168 if( p_sys->sps[i_id].p_sps )
169 h264_release_sps( p_sys->sps[i_id].p_sps );
170 if( p_sys->sps[i_id].p_sps == p_sys->p_active_sps )
171 p_sys->p_active_sps = NULL;
172 p_sys->sps[i_id].p_block = p_block;
173 p_sys->sps[i_id].p_sps = p_sps;
174 }
175
176 static void StorePPS( decoder_sys_t *p_sys, uint8_t i_id,
177 block_t *p_block, h264_picture_parameter_set_t *p_pps )
178 {
179 if( p_sys->pps[i_id].p_block )
180 block_Release( p_sys->pps[i_id].p_block );
181 if( p_sys->pps[i_id].p_pps )
182 h264_release_pps( p_sys->pps[i_id].p_pps );
183 if( p_sys->pps[i_id].p_pps == p_sys->p_active_pps )
184 p_sys->p_active_pps = NULL;
185 p_sys->pps[i_id].p_block = p_block;
186 p_sys->pps[i_id].p_pps = p_pps;
187 }
188
189 static void ActivateSets( decoder_t *p_dec, const h264_sequence_parameter_set_t *p_sps,
190 const h264_picture_parameter_set_t *p_pps )
191 {
192 decoder_sys_t *p_sys = p_dec->p_sys;
193
194 p_sys->p_active_pps = p_pps;
195 p_sys->p_active_sps = p_sps;
196
197 if( p_sps )
198 {
199 p_dec->fmt_out.i_profile = p_sps->i_profile;
200 p_dec->fmt_out.i_level = p_sps->i_level;
201
202 (void) h264_get_picture_size( p_sps, &p_dec->fmt_out.video.i_width,
203 &p_dec->fmt_out.video.i_height,
204 &p_dec->fmt_out.video.i_visible_width,
205 &p_dec->fmt_out.video.i_visible_height );
206
207 if( p_sps->vui.i_sar_num != 0 && p_sps->vui.i_sar_den != 0 )
208 {
209 p_dec->fmt_out.video.i_sar_num = p_sps->vui.i_sar_num;
210 p_dec->fmt_out.video.i_sar_den = p_sps->vui.i_sar_den;
211 }
212
213 if( p_sps->vui.b_valid )
214 {
215 if( !p_dec->fmt_in.video.i_frame_rate_base &&
216 p_sps->vui.i_num_units_in_tick > 0 && p_sps->vui.i_time_scale > 1 )
217 {
218 const unsigned i_rate_base = p_sps->vui.i_num_units_in_tick;
219 const unsigned i_rate = p_sps->vui.i_time_scale >> 1; /* num_clock_ts == 2 */
220 if( i_rate_base != p_dec->fmt_out.video.i_frame_rate_base ||
221 i_rate != p_dec->fmt_out.video.i_frame_rate )
222 {
223 p_dec->fmt_out.video.i_frame_rate_base = i_rate_base;
224 p_dec->fmt_out.video.i_frame_rate = i_rate;
225 date_Change( &p_sys->dts, p_sps->vui.i_time_scale, p_sps->vui.i_num_units_in_tick );
226 }
227 }
228 if( p_dec->fmt_in.video.primaries == COLOR_PRIMARIES_UNDEF )
229 h264_get_colorimetry( p_sps, &p_dec->fmt_out.video.primaries,
230 &p_dec->fmt_out.video.transfer,
231 &p_dec->fmt_out.video.space,
232 &p_dec->fmt_out.video.b_color_range_full );
233 }
234 }
235 }
236
237 static bool IsFirstVCLNALUnit( const h264_slice_t *p_prev, const h264_slice_t *p_cur )
238 {
239 /* Detection of the first VCL NAL unit of a primary coded picture
240 * (cf. 7.4.1.2.4) */
241 if( p_cur->i_frame_num != p_prev->i_frame_num ||
242 p_cur->i_pic_parameter_set_id != p_prev->i_pic_parameter_set_id ||
243 p_cur->i_field_pic_flag != p_prev->i_field_pic_flag ||
244 !p_cur->i_nal_ref_idc != !p_prev->i_nal_ref_idc )
245 return true;
246 if( (p_cur->i_bottom_field_flag != -1) &&
247 (p_prev->i_bottom_field_flag != -1) &&
248 (p_cur->i_bottom_field_flag != p_prev->i_bottom_field_flag) )
249 return true;
250 if( p_cur->i_pic_order_cnt_type == 0 &&
251 ( p_cur->i_pic_order_cnt_lsb != p_prev->i_pic_order_cnt_lsb ||
252 p_cur->i_delta_pic_order_cnt_bottom != p_prev->i_delta_pic_order_cnt_bottom ) )
253 return true;
254 else if( p_cur->i_pic_order_cnt_type == 1 &&
255 ( p_cur->i_delta_pic_order_cnt0 != p_prev->i_delta_pic_order_cnt0 ||
256 p_cur->i_delta_pic_order_cnt1 != p_prev->i_delta_pic_order_cnt1 ) )
257 return true;
258 if( ( p_cur->i_nal_type == H264_NAL_SLICE_IDR || p_prev->i_nal_type == H264_NAL_SLICE_IDR ) &&
259 ( p_cur->i_nal_type != p_prev->i_nal_type || p_cur->i_idr_pic_id != p_prev->i_idr_pic_id ) )
260 return true;
261
262 return false;
263 }
264
265 static void DropStoredNAL( decoder_sys_t *p_sys )
266 {
267 block_ChainRelease( p_sys->frame.p_head );
268 block_ChainRelease( p_sys->leading.p_head );
269 p_sys->frame.p_head = NULL;
270 p_sys->frame.pp_append = &p_sys->frame.p_head;
271 p_sys->leading.p_head = NULL;
272 p_sys->leading.pp_append = &p_sys->leading.p_head;
273 }
274
275 /*****************************************************************************
276 * Open: probe the packetizer and return score
277 * When opening after demux, the packetizer is only loaded AFTER the decoder
278 * That means that what you set in fmt_out is ignored by the decoder in this special case
279 *****************************************************************************/
280 static int Open( vlc_object_t *p_this )
281 {
282 decoder_t *p_dec = (decoder_t*)p_this;
283 decoder_sys_t *p_sys;
284 int i;
285
286 const bool b_avc = (p_dec->fmt_in.i_original_fourcc == VLC_FOURCC( 'a', 'v', 'c', '1' ));
287
288 if( p_dec->fmt_in.i_codec != VLC_CODEC_H264 )
289 return VLC_EGENERIC;
290 if( b_avc && p_dec->fmt_in.i_extra < 7 )
291 return VLC_EGENERIC;
292
293 /* Allocate the memory needed to store the decoder's structure */
294 if( ( p_dec->p_sys = p_sys = malloc( sizeof(decoder_sys_t) ) ) == NULL )
295 {
296 return VLC_ENOMEM;
297 }
298
299 p_sys->p_ccs = cc_storage_new();
300 if( unlikely(!p_sys->p_ccs) )
301 {
302 free( p_dec->p_sys );
303 return VLC_ENOMEM;
304 }
305
306 packetizer_Init( &p_sys->packetizer,
307 p_h264_startcode, sizeof(p_h264_startcode), startcode_FindAnnexB,
308 p_h264_startcode, 1, 5,
309 PacketizeReset, PacketizeParse, PacketizeValidate, p_dec );
310
311 p_sys->b_slice = false;
312 p_sys->frame.p_head = NULL;
313 p_sys->frame.pp_append = &p_sys->frame.p_head;
314 p_sys->leading.p_head = NULL;
315 p_sys->leading.pp_append = &p_sys->leading.p_head;
316 p_sys->b_new_sps = false;
317 p_sys->b_new_pps = false;
318
319 for( i = 0; i <= H264_SPS_ID_MAX; i++ )
320 {
321 p_sys->sps[i].p_sps = NULL;
322 p_sys->sps[i].p_block = NULL;
323 }
324 p_sys->p_active_sps = NULL;
325 for( i = 0; i <= H264_PPS_ID_MAX; i++ )
326 {
327 p_sys->pps[i].p_pps = NULL;
328 p_sys->pps[i].p_block = NULL;
329 }
330 p_sys->p_active_pps = NULL;
331 p_sys->i_recovery_frame_cnt = UINT_MAX;
332
333 h264_slice_init( &p_sys->slice );
334
335 p_sys->i_next_block_flags = 0;
336 p_sys->b_recovered = false;
337 p_sys->i_recoveryfnum = UINT_MAX;
338 p_sys->i_frame_dts = VLC_TS_INVALID;
339 p_sys->i_frame_pts = VLC_TS_INVALID;
340 p_sys->i_dpb_output_delay = 0;
341
342 /* POC */
343 h264_poc_context_init( &p_sys->pocctx );
344 p_sys->prevdatedpoc.pts = VLC_TS_INVALID;
345
346 date_Init( &p_sys->dts, 30000 * 2, 1001 );
347 date_Set( &p_sys->dts, VLC_TS_INVALID );
348
349 /* Setup properties */
350 es_format_Copy( &p_dec->fmt_out, &p_dec->fmt_in );
351 p_dec->fmt_out.i_codec = VLC_CODEC_H264;
352 p_dec->fmt_out.b_packetized = true;
353
354 if( p_dec->fmt_in.video.i_frame_rate_base &&
355 p_dec->fmt_in.video.i_frame_rate &&
356 p_dec->fmt_in.video.i_frame_rate <= UINT_MAX / 2 )
357 {
358 date_Change( &p_sys->dts, p_dec->fmt_in.video.i_frame_rate * 2,
359 p_dec->fmt_in.video.i_frame_rate_base );
360 }
361
362 if( b_avc )
363 {
364 /* This type of stream is produced by mp4 and matroska
365 * when we want to store it in another streamformat, you need to convert
366 * The fmt_in.p_extra should ALWAYS contain the avcC
367 * The fmt_out.p_extra should contain all the SPS and PPS with 4 byte startcodes */
368 if( h264_isavcC( p_dec->fmt_in.p_extra, p_dec->fmt_in.i_extra ) )
369 {
370 free( p_dec->fmt_out.p_extra );
371 size_t i_size;
372 p_dec->fmt_out.p_extra = h264_avcC_to_AnnexB_NAL( p_dec->fmt_in.p_extra,
373 p_dec->fmt_in.i_extra,
374 &i_size,
375 &p_sys->i_avcC_length_size );
376 p_dec->fmt_out.i_extra = i_size;
377 p_sys->b_recovered = !!p_dec->fmt_out.i_extra;
378
379 if(!p_dec->fmt_out.p_extra)
380 {
381 msg_Err( p_dec, "Invalid AVC extradata");
382 Close( p_this );
383 return VLC_EGENERIC;
384 }
385 }
386 else
387 {
388 msg_Err( p_dec, "Invalid or missing AVC extradata");
389 Close( p_this );
390 return VLC_EGENERIC;
391 }
392
393 /* Set callback */
394 p_dec->pf_packetize = PacketizeAVC1;
395 }
396 else
397 {
398 /* This type of stream contains data with 3 of 4 byte startcodes
399 * The fmt_in.p_extra MAY contain SPS/PPS with 4 byte startcodes
400 * The fmt_out.p_extra should be the same */
401
402 /* Set callback */
403 p_dec->pf_packetize = Packetize;
404 }
405
406 /* */
407 if( p_dec->fmt_out.i_extra > 0 )
408 {
409 packetizer_Header( &p_sys->packetizer,
410 p_dec->fmt_out.p_extra, p_dec->fmt_out.i_extra );
411 }
412
413 if( b_avc )
414 {
415 /* FIXME: that's not correct for every AVC */
416 if( !p_sys->b_new_pps || !p_sys->b_new_sps )
417 {
418 msg_Err( p_dec, "Invalid or missing SPS %d or PPS %d in AVC extradata",
419 p_sys->b_new_sps, p_sys->b_new_pps );
420 Close( p_this );
421 return VLC_EGENERIC;
422 }
423
424 msg_Dbg( p_dec, "Packetizer fed with AVC, nal length size=%d",
425 p_sys->i_avcC_length_size );
426 }
427
428 /* CC are the same for H264/AVC in T35 sections (ETSI TS 101 154) */
429 p_dec->pf_get_cc = GetCc;
430 p_dec->pf_flush = PacketizeFlush;
431
432 return VLC_SUCCESS;
433 }
434
435 /*****************************************************************************
436 * Close: clean up the packetizer
437 *****************************************************************************/
438 static void Close( vlc_object_t *p_this )
439 {
440 decoder_t *p_dec = (decoder_t*)p_this;
441 decoder_sys_t *p_sys = p_dec->p_sys;
442 int i;
443
444 DropStoredNAL( p_sys );
445 for( i = 0; i <= H264_SPS_ID_MAX; i++ )
446 StoreSPS( p_sys, i, NULL, NULL );
447 for( i = 0; i <= H264_PPS_ID_MAX; i++ )
448 StorePPS( p_sys, i, NULL, NULL );
449
450 packetizer_Clean( &p_sys->packetizer );
451
452 cc_storage_delete( p_sys->p_ccs );
453
454 free( p_sys );
455 }
456
457 static void PacketizeFlush( decoder_t *p_dec )
458 {
459 decoder_sys_t *p_sys = p_dec->p_sys;
460
461 packetizer_Flush( &p_sys->packetizer );
462 }
463
464 /****************************************************************************
465 * Packetize: the whole thing
466 * Search for the startcodes 3 or more bytes
467 * Feed ParseNALBlock ALWAYS with 4 byte startcode prepended NALs
468 ****************************************************************************/
469 static block_t *Packetize( decoder_t *p_dec, block_t **pp_block )
470 {
471 decoder_sys_t *p_sys = p_dec->p_sys;
472
473 return packetizer_Packetize( &p_sys->packetizer, pp_block );
474 }
475
476 /****************************************************************************
477 * PacketizeAVC1: Takes VCL blocks of data and creates annexe B type NAL stream
478 * Will always use 4 byte 0 0 0 1 startcodes
479 * Will prepend a SPS and PPS before each keyframe
480 ****************************************************************************/
481 static block_t *PacketizeAVC1( decoder_t *p_dec, block_t **pp_block )
482 {
483 decoder_sys_t *p_sys = p_dec->p_sys;
484
485 return PacketizeXXC1( p_dec, p_sys->i_avcC_length_size,
486 pp_block, ParseNALBlock );
487 }
488
489 /*****************************************************************************
490 * GetCc:
491 *****************************************************************************/
492 static block_t *GetCc( decoder_t *p_dec, decoder_cc_desc_t *p_desc )
493 {
494 return cc_storage_get_current( p_dec->p_sys->p_ccs, p_desc );
495 }
496
497 /****************************************************************************
498 * Helpers
499 ****************************************************************************/
500 static void ResetOutputVariables( decoder_sys_t *p_sys )
501 {
502 p_sys->i_frame_dts = VLC_TS_INVALID;
503 p_sys->i_frame_pts = VLC_TS_INVALID;
504 p_sys->slice.type = H264_SLICE_TYPE_UNKNOWN;
505 p_sys->b_new_sps = false;
506 p_sys->b_new_pps = false;
507 p_sys->b_slice = false;
508 /* From SEI */
509 p_sys->i_dpb_output_delay = 0;
510 p_sys->i_pic_struct = UINT8_MAX;
511 p_sys->i_recovery_frame_cnt = UINT_MAX;
512 }
513
514 static void PacketizeReset( void *p_private, bool b_broken )
515 {
516 decoder_t *p_dec = p_private;
517 decoder_sys_t *p_sys = p_dec->p_sys;
518
519 if( b_broken || !p_sys->b_slice )
520 {
521 DropStoredNAL( p_sys );
522 ResetOutputVariables( p_sys );
523 p_sys->p_active_pps = NULL;
524 p_sys->p_active_sps = NULL;
525 /* POC */
526 h264_poc_context_init( &p_sys->pocctx );
527 p_sys->prevdatedpoc.pts = VLC_TS_INVALID;
528 }
529 p_sys->i_next_block_flags = BLOCK_FLAG_DISCONTINUITY;
530 p_sys->b_recovered = false;
531 p_sys->i_recoveryfnum = UINT_MAX;
532 date_Set( &p_sys->dts, VLC_TS_INVALID );
533 }
534 static block_t *PacketizeParse( void *p_private, bool *pb_ts_used, block_t *p_block )
535 {
536 decoder_t *p_dec = p_private;
537
538 /* Remove trailing 0 bytes */
539 while( p_block->i_buffer > 5 && p_block->p_buffer[p_block->i_buffer-1] == 0x00 )
540 p_block->i_buffer--;
541
542 return ParseNALBlock( p_dec, pb_ts_used, p_block );
543 }
544 static int PacketizeValidate( void *p_private, block_t *p_au )
545 {
546 VLC_UNUSED(p_private);
547 VLC_UNUSED(p_au);
548 return VLC_SUCCESS;
549 }
550
551 /*****************************************************************************
552 * ParseNALBlock: parses annexB type NALs
553 * All p_frag blocks are required to start with 0 0 0 1 4-byte startcode
554 *****************************************************************************/
555 static block_t *ParseNALBlock( decoder_t *p_dec, bool *pb_ts_used, block_t *p_frag )
556 {
557 decoder_sys_t *p_sys = p_dec->p_sys;
558 block_t *p_pic = NULL;
559
560 const int i_nal_type = p_frag->p_buffer[4]&0x1f;
561 const mtime_t i_frag_dts = p_frag->i_dts;
562 const mtime_t i_frag_pts = p_frag->i_pts;
563
564 if( p_sys->b_slice && (!p_sys->p_active_pps || !p_sys->p_active_sps) )
565 {
566 msg_Warn( p_dec, "waiting for SPS/PPS" );
567
568 /* Reset context */
569 DropStoredNAL( p_sys );
570 ResetOutputVariables( p_sys );
571 cc_storage_reset( p_sys->p_ccs );
572 }
573
574 switch( i_nal_type )
575 {
576 /*** Slices ***/
577 case H264_NAL_SLICE:
578 case H264_NAL_SLICE_DPA:
579 case H264_NAL_SLICE_DPB:
580 case H264_NAL_SLICE_DPC:
581 case H264_NAL_SLICE_IDR:
582 {
583 h264_slice_t newslice;
584
585 if( i_nal_type == H264_NAL_SLICE_IDR )
586 {
587 p_sys->b_recovered = true;
588 p_sys->i_recovery_frame_cnt = UINT_MAX;
589 p_sys->i_recoveryfnum = UINT_MAX;
590 }
591
592 if( ParseSliceHeader( p_dec, p_frag, &newslice ) )
593 {
594 /* Only IDR carries the id, to be propagated */
595 if( newslice.i_idr_pic_id == -1 )
596 newslice.i_idr_pic_id = p_sys->slice.i_idr_pic_id;
597
598 bool b_new_picture = IsFirstVCLNALUnit( &p_sys->slice, &newslice );
599 if( b_new_picture )
600 {
601 /* Parse SEI for that frame now we should have matched SPS/PPS */
602 for( block_t *p_sei = p_sys->leading.p_head; p_sei; p_sei = p_sei->p_next )
603 {
604 if( (p_sei->i_flags & BLOCK_FLAG_PRIVATE_SEI) == 0 )
605 continue;
606 HxxxParse_AnnexB_SEI( p_sei->p_buffer, p_sei->i_buffer,
607 1 /* nal header */, ParseSeiCallback, p_dec );
608 }
609
610 if( p_sys->b_slice )
611 p_pic = OutputPicture( p_dec );
612 }
613
614 /* */
615 p_sys->slice = newslice;
616 }
617 else
618 {
619 p_sys->p_active_pps = NULL;
620 /* Fragment will be discarded later on */
621 }
622 p_sys->b_slice = true;
623
624 block_ChainLastAppend( &p_sys->frame.pp_append, p_frag );
625 } break;
626
627 /*** Prefix NALs ***/
628
629 case H264_NAL_AU_DELIMITER:
630 if( p_sys->b_slice )
631 p_pic = OutputPicture( p_dec );
632
633 /* clear junk if no pic, we're always the first nal */
634 DropStoredNAL( p_sys );
635
636 p_frag->i_flags |= BLOCK_FLAG_PRIVATE_AUD;
637
638 block_ChainLastAppend( &p_sys->leading.pp_append, p_frag );
639 break;
640
641 case H264_NAL_SPS:
642 case H264_NAL_PPS:
643 if( p_sys->b_slice )
644 p_pic = OutputPicture( p_dec );
645
646 /* Stored for insert on keyframes */
647 if( i_nal_type == H264_NAL_SPS )
648 {
649 PutSPS( p_dec, p_frag );
650 p_sys->b_new_sps = true;
651 }
652 else
653 {
654 PutPPS( p_dec, p_frag );
655 p_sys->b_new_pps = true;
656 }
657 break;
658
659 case H264_NAL_SEI:
660 if( p_sys->b_slice )
661 p_pic = OutputPicture( p_dec );
662
663 p_frag->i_flags |= BLOCK_FLAG_PRIVATE_SEI;
664 block_ChainLastAppend( &p_sys->leading.pp_append, p_frag );
665 break;
666
667 case H264_NAL_SPS_EXT:
668 case H264_NAL_PREFIX: /* first slice/VCL associated data */
669 case H264_NAL_SUBSET_SPS:
670 case H264_NAL_DEPTH_PS:
671 case H264_NAL_RESERVED_17:
672 case H264_NAL_RESERVED_18:
673 if( p_sys->b_slice )
674 p_pic = OutputPicture( p_dec );
675
676 block_ChainLastAppend( &p_sys->leading.pp_append, p_frag );
677 break;
678
679 /*** Suffix NALs ***/
680
681 case H264_NAL_END_OF_SEQ:
682 case H264_NAL_END_OF_STREAM:
683 /* Early end of packetization */
684 block_ChainLastAppend( &p_sys->frame.pp_append, p_frag );
685
686 /* important for still pictures/menus */
687 p_sys->i_next_block_flags |= BLOCK_FLAG_END_OF_SEQUENCE;
688 if( p_sys->b_slice )
689 p_pic = OutputPicture( p_dec );
690 break;
691
692 case H264_NAL_SLICE_WP: // post
693 case H264_NAL_UNKNOWN:
694 case H264_NAL_FILLER_DATA:
695 case H264_NAL_SLICE_EXT:
696 case H264_NAL_SLICE_3D_EXT:
697 case H264_NAL_RESERVED_22:
698 case H264_NAL_RESERVED_23:
699 default: /* others 24..31, including unknown */
700 block_ChainLastAppend( &p_sys->frame.pp_append, p_frag );
701 break;
702 }
703
704 *pb_ts_used = false;
705 if( p_sys->i_frame_dts <= VLC_TS_INVALID &&
706 p_sys->i_frame_pts <= VLC_TS_INVALID )
707 {
708 p_sys->i_frame_dts = i_frag_dts;
709 p_sys->i_frame_pts = i_frag_pts;
710 *pb_ts_used = true;
711 if( i_frag_dts > VLC_TS_INVALID )
712 date_Set( &p_sys->dts, i_frag_dts );
713 }
714
715 if( p_pic && (p_pic->i_flags & BLOCK_FLAG_DROP) )
716 {
717 block_Release( p_pic );
718 p_pic = NULL;
719 }
720
721 return p_pic;
722 }
723
724 static block_t *OutputPicture( decoder_t *p_dec )
725 {
726 decoder_sys_t *p_sys = p_dec->p_sys;
727 block_t *p_pic = NULL;
728 block_t **pp_pic_last = &p_pic;
729
730 if( unlikely(!p_sys->frame.p_head) )
731 {
732 assert( p_sys->frame.p_head );
733 DropStoredNAL( p_sys );
734 ResetOutputVariables( p_sys );
735 cc_storage_reset( p_sys->p_ccs );
736 return NULL;
737 }
738
739 /* Bind matched/referred PPS and SPS */
740 const h264_picture_parameter_set_t *p_pps = p_sys->p_active_pps;
741 const h264_sequence_parameter_set_t *p_sps = p_sys->p_active_sps;
742 if( !p_pps || !p_sps )
743 {
744 DropStoredNAL( p_sys );
745 ResetOutputVariables( p_sys );
746 cc_storage_reset( p_sys->p_ccs );
747 return NULL;
748 }
749
750 if( !p_sys->b_recovered && p_sys->i_recoveryfnum == UINT_MAX &&
751 p_sys->i_recovery_frame_cnt == UINT_MAX && p_sys->slice.type == H264_SLICE_TYPE_I )
752 {
753 /* No way to recover using SEI, just sync on I Slice */
754 p_sys->b_recovered = true;
755 }
756
757 bool b_need_sps_pps = p_sys->slice.type == H264_SLICE_TYPE_I &&
758 p_sys->p_active_pps && p_sys->p_active_sps;
759
760 /* Handle SEI recovery */
761 if ( !p_sys->b_recovered && p_sys->i_recovery_frame_cnt != UINT_MAX &&
762 p_sys->i_recoveryfnum == UINT_MAX )
763 {
764 p_sys->i_recoveryfnum = p_sys->slice.i_frame_num + p_sys->i_recovery_frame_cnt;
765 b_need_sps_pps = true; /* SPS/PPS must be inserted for SEI recovery */
766 msg_Dbg( p_dec, "Recovering using SEI, prerolling %u reference pics", p_sys->i_recovery_frame_cnt );
767 }
768
769 if( p_sys->i_recoveryfnum != UINT_MAX )
770 {
771 assert(p_sys->b_recovered == false);
772 const unsigned maxFrameNum = 1 << (p_sps->i_log2_max_frame_num + 4);
773 if( (p_sys->i_recoveryfnum > maxFrameNum &&
774 (unsigned)p_sys->slice.i_frame_num <= maxFrameNum / 2 &&
775 (unsigned)p_sys->slice.i_frame_num >= p_sys->i_recoveryfnum % maxFrameNum ) ||
776 (unsigned)p_sys->slice.i_frame_num >= p_sys->i_recoveryfnum )
777 {
778 p_sys->i_recoveryfnum = UINT_MAX;
779 p_sys->b_recovered = true;
780 msg_Dbg( p_dec, "Recovery from SEI recovery point complete" );
781 }
782 }
783
784 /* Gather PPS/SPS if required */
785 block_t *p_xpsnal = NULL;
786 block_t **pp_xpsnal_tail = &p_xpsnal;
787 if( b_need_sps_pps || p_sys->b_new_sps || p_sys->b_new_pps )
788 {
789 for( int i = 0; i <= H264_SPS_ID_MAX && (b_need_sps_pps || p_sys->b_new_sps); i++ )
790 {
791 if( p_sys->sps[i].p_block )
792 block_ChainLastAppend( &pp_xpsnal_tail, block_Duplicate( p_sys->sps[i].p_block ) );
793 }
794 for( int i = 0; i < H264_PPS_ID_MAX && (b_need_sps_pps || p_sys->b_new_pps); i++ )
795 {
796 if( p_sys->pps[i].p_block )
797 block_ChainLastAppend( &pp_xpsnal_tail, block_Duplicate( p_sys->pps[i].p_block ) );
798 }
799 }
800
801 /* Now rebuild NAL Sequence, inserting PPS/SPS if any */
802 if( p_sys->frame.p_head->i_flags & BLOCK_FLAG_PRIVATE_AUD )
803 {
804 block_t *p_au = p_sys->frame.p_head;
805 p_sys->frame.p_head = p_au->p_next;
806 p_au->p_next = NULL;
807 block_ChainLastAppend( &pp_pic_last, p_au );
808 }
809
810 if( p_xpsnal )
811 block_ChainLastAppend( &pp_pic_last, p_xpsnal );
812
813 if( p_sys->leading.p_head )
814 block_ChainLastAppend( &pp_pic_last, p_sys->leading.p_head );
815
816 assert( p_sys->frame.p_head );
817 if( p_sys->frame.p_head )
818 block_ChainLastAppend( &pp_pic_last, p_sys->frame.p_head );
819
820 /* Reset chains, now empty */
821 p_sys->frame.p_head = NULL;
822 p_sys->frame.pp_append = &p_sys->frame.p_head;
823 p_sys->leading.p_head = NULL;
824 p_sys->leading.pp_append = &p_sys->leading.p_head;
825
826 p_pic = block_ChainGather( p_pic );
827
828 if( !p_pic )
829 {
830 ResetOutputVariables( p_sys );
831 cc_storage_reset( p_sys->p_ccs );
832 return NULL;
833 }
834
835 /* clear up flags gathered */
836 p_pic->i_flags &= ~BLOCK_FLAG_PRIVATE_MASK;
837
838 /* for PTS Fixup, interlaced fields (multiple AU/block) */
839 int tFOC = 0, bFOC = 0, PictureOrderCount = 0;
840 h264_compute_poc( p_sps, &p_sys->slice, &p_sys->pocctx, &PictureOrderCount, &tFOC, &bFOC );
841
842 unsigned i_num_clock_ts = h264_get_num_ts( p_sps, &p_sys->slice, p_sys->i_pic_struct, tFOC, bFOC );
843
844 if( p_sps->frame_mbs_only_flag == 0 && p_sps->vui.b_pic_struct_present_flag )
845 {
846 switch( p_sys->i_pic_struct )
847 {
848 /* Top and Bottom field slices */
849 case 1:
850 case 2:
851 p_pic->i_flags |= BLOCK_FLAG_SINGLE_FIELD;
852 p_pic->i_flags |= (!p_sys->slice.i_bottom_field_flag) ? BLOCK_FLAG_TOP_FIELD_FIRST
853 : BLOCK_FLAG_BOTTOM_FIELD_FIRST;
854 break;
855 /* Each of the following slices contains multiple fields */
856 case 3:
857 p_pic->i_flags |= BLOCK_FLAG_TOP_FIELD_FIRST;
858 break;
859 case 4:
860 p_pic->i_flags |= BLOCK_FLAG_BOTTOM_FIELD_FIRST;
861 break;
862 case 5:
863 p_pic->i_flags |= BLOCK_FLAG_TOP_FIELD_FIRST;
864 break;
865 case 6:
866 p_pic->i_flags |= BLOCK_FLAG_BOTTOM_FIELD_FIRST;
867 break;
868 default:
869 break;
870 }
871 }
872
873 /* set dts/pts to current block timestamps */
874 p_pic->i_dts = p_sys->i_frame_dts;
875 p_pic->i_pts = p_sys->i_frame_pts;
876
877 /* Fixup missing timestamps after split (multiple AU/block)*/
878 if( p_pic->i_dts <= VLC_TS_INVALID )
879 p_pic->i_dts = date_Get( &p_sys->dts );
880
881 if( p_sys->slice.type == H264_SLICE_TYPE_I )
882 p_sys->prevdatedpoc.pts = VLC_TS_INVALID;
883
884 if( p_pic->i_pts == VLC_TS_INVALID )
885 {
886 if( p_sys->prevdatedpoc.pts > VLC_TS_INVALID &&
887 date_Get( &p_sys->dts ) != VLC_TS_INVALID )
888 {
889 date_t pts = p_sys->dts;
890 date_Set( &pts, p_sys->prevdatedpoc.pts );
891
892 int diff = tFOC - p_sys->prevdatedpoc.num;
893 if( diff > 0 )
894 date_Increment( &pts, diff );
895 else
896 date_Decrement( &pts, -diff );
897
898 p_pic->i_pts = date_Get( &pts );
899 }
900 /* In case there's no PTS at all */
901 else if( p_sys->slice.i_nal_ref_idc == 0 &&
902 p_sys->slice.type == H264_SLICE_TYPE_B )
903 {
904 p_pic->i_pts = p_pic->i_dts;
905 }
906 else if( p_sys->slice.type == H264_SLICE_TYPE_I &&
907 date_Get( &p_sys->dts ) != VLC_TS_INVALID )
908 {
909 /* Hell no PTS on IDR. We're totally blind */
910 date_t pts = p_sys->dts;
911 date_Increment( &pts, 2 );
912 p_pic->i_pts = date_Get( &pts );
913 }
914 }
915
916 if( p_pic->i_pts > VLC_TS_INVALID )
917 {
918 p_sys->prevdatedpoc.pts = p_pic->i_pts;
919 p_sys->prevdatedpoc.num = PictureOrderCount;
920 }
921
922 if( p_pic->i_length == 0 )
923 {
924 if( p_sps->vui.i_time_scale )
925 {
926 p_pic->i_length = CLOCK_FREQ * i_num_clock_ts *
927 p_sps->vui.i_num_units_in_tick / p_sps->vui.i_time_scale;
928 }
929 else
930 {
931 date_t next = p_sys->dts;
932 date_Increment( &next, i_num_clock_ts );
933 p_pic->i_length = date_Get( &next ) - date_Get( &p_sys->dts );
934 }
935 }
936
937 #if 0
938 msg_Err(p_dec, "F/BOC %d/%d POC %d %d rec %d flags %x ref%d fn %d fp %d %d pts %ld len %ld",
939 tFOC, bFOC, PictureOrderCount,
940 p_sys->slice.type, p_sys->b_recovered, p_pic->i_flags,
941 p_sys->slice.i_nal_ref_idc, p_sys->slice.i_frame_num, p_sys->slice.i_field_pic_flag,
942 p_pic->i_pts - p_pic->i_dts, p_pic->i_pts % (100*CLOCK_FREQ), p_pic->i_length);
943 #endif
944
945 /* save for next pic fixups */
946 if( date_Get( &p_sys->dts ) != VLC_TS_INVALID )
947 {
948 if( p_sys->i_next_block_flags & BLOCK_FLAG_DISCONTINUITY )
949 date_Set( &p_sys->dts, VLC_TS_INVALID );
950 else
951 date_Increment( &p_sys->dts, i_num_clock_ts );
952 }
953
954 if( p_pic )
955 {
956 p_pic->i_flags |= p_sys->i_next_block_flags;
957 p_sys->i_next_block_flags = 0;
958 }
959
960 switch( p_sys->slice.type )
961 {
962 case H264_SLICE_TYPE_P:
963 p_pic->i_flags |= BLOCK_FLAG_TYPE_P;
964 break;
965 case H264_SLICE_TYPE_B:
966 p_pic->i_flags |= BLOCK_FLAG_TYPE_B;
967 break;
968 case H264_SLICE_TYPE_I:
969 p_pic->i_flags |= BLOCK_FLAG_TYPE_I;
970 default:
971 break;
972 }
973
974 if( !p_sys->b_recovered )
975 {
976 if( p_sys->i_recoveryfnum != UINT_MAX ) /* recovering from SEI */
977 p_pic->i_flags |= BLOCK_FLAG_PREROLL;
978 else
979 p_pic->i_flags |= BLOCK_FLAG_DROP;
980 }
981
982 p_pic->i_flags &= ~BLOCK_FLAG_PRIVATE_AUD;
983
984 /* reset after output */
985 ResetOutputVariables( p_sys );
986
987 /* CC */
988 cc_storage_commit( p_sys->p_ccs, p_pic );
989
990 return p_pic;
991 }
992
993 static void PutSPS( decoder_t *p_dec, block_t *p_frag )
994 {
995 decoder_sys_t *p_sys = p_dec->p_sys;
996
997 const uint8_t *p_buffer = p_frag->p_buffer;
998 size_t i_buffer = p_frag->i_buffer;
999
1000 if( !hxxx_strip_AnnexB_startcode( &p_buffer, &i_buffer ) )
1001 {
1002 block_Release( p_frag );
1003 return;
1004 }
1005
1006 h264_sequence_parameter_set_t *p_sps = h264_decode_sps( p_buffer, i_buffer, true );
1007 if( !p_sps )
1008 {
1009 msg_Warn( p_dec, "invalid SPS" );
1010 block_Release( p_frag );
1011 return;
1012 }
1013
1014 /* We have a new SPS */
1015 if( !p_sys->sps[p_sps->i_id].p_sps )
1016 msg_Dbg( p_dec, "found NAL_SPS (sps_id=%d)", p_sps->i_id );
1017
1018 StoreSPS( p_sys, p_sps->i_id, p_frag, p_sps );
1019 }
1020
1021 static void PutPPS( decoder_t *p_dec, block_t *p_frag )
1022 {
1023 decoder_sys_t *p_sys = p_dec->p_sys;
1024 const uint8_t *p_buffer = p_frag->p_buffer;
1025 size_t i_buffer = p_frag->i_buffer;
1026
1027 if( !hxxx_strip_AnnexB_startcode( &p_buffer, &i_buffer ) )
1028 {
1029 block_Release( p_frag );
1030 return;
1031 }
1032
1033 h264_picture_parameter_set_t *p_pps = h264_decode_pps( p_buffer, i_buffer, true );
1034 if( !p_pps )
1035 {
1036 msg_Warn( p_dec, "invalid PPS" );
1037 block_Release( p_frag );
1038 return;
1039 }
1040
1041 /* We have a new PPS */
1042 if( !p_sys->pps[p_pps->i_id].p_pps )
1043 msg_Dbg( p_dec, "found NAL_PPS (pps_id=%d sps_id=%d)", p_pps->i_id, p_pps->i_sps_id );
1044
1045 StorePPS( p_sys, p_pps->i_id, p_frag, p_pps );
1046 }
1047
1048 static void GetSPSPPS( uint8_t i_pps_id, void *priv,
1049 const h264_sequence_parameter_set_t **pp_sps,
1050 const h264_picture_parameter_set_t **pp_pps )
1051 {
1052 decoder_sys_t *p_sys = priv;
1053
1054 *pp_pps = p_sys->pps[i_pps_id].p_pps;
1055 if( *pp_pps == NULL )
1056 *pp_sps = NULL;
1057 else
1058 *pp_sps = p_sys->sps[(*pp_pps)->i_sps_id].p_sps;
1059 }
1060
1061 static bool ParseSliceHeader( decoder_t *p_dec, const block_t *p_frag, h264_slice_t *p_slice )
1062 {
1063 decoder_sys_t *p_sys = p_dec->p_sys;
1064
1065 const uint8_t *p_stripped = p_frag->p_buffer;
1066 size_t i_stripped = p_frag->i_buffer;
1067
1068 if( !hxxx_strip_AnnexB_startcode( &p_stripped, &i_stripped ) || i_stripped < 2 )
1069 return false;
1070
1071 if( !h264_decode_slice( p_stripped, i_stripped, GetSPSPPS, p_sys, p_slice ) )
1072 return false;
1073
1074 const h264_sequence_parameter_set_t *p_sps;
1075 const h264_picture_parameter_set_t *p_pps;
1076 GetSPSPPS( p_slice->i_pic_parameter_set_id, p_sys, &p_sps, &p_pps );
1077 if( unlikely( !p_sps || !p_pps) )
1078 return false;
1079
1080 ActivateSets( p_dec, p_sps, p_pps );
1081
1082 return true;
1083 }
1084
1085 static bool ParseSeiCallback( const hxxx_sei_data_t *p_sei_data, void *cbdata )
1086 {
1087 decoder_t *p_dec = (decoder_t *) cbdata;
1088 decoder_sys_t *p_sys = p_dec->p_sys;
1089
1090 switch( p_sei_data->i_type )
1091 {
1092 /* Look for pic timing */
1093 case HXXX_SEI_PIC_TIMING:
1094 {
1095 const h264_sequence_parameter_set_t *p_sps = p_sys->p_active_sps;
1096 if( unlikely( p_sps == NULL ) )
1097 {
1098 assert( p_sps );
1099 break;
1100 }
1101
1102 if( p_sps->vui.b_valid )
1103 {
1104 if( p_sps->vui.b_hrd_parameters_present_flag )
1105 {
1106 bs_read( p_sei_data->p_bs, p_sps->vui.i_cpb_removal_delay_length_minus1 + 1 );
1107 p_sys->i_dpb_output_delay =
1108 bs_read( p_sei_data->p_bs, p_sps->vui.i_dpb_output_delay_length_minus1 + 1 );
1109 }
1110
1111 if( p_sps->vui.b_pic_struct_present_flag )
1112 p_sys->i_pic_struct = bs_read( p_sei_data->p_bs, 4 );
1113 /* + unparsed remains */
1114 }
1115 } break;
1116
1117 /* Look for user_data_registered_itu_t_t35 */
1118 case HXXX_SEI_USER_DATA_REGISTERED_ITU_T_T35:
1119 {
1120 if( p_sei_data->itu_t35.type == HXXX_ITU_T35_TYPE_CC )
1121 {
1122 cc_storage_append( p_sys->p_ccs, true, p_sei_data->itu_t35.u.cc.p_data,
1123 p_sei_data->itu_t35.u.cc.i_data );
1124 }
1125 } break;
1126
1127 case HXXX_SEI_FRAME_PACKING_ARRANGEMENT:
1128 {
1129 if( p_dec->fmt_in.video.multiview_mode == MULTIVIEW_2D )
1130 {
1131 video_multiview_mode_t mode;
1132 switch( p_sei_data->frame_packing.type )
1133 {
1134 case FRAME_PACKING_INTERLEAVED_CHECKERBOARD:
1135 mode = MULTIVIEW_STEREO_CHECKERBOARD; break;
1136 case FRAME_PACKING_INTERLEAVED_COLUMN:
1137 mode = MULTIVIEW_STEREO_COL; break;
1138 case FRAME_PACKING_INTERLEAVED_ROW:
1139 mode = MULTIVIEW_STEREO_ROW; break;
1140 case FRAME_PACKING_SIDE_BY_SIDE:
1141 mode = MULTIVIEW_STEREO_SBS; break;
1142 case FRAME_PACKING_TOP_BOTTOM:
1143 mode = MULTIVIEW_STEREO_TB; break;
1144 case FRAME_PACKING_TEMPORAL:
1145 mode = MULTIVIEW_STEREO_FRAME; break;
1146 case FRAME_PACKING_TILED:
1147 default:
1148 mode = MULTIVIEW_2D; break;
1149 }
1150 p_dec->fmt_out.video.multiview_mode = mode;
1151 }
1152 } break;
1153
1154 /* Look for SEI recovery point */
1155 case HXXX_SEI_RECOVERY_POINT:
1156 {
1157 if( !p_sys->b_recovered )
1158 msg_Dbg( p_dec, "Seen SEI recovery point, %d recovery frames", p_sei_data->recovery.i_frames );
1159 p_sys->i_recovery_frame_cnt = p_sei_data->recovery.i_frames;
1160 } break;
1161
1162 default:
1163 /* Will skip */
1164 break;
1165 }
1166
1167 return true;
1168 }
1169
VLC Development tree mirror