b1cd66ebd0b93df11fff3bf0fe43c56b94f2b04f
[vlc.git] / modules / demux / mpeg / h26x.c
1 /*****************************************************************************
2  * h26x.c : raw H264 and HEVC Video demuxers
3  *****************************************************************************
4  * Copyright (C) 2002-2004, 2014-2015 VLC authors and VideoLAN
5  *
6  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
7  *          Denis Charmet <typx@videolan.org>
8  *
9  * This program is free software; you can redistribute it and/or modify it
10  * under the terms of the GNU Lesser General Public License as published by
11  * the Free Software Foundation; either version 2.1 of the License, or
12  * (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17  * GNU Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public License
20  * along with this program; if not, write to the Free Software Foundation,
21  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
22  *****************************************************************************/
23
24 /*****************************************************************************
25  * Preamble
26  *****************************************************************************/
27
28 #ifdef HAVE_CONFIG_H
29 # include "config.h"
30 #endif
31
32 #include <vlc_common.h>
33 #include <vlc_plugin.h>
34 #include <vlc_demux.h>
35 #include <vlc_codec.h>
36 #include "../../packetizer/hevc_nal.h" /* definitions, inline helpers */
37 #include "../../packetizer/h264_nal.h" /* definitions, inline helpers */
38
39 /*****************************************************************************
40  * Module descriptor
41  *****************************************************************************/
42 static int  OpenH264 ( vlc_object_t * );
43 static int  OpenHEVC ( vlc_object_t * );
44 static void Close( vlc_object_t * );
45
46 #define FPS_TEXT N_("Frames per Second")
47 #define FPS_LONGTEXT N_("Desired frame rate for the stream.")
48
49 vlc_module_begin ()
50     set_shortname( "H264")
51     set_category( CAT_INPUT )
52     set_subcategory( SUBCAT_INPUT_DEMUX )
53     set_description( N_("H264 video demuxer" ) )
54     set_capability( "demux", 6 )
55     set_section( N_("H264 video demuxer" ), NULL )
56     add_float( "h264-fps", 0.0, FPS_TEXT, FPS_LONGTEXT, true )
57     set_callbacks( OpenH264, Close )
58     add_shortcut( "h264" )
59     add_file_extension("h264")
60
61     add_submodule()
62         set_shortname( "HEVC")
63         set_category( CAT_INPUT )
64         set_subcategory( SUBCAT_INPUT_DEMUX )
65         set_description( N_("HEVC/H.265 video demuxer" ) )
66         set_capability( "demux", 6 )
67         set_section( N_("HEVC/H.265 video demuxer" ), NULL )
68         add_float( "hevc-fps", 0.0, FPS_TEXT, FPS_LONGTEXT, true )
69         set_callbacks( OpenHEVC, Close )
70         add_shortcut( "hevc", "h265" )
71
72 vlc_module_end ()
73
74 /*****************************************************************************
75  * Local prototypes
76  *****************************************************************************/
77 typedef struct
78 {
79     es_out_id_t *p_es;
80
81     date_t      feed_dts;
82     date_t      output_dts;
83     unsigned    frame_rate_num;
84     unsigned    frame_rate_den;
85
86     decoder_t *p_packetizer;
87 } demux_sys_t;
88
89 static int Demux( demux_t * );
90 static int Control( demux_t *, int, va_list );
91
92 #define H26X_PACKET_SIZE 2048
93 #define H26X_PEEK_CHUNK  (H26X_PACKET_SIZE * 4)
94 #define H26X_MIN_PEEK    (4 + 7 + 10)
95 #define H26X_MAX_PEEK    (H26X_PEEK_CHUNK * 8) /* max data to check */
96 #define H26X_NAL_COUNT   8 /* max # or NAL to check */
97
98 /*****************************************************************************
99  * Probing
100  *****************************************************************************/
101 typedef struct
102 {
103     bool b_sps;
104     bool b_pps;
105     bool b_vps;
106 } hevc_probe_ctx_t;
107
108 typedef struct
109 {
110     bool b_sps;
111     bool b_pps;
112 } h264_probe_ctx_t;
113
114 static int ProbeHEVC( const uint8_t *p_peek, size_t i_peek, void *p_priv )
115 {
116     hevc_probe_ctx_t *p_ctx = (hevc_probe_ctx_t *) p_priv;
117
118     if( i_peek < 2 )
119         return -1;
120
121     if( p_peek[0] & 0x80 )
122         return -1;
123
124     const uint8_t i_type = hevc_getNALType( p_peek );
125     const uint8_t i_layer = hevc_getNALLayer( p_peek );
126
127    if ( i_type == HEVC_NAL_VPS ) /* VPS */
128    {
129        if( i_layer != 0 || i_peek < 6 ||
130            p_peek[4] != 0xFF || p_peek[5] != 0xFF ) /* Check reserved bits */
131            return -1;
132        p_ctx->b_vps = true;
133        return 0;
134    }
135    else if( i_type == HEVC_NAL_SPS )  /* SPS */
136    {
137        if( i_layer != 0 )
138            return -1;
139        p_ctx->b_sps = true;
140        return 0;
141    }
142    else if( i_type == HEVC_NAL_PPS )  /* PPS */
143    {
144        if( i_layer != 0 )
145            return -1;
146        p_ctx->b_pps = true;
147        return 0;
148    }
149    else if( i_type >= HEVC_NAL_BLA_W_LP && i_type <= HEVC_NAL_CRA ) /* Key Frame */
150    {
151         if( p_ctx->b_vps && p_ctx->b_sps && p_ctx->b_pps && i_layer == 0 )
152             return 1;
153    }
154    else if( i_type == HEVC_NAL_AUD ) /* AU */
155    {
156         if( i_peek < H26X_MIN_PEEK ||
157             p_peek[4] != 0 || p_peek[5] != 0 ) /* Must prefix another NAL */
158             return -1;
159    }
160    else if( i_type == HEVC_NAL_PREF_SEI ) /* Prefix SEI */
161    {
162        if( p_peek[2] == 0xFF ) /* empty SEI */
163            return -1;
164    }
165    else
166    {
167        return -1; /* See 7.4.2.4.4 for sequence order */
168    }
169
170     return 0; /* Probe more */
171 }
172
173 static int ProbeH264( const uint8_t *p_peek, size_t i_peek, void *p_priv )
174 {
175     h264_probe_ctx_t *p_ctx = (h264_probe_ctx_t *) p_priv;
176
177     if( i_peek < 1 )
178         return -1;
179     const uint8_t i_nal_type = p_peek[0] & 0x1F;
180     const uint8_t i_ref_idc = p_peek[0] & 0x60;
181
182     if( (p_peek[0] & 0x80) ) /* reserved 0 */
183         return -1;
184
185     /* ( !i_ref_idc && (i_nal_type < 6 || i_nal_type == 7 || i_nal_type == 8) ) ||
186        (  i_ref_idc && (i_nal_type == 6 || i_nal_type >= 9) ) */
187
188     if( i_nal_type == H264_NAL_SPS )
189     {
190         if( i_ref_idc == 0 || i_peek < 3 ||
191            (p_peek[2] & 0x03) /* reserved 0 bits */ )
192             return -1;
193         p_ctx->b_sps = true;
194     }
195     else if( i_nal_type == H264_NAL_PPS )
196     {
197         if( i_ref_idc == 0 )
198             return -1;
199         p_ctx->b_pps = true;
200     }
201     else if( i_nal_type == H264_NAL_SLICE_IDR )
202     {
203         if( i_ref_idc == 0 || ! p_ctx->b_pps || ! p_ctx->b_sps )
204             return -1;
205         else
206             return 1;
207     }
208     else if( i_nal_type == H264_NAL_AU_DELIMITER )
209     {
210         if( i_ref_idc || p_ctx->b_pps || p_ctx->b_sps )
211             return -1;
212     }
213     else if ( i_nal_type == H264_NAL_SEI )
214     {
215         if( i_ref_idc )
216             return -1;
217     }
218      /* 7.4.1.1 */
219     else if ( i_nal_type == H264_NAL_SPS_EXT ||
220               i_nal_type == H264_NAL_SUBSET_SPS )
221     {
222         if( i_ref_idc == 0 || !p_ctx->b_sps )
223             return -1;
224     }
225     else if( i_nal_type == H264_NAL_PREFIX )
226     {
227         if( i_ref_idc == 0 || !p_ctx->b_pps || !p_ctx->b_sps )
228             return -1;
229     }
230     else return -1; /* see 7.4.1.2.3 for sequence */
231
232     return 0;
233 }
234
235 /*****************************************************************************
236  * Shared Open code
237  *****************************************************************************/
238 static inline bool check_Property( demux_t *p_demux, const char **pp_psz,
239                                    bool(*pf_check)(demux_t *, const char *) )
240 {
241     while( *pp_psz )
242     {
243         if( pf_check( p_demux, *pp_psz ) )
244             return true;
245         pp_psz++;
246     }
247     return false;
248 }
249
250 static int GenericOpen( demux_t *p_demux, const char *psz_module,
251                         vlc_fourcc_t i_codec,
252                         int(*pf_probe)(const uint8_t *, size_t, void *),
253                         void *p_ctx,
254                         const char **pp_psz_exts,
255                         const char **pp_psz_mimes )
256 {
257     demux_sys_t *p_sys;
258     const uint8_t *p_peek;
259     es_format_t fmt;
260     uint8_t annexb_startcode[] = {0,0,0,1};
261     int i_ret = 0;
262
263     /* Restrict by type first */
264     if( !p_demux->obj.force &&
265         !check_Property( p_demux, pp_psz_exts, demux_IsPathExtension ) &&
266         !check_Property( p_demux, pp_psz_mimes, demux_IsContentType ) )
267     {
268         return VLC_EGENERIC;
269     }
270
271     /* First check for first AnnexB header */
272     if( vlc_stream_Peek( p_demux->s, &p_peek, H26X_MIN_PEEK ) == H26X_MIN_PEEK &&
273        !memcmp( p_peek, annexb_startcode, 4 ) )
274     {
275         size_t i_peek = H26X_MIN_PEEK;
276         size_t i_peek_target = H26X_MIN_PEEK;
277         size_t i_probe_offset = 4;
278         const uint8_t *p_probe = p_peek;
279         bool b_synced = true;
280         unsigned i_bitflow = 0;
281
282         for( unsigned i=0; i<H26X_NAL_COUNT; i++ )
283         {
284             while( !b_synced )
285             {
286                 if( i_probe_offset + H26X_MIN_PEEK >= i_peek &&
287                     i_peek_target + H26X_PEEK_CHUNK <= H26X_MAX_PEEK )
288                 {
289                     i_peek_target += H26X_PEEK_CHUNK;
290                     i_peek = vlc_stream_Peek( p_demux->s, &p_peek, i_peek_target );
291                 }
292
293                 if( i_probe_offset + H26X_MIN_PEEK >= i_peek )
294                     break;
295
296                 p_probe = &p_peek[i_probe_offset];
297                 i_bitflow = (i_bitflow << 1) | (!p_probe[0]);
298                 /* Check for annexB */
299                 if( p_probe[0] == 0x01 && ((i_bitflow & 0x06) == 0x06) )
300                     b_synced = true;
301
302                 i_probe_offset++;
303             }
304
305             if( b_synced )
306             {
307                 p_probe = &p_peek[i_probe_offset];
308                 i_ret = pf_probe( p_probe, i_peek - i_probe_offset, p_ctx );
309             }
310
311             if( i_ret != 0 )
312                 break;
313
314             i_probe_offset += 4;
315             b_synced = false;
316         }
317     }
318
319     if( i_ret < 1 )
320     {
321         if( !p_demux->obj.force )
322         {
323             msg_Warn( p_demux, "%s module discarded (no startcode)", psz_module );
324             return VLC_EGENERIC;
325         }
326
327         msg_Err( p_demux, "this doesn't look like a %s ES stream, "
328                  "continuing anyway", psz_module );
329     }
330
331     p_demux->pf_demux  = Demux;
332     p_demux->pf_control= Control;
333     p_demux->p_sys     = p_sys = malloc( sizeof( demux_sys_t ) );
334     p_sys->p_es        = NULL;
335     p_sys->frame_rate_num = 0;
336     p_sys->frame_rate_den = 0;
337
338     float f_fps = 0;
339     char *psz_fpsvar;
340     if( asprintf( &psz_fpsvar, "%s-fps", psz_module ) )
341     {
342         f_fps = var_CreateGetFloat( p_demux, psz_fpsvar );
343         free( psz_fpsvar );
344     }
345
346     if( f_fps )
347     {
348         if ( f_fps < 0.001f ) f_fps = 0.001f;
349         p_sys->frame_rate_den = 1000;
350         p_sys->frame_rate_num = 2000 * f_fps;
351         date_Init( &p_sys->feed_dts, p_sys->frame_rate_num, p_sys->frame_rate_den );
352     }
353     else
354         date_Init( &p_sys->feed_dts, 25000, 1000 );
355     date_Set( &p_sys->feed_dts, VLC_TICK_0 );
356     p_sys->output_dts = p_sys->feed_dts;
357
358     /* Load the mpegvideo packetizer */
359     es_format_Init( &fmt, VIDEO_ES, i_codec );
360     if( f_fps )
361     {
362         fmt.video.i_frame_rate = p_sys->feed_dts.i_divider_num;
363         fmt.video.i_frame_rate_base = p_sys->feed_dts.i_divider_den;
364     }
365     p_sys->p_packetizer = demux_PacketizerNew( p_demux, &fmt, psz_module );
366     if( !p_sys->p_packetizer )
367     {
368         free( p_sys );
369         return VLC_EGENERIC;
370     }
371
372     return VLC_SUCCESS;
373 }
374
375 /*****************************************************************************
376  * Open: initializes demux structures
377  *****************************************************************************/
378 static int OpenH264( vlc_object_t * p_this )
379 {
380     h264_probe_ctx_t ctx = { 0, 0 };
381     const char *rgi_psz_ext[] = { ".h264", ".264", ".bin", ".bit", ".raw", NULL };
382     const char *rgi_psz_mime[] = { "video/H264", "video/h264", "video/avc", NULL };
383
384     return GenericOpen( (demux_t*)p_this, "h264", VLC_CODEC_H264, ProbeH264,
385                         &ctx, rgi_psz_ext, rgi_psz_mime );
386 }
387
388 static int OpenHEVC( vlc_object_t * p_this )
389 {
390     hevc_probe_ctx_t ctx = { 0, 0, 0 };
391     const char *rgi_psz_ext[] = { ".h265", ".265", ".hevc", ".bin", ".bit", ".raw", NULL };
392     const char *rgi_psz_mime[] = { "video/h265", "video/hevc", "video/HEVC", NULL };
393
394     return GenericOpen( (demux_t*)p_this, "hevc", VLC_CODEC_HEVC, ProbeHEVC,
395                         &ctx, rgi_psz_ext, rgi_psz_mime );
396 }
397
398 /*****************************************************************************
399  * Close: frees unused data
400  *****************************************************************************/
401 static void Close( vlc_object_t * p_this )
402 {
403     demux_t     *p_demux = (demux_t*)p_this;
404     demux_sys_t *p_sys = p_demux->p_sys;
405
406     demux_PacketizerDestroy( p_sys->p_packetizer );
407     free( p_sys );
408 }
409
410 /*****************************************************************************
411  * Demux: reads and demuxes data packets
412  *****************************************************************************
413  * Returns -1 in case of error, 0 in case of EOF, 1 otherwise
414  *****************************************************************************/
415 static int Demux( demux_t *p_demux)
416 {
417     demux_sys_t *p_sys = p_demux->p_sys;
418     block_t *p_block_in, *p_block_out;
419     bool b_eof = false;
420
421     p_block_in = vlc_stream_Block( p_demux->s, H26X_PACKET_SIZE );
422     if( p_block_in == NULL )
423     {
424         b_eof = true;
425     }
426     else
427     {
428         p_block_in->i_dts = date_Get( &p_sys->feed_dts );
429     }
430
431     while( (p_block_out = p_sys->p_packetizer->pf_packetize( p_sys->p_packetizer,
432                                                              p_block_in ? &p_block_in : NULL )) )
433     {
434         while( p_block_out )
435         {
436             block_t *p_next = p_block_out->p_next;
437             p_block_out->p_next = NULL;
438
439             if( p_sys->p_packetizer->fmt_out.video.i_frame_rate_base &&
440                 p_sys->p_packetizer->fmt_out.video.i_frame_rate_base != p_sys->frame_rate_den &&
441                 p_sys->p_packetizer->fmt_out.video.i_frame_rate &&
442                 p_sys->p_packetizer->fmt_out.video.i_frame_rate_base != p_sys->frame_rate_num )
443             {
444                 p_sys->frame_rate_num = p_sys->p_packetizer->fmt_out.video.i_frame_rate;
445                 p_sys->frame_rate_den = p_sys->p_packetizer->fmt_out.video.i_frame_rate_base;
446                 date_Change( &p_sys->feed_dts, 2 * p_sys->frame_rate_num, p_sys->frame_rate_den );
447                 date_Change( &p_sys->output_dts, 2 * p_sys->frame_rate_num, p_sys->frame_rate_den );
448                 msg_Dbg( p_demux, "using %.2f fps", (double) p_sys->frame_rate_num / p_sys->frame_rate_den );
449             }
450
451             /* we only want to use the pts-dts offset and length from packetizer */
452             vlc_tick_t dtsdiff = p_block_out->i_pts > p_block_out->i_dts
453                                ? p_block_out->i_pts - p_block_out->i_dts
454                                : 0;
455             /* Always start frame N=1 so we get PCR on N=0 */
456             date_t dtsdate = p_sys->output_dts;
457             vlc_tick_t dts = date_Increment( &dtsdate, 2 );
458
459             p_block_out->i_dts = dts;
460             if( p_block_out->i_pts != VLC_TICK_INVALID )
461                 p_block_out->i_pts = dts + dtsdiff;
462
463             if( p_block_in )
464             {
465                 p_block_in->i_dts = date_Get( &p_sys->feed_dts );
466                 p_block_in->i_pts = VLC_TICK_INVALID;
467             }
468
469             if( p_sys->p_es == NULL )
470             {
471                 p_sys->p_packetizer->fmt_out.b_packetized = true;
472                 p_sys->p_packetizer->fmt_out.i_id = 0;
473                 p_sys->p_es = es_out_Add( p_demux->out, &p_sys->p_packetizer->fmt_out );
474                 if( !p_sys->p_es )
475                 {
476                     block_ChainRelease( p_block_out );
477                     return VLC_DEMUXER_EOF;
478                 }
479             }
480
481             /* h264 packetizer does merge multiple NAL into AU, but slice flag persists */
482             bool frame = p_block_out->i_flags & BLOCK_FLAG_TYPE_MASK;
483             const vlc_tick_t i_frame_length = p_block_out->i_length;
484
485             /* first output */
486             if( date_Get( &p_sys->output_dts ) == VLC_TICK_0 )
487                 es_out_SetPCR( p_demux->out, date_Get( &p_sys->output_dts ) );
488
489             es_out_Send( p_demux->out, p_sys->p_es, p_block_out );
490
491             vlc_tick_t pcr = b_eof ? dts : date_Get( &p_sys->output_dts );
492
493             if( frame )
494             {
495                 unsigned i_nb_fields;
496                 if( i_frame_length > 0 )
497                 {
498                     i_nb_fields = round( (double)i_frame_length * 2 * p_sys->frame_rate_num /
499                                   ( p_sys->frame_rate_den * CLOCK_FREQ ) );
500                 }
501                 else i_nb_fields = 2;
502                 if( i_nb_fields <= 6 ) /* in the legit range */
503                 {
504                     date_Increment( &p_sys->output_dts, i_nb_fields );
505                 }
506             }
507
508             es_out_SetPCR( p_demux->out, pcr );
509
510             p_block_out = p_next;
511         }
512     }
513     return (b_eof) ? VLC_DEMUXER_EOF : VLC_DEMUXER_SUCCESS;
514 }
515
516 /*****************************************************************************
517  * Control:
518  *****************************************************************************/
519 static int Control( demux_t *p_demux, int i_query, va_list args )
520 {
521     /* demux_sys_t *p_sys  = p_demux->p_sys; */
522     /* FIXME calculate the bitrate */
523     if( i_query == DEMUX_SET_TIME )
524         return VLC_EGENERIC;
525     else
526         return demux_vaControlHelper( p_demux->s,
527                                        0, -1,
528                                        0, 1, i_query, args );
529 }
530