git.sesse.net Git - vlc/blob - 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