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