demux: hls: add adaptative based hls demuxer
[vlc.git] / modules / demux / flac.c
1 /*****************************************************************************
2  * flac.c : FLAC demux module for vlc
3  *****************************************************************************
4  * Copyright (C) 2001-2008 VLC authors and VideoLAN
5  * $Id$
6  *
7  * Authors: Gildas Bazin <gbazin@netcourrier.com>
8  *          Laurent Aimar <fenrir@via.ecp.fr>
9  *
10  * This program is free software; you can redistribute it and/or modify it
11  * under the terms of the GNU Lesser General Public License as published by
12  * the Free Software Foundation; either version 2.1 of the License, or
13  * (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18  * GNU Lesser General Public License for more details.
19  *
20  * You should have received a copy of the GNU Lesser General Public License
21  * along with this program; if not, write to the Free Software Foundation,
22  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
23  *****************************************************************************/
24
25 /*****************************************************************************
26  * Preamble
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_meta.h>                 /* vlc_meta_* */
36 #include <vlc_input.h>                /* vlc_input_attachment, vlc_seekpoint */
37 #include <vlc_codec.h>                /* decoder_t */
38 #include <vlc_charset.h>              /* EnsureUTF8 */
39
40 #include <assert.h>
41 #include "xiph_metadata.h"            /* vorbis comments */
42
43 /*****************************************************************************
44  * Module descriptor
45  *****************************************************************************/
46 static int  Open  ( vlc_object_t * );
47 static void Close ( vlc_object_t * );
48
49 vlc_module_begin ()
50     set_description( N_("FLAC demuxer") )
51     set_capability( "demux", 155 )
52     set_category( CAT_INPUT )
53     set_subcategory( SUBCAT_INPUT_DEMUX )
54     set_callbacks( Open, Close )
55     add_shortcut( "flac" )
56 vlc_module_end ()
57
58 /*****************************************************************************
59  * Local prototypes
60  *****************************************************************************/
61 static int Demux  ( demux_t * );
62 static int Control( demux_t *, int, va_list );
63
64 static int  ReadMeta( demux_t *, uint8_t **pp_streaminfo, int *pi_streaminfo );
65
66 struct demux_sys_t
67 {
68     bool  b_start;
69     es_out_id_t *p_es;
70
71     /* Packetizer */
72     decoder_t *p_packetizer;
73
74     vlc_meta_t *p_meta;
75
76     int64_t i_pts;
77
78     int64_t i_length; /* Length from stream info */
79     int64_t i_data_pos;
80
81     /* */
82     int         i_seekpoint;
83     seekpoint_t **seekpoint;
84
85     /* */
86     int                i_attachments;
87     input_attachment_t **attachments;
88     int                i_cover_idx;
89     int                i_cover_score;
90 };
91
92 #define STREAMINFO_SIZE 34
93 #define FLAC_PACKET_SIZE 16384
94
95 /*****************************************************************************
96  * Open: initializes ES structures
97  *****************************************************************************/
98 static int Open( vlc_object_t * p_this )
99 {
100     demux_t     *p_demux = (demux_t*)p_this;
101     demux_sys_t *p_sys;
102     const uint8_t *p_peek;
103     uint8_t     *p_streaminfo;
104     int         i_streaminfo;
105     es_format_t fmt;
106
107     /* Have a peep at the show. */
108     if( stream_Peek( p_demux->s, &p_peek, 4 ) < 4 ) return VLC_EGENERIC;
109
110     if( p_peek[0]!='f' || p_peek[1]!='L' || p_peek[2]!='a' || p_peek[3]!='C' )
111     {
112         if( !p_demux->b_force )
113         {
114             char *psz_mime = stream_ContentType( p_demux->s );
115             if ( !psz_mime || strcmp( psz_mime, "audio/flac" ) )
116             {
117                 free( psz_mime );
118                 return VLC_EGENERIC;
119             }
120             free( psz_mime );
121         }
122
123         /* User forced */
124         msg_Err( p_demux, "this doesn't look like a flac stream, "
125                  "continuing anyway" );
126     }
127
128     p_sys = malloc( sizeof( demux_sys_t ) );
129     if( unlikely(p_sys == NULL) )
130         return VLC_ENOMEM;
131
132     p_demux->pf_demux   = Demux;
133     p_demux->pf_control = Control;
134     p_demux->p_sys      = p_sys;
135     p_sys->b_start = true;
136     p_sys->p_meta = NULL;
137     p_sys->i_length = 0;
138     p_sys->i_pts = 0;
139     p_sys->p_es = NULL;
140     TAB_INIT( p_sys->i_seekpoint, p_sys->seekpoint );
141     TAB_INIT( p_sys->i_attachments, p_sys->attachments);
142     p_sys->i_cover_idx = 0;
143     p_sys->i_cover_score = 0;
144
145     /* We need to read and store the STREAMINFO metadata */
146     if( ReadMeta( p_demux, &p_streaminfo, &i_streaminfo ) )
147     {
148         free( p_sys );
149         return VLC_EGENERIC;
150     }
151
152     /* Load the FLAC packetizer */
153     /* Store STREAMINFO for the decoder and packetizer */
154     es_format_Init( &fmt, AUDIO_ES, VLC_CODEC_FLAC );
155     fmt.i_extra = i_streaminfo;
156     fmt.p_extra = p_streaminfo;
157
158     p_sys->p_packetizer = demux_PacketizerNew( p_demux, &fmt, "flac" );
159     if( !p_sys->p_packetizer )
160     {
161         free( p_sys );
162         return VLC_EGENERIC;
163     }
164
165     if( p_sys->i_cover_idx < p_sys->i_attachments )
166     {
167         char psz_url[128];
168         if( !p_sys->p_meta )
169             p_sys->p_meta = vlc_meta_New();
170         snprintf( psz_url, sizeof(psz_url), "attachment://%s",
171                   p_sys->attachments[p_sys->i_cover_idx]->psz_name );
172         vlc_meta_Set( p_sys->p_meta, vlc_meta_ArtworkURL, psz_url );
173     }
174     return VLC_SUCCESS;
175 }
176
177 /*****************************************************************************
178  * Close: frees unused data
179  *****************************************************************************/
180 static void Close( vlc_object_t * p_this )
181 {
182     demux_t     *p_demux = (demux_t*)p_this;
183     demux_sys_t *p_sys = p_demux->p_sys;
184
185     for( int i = 0; i < p_sys->i_seekpoint; i++ )
186         vlc_seekpoint_Delete(p_sys->seekpoint[i]);
187     TAB_CLEAN( p_sys->i_seekpoint, p_sys->seekpoint );
188
189     for( int i = 0; i < p_sys->i_attachments; i++ )
190         vlc_input_attachment_Delete( p_sys->attachments[i] );
191     TAB_CLEAN( p_sys->i_attachments, p_sys->attachments);
192
193     /* Delete the decoder */
194     demux_PacketizerDestroy( p_sys->p_packetizer );
195
196     if( p_sys->p_meta )
197         vlc_meta_Delete( p_sys->p_meta );
198     free( p_sys );
199 }
200
201 /*****************************************************************************
202  * Demux: reads and demuxes data packets
203  *****************************************************************************
204  * Returns -1 in case of error, 0 in case of EOF, 1 otherwise
205  *****************************************************************************/
206 static int Demux( demux_t *p_demux )
207 {
208     demux_sys_t *p_sys = p_demux->p_sys;
209     block_t     *p_block_in, *p_block_out;
210
211     bool b_eof = !( p_block_in = stream_Block( p_demux->s, FLAC_PACKET_SIZE ) );
212
213     if ( p_block_in )
214     {
215         p_block_in->i_pts = p_block_in->i_dts = p_sys->b_start ? VLC_TS_0 : VLC_TS_INVALID;
216         p_sys->b_start = false;
217     }
218
219     while( (p_block_out = p_sys->p_packetizer->pf_packetize(
220                 p_sys->p_packetizer, (p_block_in) ? &p_block_in : NULL )) )
221     {
222         while( p_block_out )
223         {
224             block_t *p_next = p_block_out->p_next;
225
226             p_block_out->p_next = NULL;
227
228             if( p_sys->p_es == NULL )
229             {
230                 p_sys->p_packetizer->fmt_out.b_packetized = true;
231                 p_sys->p_es = es_out_Add( p_demux->out, &p_sys->p_packetizer->fmt_out);
232             }
233
234             p_sys->i_pts = p_block_out->i_dts;
235
236             /* set PCR */
237             es_out_Control( p_demux->out, ES_OUT_SET_PCR, p_block_out->i_dts );
238
239             es_out_Send( p_demux->out, p_sys->p_es, p_block_out );
240
241             p_block_out = p_next;
242         }
243     }
244     return !b_eof;
245 }
246
247 /*****************************************************************************
248  * Control:
249  *****************************************************************************/
250 static int64_t ControlGetLength( demux_t *p_demux )
251 {
252     demux_sys_t *p_sys = p_demux->p_sys;
253     const int64_t i_size = stream_Size(p_demux->s) - p_sys->i_data_pos;
254     int64_t i_length = p_sys->i_length;
255     int i;
256
257     /* Try to fix length using seekpoint and current size for truncated file */
258     for( i = p_sys->i_seekpoint-1; i >= 0; i-- )
259     {
260         seekpoint_t *s = p_sys->seekpoint[i];
261         if( s->i_byte_offset <= i_size )
262         {
263             if( i+1 < p_sys->i_seekpoint )
264             {
265                 /* Broken file */
266                 seekpoint_t *n = p_sys->seekpoint[i+1];
267                 assert( n->i_byte_offset != s->i_byte_offset); /* Should be ensured by ParseSeekTable */
268                 i_length = s->i_time_offset + (n->i_time_offset-s->i_time_offset) * (i_size-s->i_byte_offset) / (n->i_byte_offset-s->i_byte_offset);
269             }
270             break;
271         }
272     }
273     return i_length;
274 }
275
276 static int64_t ControlGetTime( demux_t *p_demux )
277 {
278     demux_sys_t *p_sys = p_demux->p_sys;
279     return p_sys->i_pts;
280 }
281
282 static int ControlSetTime( demux_t *p_demux, int64_t i_time )
283 {
284     demux_sys_t *p_sys = p_demux->p_sys;
285     int64_t i_delta_time;
286     bool b_seekable;
287     int i;
288
289     /* */
290     stream_Control( p_demux->s, STREAM_CAN_SEEK, &b_seekable );
291     if( !b_seekable )
292         return VLC_EGENERIC;
293
294     /* */
295     assert( p_sys->i_seekpoint > 0 );   /* ReadMeta ensure at least (0,0) */
296     for( i = p_sys->i_seekpoint-1; i >= 0; i-- )
297     {
298         if( p_sys->seekpoint[i]->i_time_offset <= i_time )
299             break;
300     }
301     i_delta_time = i_time - p_sys->seekpoint[i]->i_time_offset;
302
303     /* XXX We do exact seek if it's not too far away(45s) */
304     if( i_delta_time < CLOCK_FREQ * 45 )
305     {
306         if( stream_Seek( p_demux->s, p_sys->seekpoint[i]->i_byte_offset+p_sys->i_data_pos ) )
307             return VLC_EGENERIC;
308
309         es_out_Control( p_demux->out, ES_OUT_SET_NEXT_DISPLAY_TIME, i_time );
310     }
311     else
312     {
313         int64_t i_delta_offset;
314         int64_t i_next_time;
315         int64_t i_next_offset;
316         uint32_t i_time_align = 1;
317
318         if( i+1 < p_sys->i_seekpoint )
319         {
320             i_next_time   = p_sys->seekpoint[i+1]->i_time_offset;
321             i_next_offset = p_sys->seekpoint[i+1]->i_byte_offset;
322         }
323         else
324         {
325             i_next_time   = p_sys->i_length;
326             i_next_offset = stream_Size(p_demux->s)-p_sys->i_data_pos;
327         }
328
329         i_delta_offset = 0;
330
331         if ( INT64_MAX / i_delta_time < (i_next_offset - p_sys->seekpoint[i]->i_byte_offset) )
332             i_time_align = CLOCK_FREQ;
333
334         if( i_next_time-p_sys->seekpoint[i]->i_time_offset > 0 )
335             i_delta_offset = (i_next_offset - p_sys->seekpoint[i]->i_byte_offset) * (i_delta_time / i_time_align) /
336                              ((i_next_time-p_sys->seekpoint[i]->i_time_offset) / i_time_align);
337
338         if( stream_Seek( p_demux->s, p_sys->seekpoint[i]->i_byte_offset+p_sys->i_data_pos + i_delta_offset ) )
339             return VLC_EGENERIC;
340     }
341     return VLC_SUCCESS;
342 }
343
344 static int Control( demux_t *p_demux, int i_query, va_list args )
345 {
346     demux_sys_t *p_sys = p_demux->p_sys;
347
348     if( i_query == DEMUX_GET_META )
349     {
350         vlc_meta_t *p_meta = (vlc_meta_t *)va_arg( args, vlc_meta_t* );
351         if( p_demux->p_sys->p_meta )
352             vlc_meta_Merge( p_meta, p_demux->p_sys->p_meta );
353         return VLC_SUCCESS;
354     }
355     else if( i_query == DEMUX_HAS_UNSUPPORTED_META )
356     {
357         bool *pb_bool = (bool*)va_arg( args, bool* );
358         *pb_bool = true;
359         return VLC_SUCCESS;
360     }
361     else if( i_query == DEMUX_GET_LENGTH )
362     {
363         int64_t *pi64 = (int64_t*)va_arg( args, int64_t * );
364         *pi64 = ControlGetLength( p_demux );
365         return VLC_SUCCESS;
366     }
367     else if( i_query == DEMUX_SET_TIME )
368     {
369         int64_t i_time = (int64_t)va_arg( args, int64_t );
370         return ControlSetTime( p_demux, i_time );
371     }
372     else if( i_query == DEMUX_SET_POSITION )
373     {
374         const double f = (double)va_arg( args, double );
375         int64_t i_time = f * ControlGetLength( p_demux );
376         return ControlSetTime( p_demux, i_time );
377     }
378     else if( i_query == DEMUX_GET_TIME )
379     {
380         int64_t *pi64 = (int64_t*)va_arg( args, int64_t * );
381         *pi64 = ControlGetTime( p_demux );
382         return VLC_SUCCESS;
383     }
384     else if( i_query == DEMUX_GET_POSITION )
385     {
386         double *pf = (double*)va_arg( args, double * );
387         const int64_t i_length = ControlGetLength(p_demux);
388         if( i_length > 0 )
389         {
390             double current = ControlGetTime(p_demux);
391             *pf = current / (double)i_length;
392         }
393         else
394             *pf= 0.0;
395         return VLC_SUCCESS;
396     }
397     else if( i_query == DEMUX_GET_ATTACHMENTS )
398     {
399         input_attachment_t ***ppp_attach =
400             (input_attachment_t***)va_arg( args, input_attachment_t*** );
401         int *pi_int = (int*)va_arg( args, int * );
402
403         if( p_sys->i_attachments <= 0 )
404             return VLC_EGENERIC;
405
406         *pi_int = p_sys->i_attachments;
407         *ppp_attach = xmalloc( sizeof(input_attachment_t*) * p_sys->i_attachments );
408         for( int i = 0; i < p_sys->i_attachments; i++ )
409             (*ppp_attach)[i] = vlc_input_attachment_Duplicate( p_sys->attachments[i] );
410         return VLC_SUCCESS;
411     }
412
413     return demux_vaControlHelper( p_demux->s, p_sys->i_data_pos, -1,
414                                    8*0, 1, i_query, args );
415 }
416
417 enum
418 {
419     META_STREAMINFO = 0,
420     META_SEEKTABLE = 3,
421     META_COMMENT = 4,
422     META_PICTURE = 6,
423 };
424
425 static inline int Get24bBE( const uint8_t *p )
426 {
427     return (p[0] << 16)|(p[1] << 8)|(p[2]);
428 }
429
430 static void ParseStreamInfo( int *pi_rate, int64_t *pi_count, uint8_t *p_data );
431 static void ParseSeekTable( demux_t *p_demux, const uint8_t *p_data, int i_data,
432                             int i_sample_rate );
433 static void ParseComment( demux_t *, const uint8_t *p_data, int i_data );
434 static void ParsePicture( demux_t *, const uint8_t *p_data, int i_data );
435
436 static int  ReadMeta( demux_t *p_demux, uint8_t **pp_streaminfo, int *pi_streaminfo )
437 {
438     demux_sys_t *p_sys = p_demux->p_sys;
439     int     i_peek;
440     const uint8_t *p_peek;
441     bool b_last;
442     int i_sample_rate = 0;
443     int64_t i_sample_count;
444
445     *pp_streaminfo = NULL;
446
447     /* Be sure we have seekpoint 0 */
448     seekpoint_t *s = vlc_seekpoint_New();
449     s->i_time_offset = 0;
450     s->i_byte_offset = 0;
451     TAB_APPEND( p_sys->i_seekpoint, p_sys->seekpoint, s );
452
453     uint8_t header[4];
454     if( stream_Read( p_demux->s, header, 4) < 4)
455         return VLC_EGENERIC;
456
457     if (memcmp(header, "fLaC", 4))
458         return VLC_EGENERIC;
459
460     b_last = 0;
461     while( !b_last )
462     {
463         int i_len;
464         int i_type;
465
466         i_peek = stream_Peek( p_demux->s, &p_peek, 4 );
467         if( i_peek < 4 )
468             break;
469         b_last = p_peek[0]&0x80;
470         i_type = p_peek[0]&0x7f;
471         i_len  = Get24bBE( &p_peek[1] );
472
473         if( i_type == META_STREAMINFO && !*pp_streaminfo )
474         {
475             if( i_len != STREAMINFO_SIZE ) {
476                 msg_Err( p_demux, "invalid size %d for a STREAMINFO metadata block", i_len );
477                 return VLC_EGENERIC;
478             }
479
480             *pi_streaminfo = STREAMINFO_SIZE;
481             *pp_streaminfo = malloc( STREAMINFO_SIZE);
482             if( *pp_streaminfo == NULL )
483                 return VLC_EGENERIC;
484
485             if( stream_Read( p_demux->s, NULL, 4) < 4)
486             {
487                 free( *pp_streaminfo );
488                 return VLC_EGENERIC;
489             }
490             if( stream_Read( p_demux->s, *pp_streaminfo, STREAMINFO_SIZE ) != STREAMINFO_SIZE )
491             {
492                 msg_Err( p_demux, "failed to read STREAMINFO metadata block" );
493                 free( *pp_streaminfo );
494                 return VLC_EGENERIC;
495             }
496
497             /* */
498             ParseStreamInfo( &i_sample_rate, &i_sample_count, *pp_streaminfo );
499             if( i_sample_rate > 0 )
500                 p_sys->i_length = i_sample_count * CLOCK_FREQ /i_sample_rate;
501             continue;
502         }
503         else if( i_type == META_SEEKTABLE )
504         {
505             i_peek = stream_Peek( p_demux->s, &p_peek, 4+i_len );
506             if( i_peek == 4+i_len )
507                 ParseSeekTable( p_demux, p_peek, i_peek, i_sample_rate );
508         }
509         else if( i_type == META_COMMENT )
510         {
511             i_peek = stream_Peek( p_demux->s, &p_peek, 4+i_len );
512             if( i_peek == 4+i_len )
513                 ParseComment( p_demux, p_peek, i_peek );
514         }
515         else if( i_type == META_PICTURE )
516         {
517             i_peek = stream_Peek( p_demux->s, &p_peek, 4+i_len );
518             if( i_peek == 4+i_len )
519                 ParsePicture( p_demux, p_peek, i_peek );
520         }
521
522         if( stream_Read( p_demux->s, NULL, 4+i_len ) < 4+i_len )
523             break;
524     }
525
526     /* */
527     p_sys->i_data_pos = stream_Tell( p_demux->s );
528
529     if (!*pp_streaminfo)
530         return VLC_EGENERIC;
531
532     return VLC_SUCCESS;
533 }
534 static void ParseStreamInfo( int *pi_rate, int64_t *pi_count, uint8_t *p_data )
535 {
536     *pi_rate = GetDWBE(&p_data[4+6]) >> 12;
537     *pi_count = GetQWBE(&p_data[4+6]) &  ((INT64_C(1)<<36)-1);
538 }
539
540 static void ParseSeekTable( demux_t *p_demux, const uint8_t *p_data, int i_data,
541                             int i_sample_rate )
542 {
543     demux_sys_t *p_sys = p_demux->p_sys;
544     seekpoint_t *s;
545     int i;
546
547     if( i_sample_rate <= 0 )
548         return;
549
550     /* */
551     for( i = 0; i < (i_data-4)/18; i++ )
552     {
553         const int64_t i_sample = GetQWBE( &p_data[4+18*i+0] );
554         int j;
555
556         if( i_sample < 0 || i_sample >= INT64_MAX )
557             continue;
558
559         s = vlc_seekpoint_New();
560         s->i_time_offset = i_sample * CLOCK_FREQ / i_sample_rate;
561         s->i_byte_offset = GetQWBE( &p_data[4+18*i+8] );
562
563         /* Check for duplicate entry */
564         for( j = 0; j < p_sys->i_seekpoint; j++ )
565         {
566             if( p_sys->seekpoint[j]->i_time_offset == s->i_time_offset ||
567                 p_sys->seekpoint[j]->i_byte_offset == s->i_byte_offset )
568             {
569                 vlc_seekpoint_Delete( s );
570                 s = NULL;
571                 break;
572             }
573         }
574         if( s )
575         {
576             TAB_APPEND( p_sys->i_seekpoint, p_sys->seekpoint, s );
577         }
578     }
579     /* TODO sort it by size and remove wrong seek entry (time not increasing) */
580 }
581
582 static void ParseComment( demux_t *p_demux, const uint8_t *p_data, int i_data )
583 {
584     demux_sys_t *p_sys = p_demux->p_sys;
585
586     if( i_data < 4 )
587         return;
588
589     vorbis_ParseComment( NULL, &p_sys->p_meta, &p_data[4], i_data - 4,
590         &p_sys->i_attachments, &p_sys->attachments,
591         &p_sys->i_cover_score, &p_sys->i_cover_idx, NULL, NULL, NULL, NULL );
592 }
593
594 static void ParsePicture( demux_t *p_demux, const uint8_t *p_data, int i_data )
595 {
596     demux_sys_t *p_sys = p_demux->p_sys;
597
598     i_data -= 4; p_data += 4;
599
600     input_attachment_t *p_attachment = ParseFlacPicture( p_data, i_data,
601         p_sys->i_attachments, &p_sys->i_cover_score, &p_sys->i_cover_idx );
602     if( p_attachment == NULL )
603         return;
604
605     TAB_APPEND( p_sys->i_attachments, p_sys->attachments, p_attachment );
606 }
607