git.sesse.net Git - vlc/blob - modules/codec/flac.c

   1 /*****************************************************************************
   2  * flac.c: flac decoder/packetizer module making use of libflac
   3  *****************************************************************************
   4  * Copyright (C) 1999-2001 VideoLAN
   5  * $Id: flac.c,v 1.1 2003/11/21 01:45:48 gbazin Exp $
   6  *
   7  * Authors: Gildas Bazin <gbazin@netcourrier.com>
   8  *          Sigmund Augdal <sigmunau@idi.ntnu.no>
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 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 General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  23  *****************************************************************************/
  24
  25 /*****************************************************************************
  26  * Preamble
  27  *****************************************************************************/
  28 #include <vlc/vlc.h>
  29 #include <vlc/decoder.h>
  30 #include <vlc/input.h>
  31
  32 #include <FLAC/stream_decoder.h>
  33
  34 #include "vlc_block_helper.h"
  35
  36 #define MAX_FLAC_HEADER_SIZE 16
  37
  38 /*****************************************************************************
  39  * decoder_sys_t : FLAC decoder descriptor
  40  *****************************************************************************/
  41 struct decoder_sys_t
  42 {
  43     /* Module mode */
  44     vlc_bool_t b_packetizer;
  45
  46     /*
  47      * Input properties
  48      */
  49     int i_state;
  50
  51     block_bytestream_t bytestream;
  52
  53     /*
  54      * Input/Output properties
  55      */
  56     block_t *p_block;
  57     aout_buffer_t *p_aout_buffer;
  58
  59     /*
  60      * FLAC properties
  61      */
  62     FLAC__StreamDecoder *p_flac;
  63
  64     vlc_bool_t b_stream_info;
  65     FLAC__StreamMetadata_StreamInfo stream_info;
  66
  67     /*
  68      * Common properties
  69      */
  70     audio_date_t end_date;
  71     mtime_t i_pts;
  72
  73     int i_frame_size, i_frame_length, i_bits_per_sample;
  74     unsigned int i_rate, i_channels, i_channels_conf;
  75 };
  76
  77 enum {
  78
  79     STATE_NOSYNC,
  80     STATE_SYNC,
  81     STATE_HEADER,
  82     STATE_NEXT_SYNC,
  83     STATE_GET_DATA,
  84     STATE_SEND_DATA
  85 };
  86
  87 static int pi_channels_maps[6] =
  88 {
  89     0,
  90     AOUT_CHAN_CENTER,
  91     AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT,
  92     AOUT_CHAN_CENTER | AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT,
  93     AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_REARLEFT
  94      | AOUT_CHAN_REARRIGHT,
  95     AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER
  96      | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT
  97 };
  98
  99 /*****************************************************************************
 100  * Local prototypes
 101  *****************************************************************************/
 102 static int  OpenDecoder   ( vlc_object_t * );
 103 static int  OpenPacketizer( vlc_object_t * );
 104 static void CloseDecoder  ( vlc_object_t * );
 105
 106 static aout_buffer_t *DecodeBlock( decoder_t *, block_t ** );
 107 static block_t *PacketizeBlock( decoder_t *, block_t ** );
 108
 109 static int SyncInfo( decoder_t *, uint8_t *, int *, int *, int *,int * );
 110
 111
 112 static FLAC__StreamDecoderReadStatus
 113 DecoderReadCallback( const FLAC__StreamDecoder *decoder,
 114                      FLAC__byte buffer[], unsigned *bytes, void *client_data );
 115
 116 static FLAC__StreamDecoderWriteStatus
 117 DecoderWriteCallback( const FLAC__StreamDecoder *decoder,
 118                       const FLAC__Frame *frame,
 119                       const FLAC__int32 *const buffer[], void *client_data );
 120
 121 static void DecoderMetadataCallback( const FLAC__StreamDecoder *decoder,
 122                                      const FLAC__StreamMetadata *metadata,
 123                                      void *client_data );
 124 static void DecoderErrorCallback( const FLAC__StreamDecoder *decoder,
 125                                   FLAC__StreamDecoderErrorStatus status,
 126                                   void *client_data);
 127
 128 static void Interleave32( int32_t *p_out, const int32_t * const *pp_in,
 129                           int i_nb_channels, int i_samples );
 130 static void Interleave16( int16_t *p_out, const int32_t * const *pp_in,
 131                           int i_nb_channels, int i_samples );
 132
 133 static void decoder_state_error( decoder_t *p_dec,
 134                                  FLAC__StreamDecoderState state );
 135
 136 static uint64_t read_utf8( const uint8_t *p_buf, int *pi_read );
 137 static uint8_t flac_crc8( const uint8_t *data, unsigned len );
 138
 139 /*****************************************************************************
 140  * Module descriptor
 141  *****************************************************************************/
 142 vlc_module_begin();
 143
 144     set_description( _("Flac audio decoder") );
 145     set_capability( "decoder", 100 );
 146     set_callbacks( OpenDecoder, CloseDecoder );
 147
 148     add_submodule();
 149     set_description( _("Flac audio packetizer") );
 150     set_capability( "packetizer", 100 );
 151     set_callbacks( OpenPacketizer, CloseDecoder );
 152
 153 vlc_module_end();
 154
 155 /*****************************************************************************
 156  * OpenDecoder: probe the decoder and return score
 157  *****************************************************************************/
 158 static int OpenDecoder( vlc_object_t *p_this )
 159 {
 160     decoder_t *p_dec = (decoder_t*)p_this;
 161     decoder_sys_t *p_sys;
 162
 163     if( p_dec->fmt_in.i_codec != VLC_FOURCC('f','l','a','c') )
 164     {
 165         return VLC_EGENERIC;
 166     }
 167
 168     /* Allocate the memory needed to store the decoder's structure */
 169     if( ( p_dec->p_sys = p_sys =
 170           (decoder_sys_t *)malloc(sizeof(decoder_sys_t)) ) == NULL )
 171     {
 172         msg_Err( p_dec, "out of memory" );
 173         return VLC_EGENERIC;
 174     }
 175
 176     /* Misc init */
 177     aout_DateSet( &p_sys->end_date, 0 );
 178     p_sys->b_packetizer = VLC_FALSE;
 179     p_sys->i_state = STATE_NOSYNC;
 180
 181     p_sys->bytestream = block_BytestreamInit( p_dec );
 182
 183     /* Take care of flac init */
 184     if( !(p_sys->p_flac = FLAC__stream_decoder_new()) )
 185     {
 186         msg_Err( p_dec, "FLAC__stream_decoder_new() failed" );
 187         free( p_sys );
 188         return VLC_EGENERIC;
 189     }
 190
 191     FLAC__stream_decoder_set_read_callback( p_sys->p_flac,
 192                                             DecoderReadCallback );
 193     FLAC__stream_decoder_set_write_callback( p_sys->p_flac,
 194                                              DecoderWriteCallback );
 195     FLAC__stream_decoder_set_metadata_callback( p_sys->p_flac,
 196                                                 DecoderMetadataCallback );
 197     FLAC__stream_decoder_set_error_callback( p_sys->p_flac,
 198                                              DecoderErrorCallback );
 199     FLAC__stream_decoder_set_client_data( p_sys->p_flac, p_dec );
 200
 201     FLAC__stream_decoder_init( p_sys->p_flac );
 202
 203     /* Set output properties */
 204     p_dec->fmt_out.i_cat = AUDIO_ES;
 205     p_dec->fmt_out.i_codec = VLC_FOURCC('f','l','3','2');
 206
 207     /* Set callbacks */
 208     p_dec->pf_decode_audio = DecodeBlock;
 209     p_dec->pf_packetize    = PacketizeBlock;
 210
 211
 212     /* Decode STREAMINFO */
 213     msg_Dbg( p_dec, "decode STREAMINFO" );
 214     p_sys->p_block = block_New( p_dec, p_dec->fmt_in.i_extra + 4 );
 215     memcpy( p_sys->p_block->p_buffer + 4, p_dec->fmt_in.p_extra,
 216             p_dec->fmt_in.i_extra );
 217     memcpy( p_sys->p_block->p_buffer, "fLaC", 4 );
 218     FLAC__stream_decoder_process_until_end_of_metadata( p_sys->p_flac );
 219     msg_Dbg( p_dec, "STREAMINFO decoded" );
 220
 221     return VLC_SUCCESS;
 222 }
 223
 224 static int OpenPacketizer( vlc_object_t *p_this )
 225 {
 226     decoder_t *p_dec = (decoder_t*)p_this;
 227
 228     int i_ret = OpenDecoder( p_this );
 229
 230     if( i_ret == VLC_SUCCESS )
 231     {
 232         p_dec->p_sys->b_packetizer = VLC_TRUE;
 233         p_dec->fmt_out.i_codec = VLC_FOURCC('f','l','a','c');
 234     }
 235
 236     return i_ret;
 237 }
 238
 239 /****************************************************************************
 240  * PacketizeBlock: the whole thing
 241  ****************************************************************************
 242  * This function is called just after the thread is launched.
 243  ****************************************************************************/
 244 static block_t *PacketizeBlock( decoder_t *p_dec, block_t **pp_block )
 245 {
 246     decoder_sys_t *p_sys = p_dec->p_sys;
 247     uint8_t p_header[MAX_FLAC_HEADER_SIZE];
 248     block_t *p_sout_block;
 249
 250     if( !pp_block || !*pp_block ) return NULL;
 251
 252 #if 0
 253     if( (*pp_block)->b_discontinuity )
 254     {
 255         p_sys->i_state = STATE_NOSYNC;
 256     }
 257 #endif
 258
 259     block_BytestreamPush( &p_sys->bytestream, *pp_block );
 260
 261     while( 1 )
 262     {
 263         switch( p_sys->i_state )
 264         {
 265         case STATE_NOSYNC:
 266             while( block_PeekBytes( &p_sys->bytestream, p_header, 2 )
 267                    == VLC_SUCCESS )
 268             {
 269                 if( p_header[0] == 0xFF && p_header[1] == 0xF8 )
 270                 {
 271                     p_sys->i_state = STATE_SYNC;
 272                     break;
 273                 }
 274                 block_SkipByte( &p_sys->bytestream );
 275             }
 276             if( p_sys->i_state != STATE_SYNC )
 277             {
 278                 block_BytestreamFlush( &p_sys->bytestream );
 279
 280                 /* Need more data */
 281                 return NULL;
 282             }
 283
 284         case STATE_SYNC:
 285             /* New frame, set the Presentation Time Stamp */
 286             p_sys->i_pts = p_sys->bytestream.p_block->i_pts;
 287             if( p_sys->i_pts != 0 &&
 288                 p_sys->i_pts != aout_DateGet( &p_sys->end_date ) )
 289             {
 290                 aout_DateSet( &p_sys->end_date, p_sys->i_pts );
 291             }
 292             p_sys->i_state = STATE_HEADER;
 293
 294         case STATE_HEADER:
 295             /* Get FLAC frame header (MAX_FLAC_HEADER_SIZE bytes) */
 296             if( block_PeekBytes( &p_sys->bytestream, p_header,
 297                                  MAX_FLAC_HEADER_SIZE ) != VLC_SUCCESS )
 298             {
 299                 /* Need more data */
 300                 return NULL;
 301             }
 302
 303             /* Check if frame is valid and get frame info */
 304             p_sys->i_frame_length = SyncInfo( p_dec, p_header,
 305                                               &p_sys->i_channels,
 306                                               &p_sys->i_channels_conf,
 307                                               &p_sys->i_rate,
 308                                               &p_sys->i_bits_per_sample );
 309             if( !p_sys->i_frame_length )
 310             {
 311                 msg_Dbg( p_dec, "emulated sync word" );
 312                 block_SkipByte( &p_sys->bytestream );
 313                 p_sys->i_state = STATE_NOSYNC;
 314                 break;
 315             }
 316             p_sys->i_state = STATE_NEXT_SYNC;
 317             p_sys->i_frame_size = 1;
 318
 319         case STATE_NEXT_SYNC:
 320             /* TODO: If pp_block == NULL, flush the buffer without checking the
 321              * next sync word */
 322
 323             /* Check if next expected frame contains the sync word */
 324             while( block_PeekOffsetBytes( &p_sys->bytestream,
 325                                           p_sys->i_frame_size, p_header,
 326                                           MAX_FLAC_HEADER_SIZE )
 327                    == VLC_SUCCESS )
 328             {
 329                 if( p_header[0] == 0xFF && p_header[1] == 0xF8 )
 330                 {
 331                     /* Check if frame is valid and get frame info */
 332                     p_sys->i_frame_length =
 333                         SyncInfo( p_dec, p_header,
 334                                   &p_sys->i_channels,
 335                                   &p_sys->i_channels_conf,
 336                                   &p_sys->i_rate,
 337                                   &p_sys->i_bits_per_sample );
 338
 339                     if( p_sys->i_frame_length )
 340                     {
 341                         p_sys->i_state = STATE_SEND_DATA;
 342                         break;
 343                     }
 344                 }
 345                 p_sys->i_frame_size++;
 346             }
 347
 348             if( p_sys->i_state != STATE_SEND_DATA )
 349             {
 350                 /* Need more data */
 351                 return NULL;
 352             }
 353             break;
 354
 355         case STATE_SEND_DATA:
 356             p_sout_block = block_New( p_dec, p_sys->i_frame_size );
 357
 358             /* Copy the whole frame into the buffer. When we reach this point
 359              * we already know we have enough data available. */
 360             block_GetBytes( &p_sys->bytestream, p_sout_block->p_buffer,
 361                             p_sys->i_frame_size );
 362
 363             /* Make sure we don't reuse the same pts twice */
 364             if( p_sys->i_pts == p_sys->bytestream.p_block->i_pts )
 365                 p_sys->i_pts = p_sys->bytestream.p_block->i_pts = 0;
 366
 367             /* So p_block doesn't get re-added several times */
 368             *pp_block = block_BytestreamPop( &p_sys->bytestream );
 369
 370             p_sys->i_state = STATE_NOSYNC;
 371
 372             /* Date management */
 373             p_sout_block->i_pts = aout_DateGet( &p_sys->end_date );
 374             p_sout_block->i_length =
 375                 aout_DateIncrement( &p_sys->end_date, p_sys->i_frame_length );
 376
 377             return p_sout_block;
 378         }
 379     }
 380
 381     return NULL;
 382 }
 383
 384 /****************************************************************************
 385  * DecodeBlock: the whole thing
 386  ****************************************************************************/
 387 static aout_buffer_t *DecodeBlock( decoder_t *p_dec, block_t **pp_block )
 388 {
 389     decoder_sys_t *p_sys = p_dec->p_sys;
 390
 391     if( !pp_block || !*pp_block ) return NULL;
 392
 393     if( !aout_DateGet( &p_sys->end_date ) && !(*pp_block)->i_pts )
 394     {
 395         /* We've just started the stream, wait for the first PTS. */
 396         block_Release( *pp_block );
 397         return NULL;
 398     }
 399
 400     p_sys->p_aout_buffer = 0;
 401     if( ( p_sys->p_block = PacketizeBlock( p_dec, pp_block ) ) )
 402     {
 403         if( !FLAC__stream_decoder_process_single( p_sys->p_flac ) )
 404         {
 405             decoder_state_error( p_dec,
 406                 FLAC__stream_decoder_get_state( p_sys->p_flac ) );
 407         }
 408         block_Release( p_sys->p_block );
 409     }
 410
 411     return p_sys->p_aout_buffer;
 412 }
 413
 414 /*****************************************************************************
 415  * CloseDecoder: flac decoder destruction
 416  *****************************************************************************/
 417 static void CloseDecoder( vlc_object_t *p_this )
 418 {
 419     decoder_t *p_dec = (decoder_t *)p_this;
 420     decoder_sys_t *p_sys = p_dec->p_sys;
 421
 422     FLAC__stream_decoder_finish( p_sys->p_flac );
 423     FLAC__stream_decoder_delete( p_sys->p_flac );
 424     free( p_sys );
 425 }
 426
 427 /*****************************************************************************
 428  * DecoderReadCallback: called by libflac when it needs more data
 429  *****************************************************************************/
 430 static FLAC__StreamDecoderReadStatus
 431 DecoderReadCallback( const FLAC__StreamDecoder *decoder, FLAC__byte buffer[],
 432                      unsigned *bytes, void *client_data )
 433 {
 434     decoder_t *p_dec = (decoder_t *)client_data;
 435     decoder_sys_t *p_sys = p_dec->p_sys;
 436
 437     msg_Err( p_dec, "buffer: %i", p_sys->p_block->i_buffer );
 438     if( p_sys->p_block && p_sys->p_block->i_buffer )
 439     {
 440         *bytes = __MIN(*bytes, (unsigned)p_sys->p_block->i_buffer);
 441         memcpy( buffer, p_sys->p_block->p_buffer, *bytes );
 442         p_sys->p_block->i_buffer -= *bytes;
 443         p_sys->p_block->p_buffer += *bytes;
 444     }
 445     else
 446     {
 447         *bytes = 0;
 448         return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
 449     }
 450
 451     return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
 452 }
 453
 454 /*****************************************************************************
 455  * DecoderWriteCallback: called by libflac to output decoded samples
 456  *****************************************************************************/
 457 static FLAC__StreamDecoderWriteStatus
 458 DecoderWriteCallback( const FLAC__StreamDecoder *decoder,
 459                       const FLAC__Frame *frame,
 460                       const FLAC__int32 *const buffer[], void *client_data )
 461 {
 462     decoder_t *p_dec = (decoder_t *)client_data;
 463     decoder_sys_t *p_sys = p_dec->p_sys;
 464
 465     if( p_sys->p_block && p_sys->p_block->i_pts != 0 &&
 466         p_sys->p_block->i_pts != aout_DateGet( &p_sys->end_date ) )
 467     {
 468         aout_DateSet( &p_sys->end_date, p_sys->p_block->i_pts );
 469     }
 470     else if( !aout_DateGet( &p_sys->end_date ) )
 471     {
 472         return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
 473     }
 474
 475     if( p_sys->p_block ) p_sys->p_block->i_pts = 0;
 476
 477     p_sys->p_aout_buffer =
 478         p_dec->pf_aout_buffer_new( p_dec, frame->header.blocksize );
 479
 480     if( p_sys->p_aout_buffer == NULL )
 481         return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
 482
 483     switch( frame->header.bits_per_sample )
 484     {
 485     case 16:
 486         Interleave16( (int16_t *)p_sys->p_aout_buffer->p_buffer, buffer,
 487                       frame->header.channels, frame->header.blocksize );
 488         break;
 489     default:
 490         Interleave32( (int32_t *)p_sys->p_aout_buffer->p_buffer, buffer,
 491                       frame->header.channels, frame->header.blocksize );
 492     }
 493
 494     /* Date management */
 495     p_sys->p_aout_buffer->start_date = aout_DateGet( &p_sys->end_date );
 496     p_sys->p_aout_buffer->end_date =
 497         aout_DateIncrement( &p_sys->end_date, frame->header.blocksize );
 498
 499     return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
 500 }
 501
 502 /*****************************************************************************
 503  * DecoderMetadataCallback: called by libflac to when it encounters metadata
 504  *****************************************************************************/
 505 static void DecoderMetadataCallback( const FLAC__StreamDecoder *decoder,
 506                                      const FLAC__StreamMetadata *metadata,
 507                                      void *client_data )
 508 {
 509     decoder_t *p_dec = (decoder_t *)client_data;
 510     decoder_sys_t *p_sys = p_dec->p_sys;
 511
 512     switch( metadata->data.stream_info.bits_per_sample )
 513     {
 514     case 8:
 515         p_dec->fmt_out.i_codec = VLC_FOURCC('s','8',' ',' ');
 516         break;
 517     case 16:
 518         p_dec->fmt_out.i_codec = AOUT_FMT_S16_NE;
 519         break;
 520     default:
 521         msg_Dbg( p_dec, "strange bps %d",
 522                  metadata->data.stream_info.bits_per_sample );
 523         p_dec->fmt_out.i_codec = VLC_FOURCC('f','i','3','2');
 524         break;
 525     }
 526
 527     /* Setup the format */
 528     p_dec->fmt_out.audio.i_rate     = metadata->data.stream_info.sample_rate;
 529     p_dec->fmt_out.audio.i_channels = metadata->data.stream_info.channels;
 530     p_dec->fmt_out.audio.i_physical_channels =
 531         p_dec->fmt_out.audio.i_original_channels =
 532             pi_channels_maps[metadata->data.stream_info.channels];
 533     p_dec->fmt_out.audio.i_bitspersample =
 534         metadata->data.stream_info.bits_per_sample;
 535
 536     aout_DateInit( &p_sys->end_date, p_dec->fmt_out.audio.i_rate );
 537
 538     msg_Dbg( p_dec, "channels:%d samplerate:%d bitspersamples:%d",
 539              p_dec->fmt_out.audio.i_channels, p_dec->fmt_out.audio.i_rate,
 540              p_dec->fmt_out.audio.i_bitspersample );
 541
 542     p_sys->b_stream_info = VLC_TRUE;
 543     p_sys->stream_info = metadata->data.stream_info;
 544
 545     return;
 546 }
 547
 548 /*****************************************************************************
 549  * DecoderErrorCallback: called when the libflac decoder encounters an error
 550  *****************************************************************************/
 551 static void DecoderErrorCallback( const FLAC__StreamDecoder *decoder,
 552                                   FLAC__StreamDecoderErrorStatus status,
 553                                   void *client_data )
 554 {
 555     decoder_t *p_dec = (decoder_t *)client_data;
 556
 557     switch( status )
 558     {
 559     case FLAC__STREAM_DECODER_ERROR_STATUS_LOST_SYNC:
 560         msg_Err( p_dec, "An error in the stream caused the decoder to "
 561                  "loose synchronization." );
 562         break;
 563     case FLAC__STREAM_DECODER_ERROR_STATUS_BAD_HEADER:
 564         msg_Err( p_dec, "The decoder encountered a corrupted frame header." );
 565         break;
 566     case FLAC__STREAM_DECODER_ERROR_STATUS_FRAME_CRC_MISMATCH:
 567         msg_Err( p_dec, "The frame's data did not match the CRC in the "
 568                  "footer." );
 569         break;
 570     default:
 571         msg_Err( p_dec, "got decoder error: %d", status );
 572     }
 573     return;
 574 }
 575
 576 /*****************************************************************************
 577  * Interleave: helper function to interleave channels
 578  *****************************************************************************/
 579 static void Interleave32( int32_t *p_out, const int32_t * const *pp_in,
 580                           int i_nb_channels, int i_samples )
 581 {
 582     int i, j;
 583     for ( j = 0; j < i_samples; j++ )
 584     {
 585         for ( i = 0; i < i_nb_channels; i++ )
 586         {
 587             p_out[j * i_nb_channels + i] = pp_in[i][j];
 588         }
 589     }
 590 }
 591 static void Interleave16( int16_t *p_out, const int32_t * const *pp_in,
 592                           int i_nb_channels, int i_samples )
 593 {
 594     int i, j;
 595     for ( j = 0; j < i_samples; j++ )
 596     {
 597         for ( i = 0; i < i_nb_channels; i++ )
 598         {
 599             p_out[j * i_nb_channels + i] = (int32_t)(pp_in[i][j]);
 600         }
 601     }
 602 }
 603
 604 /*****************************************************************************
 605  * decoder_state_error: print meaningful error messages
 606  *****************************************************************************/
 607 static void decoder_state_error( decoder_t *p_dec,
 608                                  FLAC__StreamDecoderState state )
 609 {
 610     switch ( state )
 611     {
 612     case FLAC__STREAM_DECODER_SEARCH_FOR_METADATA:
 613         msg_Err( p_dec, "The decoder is ready to search for metadata." );
 614         break;
 615     case FLAC__STREAM_DECODER_READ_METADATA:
 616         msg_Err( p_dec, "The decoder is ready to or is in the process of "
 617                  "reading metadata." );
 618         break;
 619     case FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC:
 620         msg_Err( p_dec, "The decoder is ready to or is in the process of "
 621                  "searching for the frame sync code." );
 622         break;
 623     case FLAC__STREAM_DECODER_READ_FRAME:
 624         msg_Err( p_dec, "The decoder is ready to or is in the process of "
 625                  "reading a frame." );
 626         break;
 627     case FLAC__STREAM_DECODER_END_OF_STREAM:
 628         msg_Err( p_dec, "The decoder has reached the end of the stream." );
 629         break;
 630     case FLAC__STREAM_DECODER_ABORTED:
 631         msg_Err( p_dec, "The decoder was aborted by the read callback." );
 632         break;
 633     case FLAC__STREAM_DECODER_UNPARSEABLE_STREAM:
 634         msg_Err( p_dec, "The decoder encountered reserved fields in use "
 635                  "in the stream." );
 636         FLAC__stream_decoder_flush( p_dec->p_sys->p_flac );
 637         break;
 638     case FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR:
 639         msg_Err( p_dec, "An error occurred allocating memory." );
 640         break;
 641     case FLAC__STREAM_DECODER_ALREADY_INITIALIZED:
 642         msg_Err( p_dec, "FLAC__stream_decoder_init() was called when the "
 643                  "decoder was already initialized, usually because "
 644                  "FLAC__stream_decoder_finish() was not called." );
 645         break;
 646     case FLAC__STREAM_DECODER_INVALID_CALLBACK:
 647         msg_Err( p_dec, "FLAC__stream_decoder_init() was called without "
 648                  "all callbacks being set." );
 649         break;
 650     case FLAC__STREAM_DECODER_UNINITIALIZED:
 651         msg_Err( p_dec, "The decoder is in the uninitialized state." );
 652         break;
 653     default:
 654         msg_Err(p_dec, "unknown error" );
 655     }
 656 }
 657
 658 /*****************************************************************************
 659  * SyncInfo: parse FLAC sync info
 660  *****************************************************************************/
 661 static int SyncInfo( decoder_t *p_dec, uint8_t *p_buf,
 662                      int * pi_channels, int * pi_channels_conf,
 663                      int * pi_sample_rate, int * pi_bits_per_sample )
 664 {
 665     decoder_sys_t *p_sys = p_dec->p_sys;
 666     int i_header, i_temp, i_read;
 667     int i_blocksize = 0, i_blocksize_hint = 0, i_sample_rate_hint = 0;
 668     uint64_t i_sample_number = 0;
 669
 670     vlc_bool_t b_variable_blocksize = ( p_sys->b_stream_info &&
 671         p_sys->stream_info.min_blocksize != p_sys->stream_info.max_blocksize );
 672     vlc_bool_t b_fixed_blocksize = ( p_sys->b_stream_info &&
 673         p_sys->stream_info.min_blocksize == p_sys->stream_info.max_blocksize );
 674
 675     /* Check syncword */
 676     if( p_buf[0] != 0xFF || p_buf[1] != 0xF8 ) return 0;
 677
 678     /* Check there is no emulated sync code in the rest of the header */
 679     if( p_buf[2] == 0xff || p_buf[3] == 0xFF ) return 0;
 680
 681     /* Find blocksize (framelength) */
 682     switch( i_temp = p_buf[2] >> 4 )
 683     {
 684     case 0:
 685         if( b_fixed_blocksize )
 686             i_blocksize = p_sys->stream_info.min_blocksize;
 687         else return 0; /* We can't do anything with this */
 688         break;
 689
 690     case 1:
 691         i_blocksize = 192;
 692         break;
 693
 694     case 2:
 695     case 3:
 696     case 4:
 697     case 5:
 698         i_blocksize = 576 << (i_temp - 2);
 699         break;
 700
 701     case 6:
 702     case 7:
 703         i_blocksize_hint = i_temp;
 704         break;
 705
 706     case 8:
 707     case 9:
 708     case 10:
 709     case 11:
 710     case 12:
 711     case 13:
 712     case 14:
 713     case 15:
 714         i_blocksize = 256 << (i_temp - 8);
 715         break;
 716     }
 717
 718     /* Find samplerate */
 719     switch( i_temp = p_buf[2] & 0x0f )
 720     {
 721     case 0:
 722         if( p_sys->b_stream_info )
 723             *pi_sample_rate = p_sys->stream_info.sample_rate;
 724         else return 0; /* We can't do anything with this */
 725         break;
 726
 727     case 1:
 728     case 2:
 729     case 3:
 730         return 0;
 731         break;
 732
 733     case 4:
 734         *pi_sample_rate = 8000;
 735         break;
 736
 737     case 5:
 738         *pi_sample_rate = 16000;
 739         break;
 740
 741     case 6:
 742         *pi_sample_rate = 22050;
 743         break;
 744
 745     case 7:
 746         *pi_sample_rate = 24000;
 747         break;
 748
 749     case 8:
 750         *pi_sample_rate = 32000;
 751         break;
 752
 753     case 9:
 754         *pi_sample_rate = 44100;
 755         break;
 756
 757     case 10:
 758         *pi_sample_rate = 48000;
 759         break;
 760
 761     case 11:
 762         *pi_sample_rate = 96000;
 763         break;
 764
 765     case 12:
 766     case 13:
 767     case 14:
 768         i_sample_rate_hint = i_temp;
 769         break;
 770
 771     case 15:
 772         return 0;
 773     }
 774
 775     /* Find channels */
 776     i_temp = (unsigned)(p_buf[3] >> 4);
 777     if( i_temp & 8 )
 778     {
 779         int i_channel_assignment; /* ??? */
 780
 781         *pi_channels = 2;
 782         switch( i_temp & 7 )
 783         {
 784         case 0:
 785             i_channel_assignment = FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE;
 786             break;
 787         case 1:
 788             i_channel_assignment = FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE;
 789             break;
 790         case 2:
 791             i_channel_assignment = FLAC__CHANNEL_ASSIGNMENT_MID_SIDE;
 792             break;
 793         default:
 794             return 0;
 795             break;
 796         }
 797     }
 798     else
 799     {
 800         *pi_channels = i_temp + 1;
 801         *pi_channels_conf = pi_channels_maps[ *pi_channels ];
 802     }
 803
 804     /* Find bits per sample */
 805     switch( i_temp = (unsigned)(p_buf[3] & 0x0e) >> 1 )
 806     {
 807     case 0:
 808         if( p_sys->b_stream_info )
 809             *pi_bits_per_sample = p_sys->stream_info.bits_per_sample;
 810         else
 811             return 0;
 812         break;
 813
 814     case 1:
 815         *pi_bits_per_sample = 8;
 816         break;
 817
 818     case 2:
 819         *pi_bits_per_sample = 12;
 820         break;
 821
 822     case 4:
 823         *pi_bits_per_sample = 16;
 824         break;
 825
 826     case 5:
 827         *pi_bits_per_sample = 20;
 828         break;
 829
 830     case 6:
 831         *pi_bits_per_sample = 24;
 832         break;
 833
 834     case 3:
 835     case 7:
 836         return 0;
 837         break;
 838     }
 839
 840     /* Zero padding bit */
 841     if( p_buf[3] & 0x01 ) return 0;
 842
 843     /* End of fixed size header */
 844     i_header = 4;
 845
 846     /* Find Sample/Frame number */
 847     if( i_blocksize_hint && b_variable_blocksize )
 848     {
 849         i_sample_number = read_utf8( &p_buf[i_header++], &i_read );
 850         if( i_sample_number == I64C(0xffffffffffffffff) ) return 0;
 851     }
 852     else
 853     {
 854         i_sample_number = read_utf8( &p_buf[i_header++], &i_read );
 855         if( i_sample_number == I64C(0xffffffffffffffff) ) return 0;
 856
 857         if( p_sys->b_stream_info )
 858             i_sample_number *= p_sys->stream_info.min_blocksize;
 859     }
 860
 861     i_header += i_read;
 862
 863     /* Read blocksize */
 864     if( i_blocksize_hint )
 865     {
 866         int i_val1 = p_buf[i_header++];
 867         if( i_blocksize_hint == 7 )
 868         {
 869             int i_val2 = p_buf[i_header++];
 870             i_val1 = (i_val1 << 8) | i_val2;
 871         }
 872         i_blocksize = i_val1 + 1;
 873     }
 874
 875     /* Read sample rate */
 876     if( i_sample_rate_hint )
 877     {
 878         int i_val1 = p_buf[i_header++];
 879         if( i_sample_rate_hint != 12 )
 880         {
 881             int i_val2 = p_buf[i_header++];
 882             i_val1 = (i_val1 << 8) | i_val2;
 883         }
 884         if( i_sample_rate_hint == 12 ) *pi_sample_rate = i_val1 * 1000;
 885         else if( i_sample_rate_hint == 13 ) *pi_sample_rate = i_val1;
 886         else *pi_sample_rate = i_val1 * 10;
 887     }
 888
 889     /* Check the CRC-8 byte */
 890     if( flac_crc8( p_buf, i_header ) != p_buf[i_header] )
 891     {
 892         return 0;
 893     }
 894
 895     return i_blocksize;
 896 }
 897
 898 /* Will return 0xffffffffffffffff for an invalid utf-8 sequence */
 899 static uint64_t read_utf8( const uint8_t *p_buf, int *pi_read )
 900 {
 901     uint64_t i_result = 0;
 902     unsigned i, j;
 903
 904     if( !(p_buf[0] & 0x80) ) /* 0xxxxxxx */
 905     {
 906         i_result = p_buf[0];
 907         i = 0;
 908     }
 909     else if( p_buf[0] & 0xC0 && !(p_buf[0] & 0x20) ) /* 110xxxxx */
 910     {
 911         i_result = p_buf[0] & 0x1F;
 912         i = 1;
 913     }
 914     else if( p_buf[0] & 0xE0 && !(p_buf[0] & 0x10) ) /* 1110xxxx */
 915     {
 916         i_result = p_buf[0] & 0x0F;
 917         i = 2;
 918     }
 919     else if( p_buf[0] & 0xF0 && !(p_buf[0] & 0x08) ) /* 11110xxx */
 920     {
 921         i_result = p_buf[0] & 0x07;
 922         i = 3;
 923     }
 924     else if( p_buf[0] & 0xF8 && !(p_buf[0] & 0x04) ) /* 111110xx */
 925     {
 926         i_result = p_buf[0] & 0x03;
 927         i = 4;
 928     }
 929     else if( p_buf[0] & 0xFC && !(p_buf[0] & 0x02) ) /* 1111110x */
 930     {
 931         i_result = p_buf[0] & 0x01;
 932         i = 5;
 933     }
 934     else if( p_buf[0] & 0xFE && !(p_buf[0] & 0x01) ) /* 11111110 */
 935     {
 936         i_result = 0;
 937         i = 6;
 938     }
 939     else {
 940         return I64C(0xffffffffffffffff);
 941     }
 942
 943     for( j = 1; j <= i; j++ )
 944     {
 945         if( !(p_buf[j] & 0x80) || (p_buf[j] & 0x40) ) /* 10xxxxxx */
 946         {
 947             return I64C(0xffffffffffffffff);
 948         }
 949         i_result <<= 6;
 950         i_result |= (p_buf[j] & 0x3F);
 951     }
 952
 953     *pi_read = i;
 954     return i_result;
 955 }
 956
 957 /* CRC-8, poly = x^8 + x^2 + x^1 + x^0, init = 0 */
 958 static uint8_t const flac_crc8_table[256] = {
 959         0x00, 0x07, 0x0E, 0x09, 0x1C, 0x1B, 0x12, 0x15,
 960         0x38, 0x3F, 0x36, 0x31, 0x24, 0x23, 0x2A, 0x2D,
 961         0x70, 0x77, 0x7E, 0x79, 0x6C, 0x6B, 0x62, 0x65,
 962         0x48, 0x4F, 0x46, 0x41, 0x54, 0x53, 0x5A, 0x5D,
 963         0xE0, 0xE7, 0xEE, 0xE9, 0xFC, 0xFB, 0xF2, 0xF5,
 964         0xD8, 0xDF, 0xD6, 0xD1, 0xC4, 0xC3, 0xCA, 0xCD,
 965         0x90, 0x97, 0x9E, 0x99, 0x8C, 0x8B, 0x82, 0x85,
 966         0xA8, 0xAF, 0xA6, 0xA1, 0xB4, 0xB3, 0xBA, 0xBD,
 967         0xC7, 0xC0, 0xC9, 0xCE, 0xDB, 0xDC, 0xD5, 0xD2,
 968         0xFF, 0xF8, 0xF1, 0xF6, 0xE3, 0xE4, 0xED, 0xEA,
 969         0xB7, 0xB0, 0xB9, 0xBE, 0xAB, 0xAC, 0xA5, 0xA2,
 970         0x8F, 0x88, 0x81, 0x86, 0x93, 0x94, 0x9D, 0x9A,
 971         0x27, 0x20, 0x29, 0x2E, 0x3B, 0x3C, 0x35, 0x32,
 972         0x1F, 0x18, 0x11, 0x16, 0x03, 0x04, 0x0D, 0x0A,
 973         0x57, 0x50, 0x59, 0x5E, 0x4B, 0x4C, 0x45, 0x42,
 974         0x6F, 0x68, 0x61, 0x66, 0x73, 0x74, 0x7D, 0x7A,
 975         0x89, 0x8E, 0x87, 0x80, 0x95, 0x92, 0x9B, 0x9C,
 976         0xB1, 0xB6, 0xBF, 0xB8, 0xAD, 0xAA, 0xA3, 0xA4,
 977         0xF9, 0xFE, 0xF7, 0xF0, 0xE5, 0xE2, 0xEB, 0xEC,
 978         0xC1, 0xC6, 0xCF, 0xC8, 0xDD, 0xDA, 0xD3, 0xD4,
 979         0x69, 0x6E, 0x67, 0x60, 0x75, 0x72, 0x7B, 0x7C,
 980         0x51, 0x56, 0x5F, 0x58, 0x4D, 0x4A, 0x43, 0x44,
 981         0x19, 0x1E, 0x17, 0x10, 0x05, 0x02, 0x0B, 0x0C,
 982         0x21, 0x26, 0x2F, 0x28, 0x3D, 0x3A, 0x33, 0x34,
 983         0x4E, 0x49, 0x40, 0x47, 0x52, 0x55, 0x5C, 0x5B,
 984         0x76, 0x71, 0x78, 0x7F, 0x6A, 0x6D, 0x64, 0x63,
 985         0x3E, 0x39, 0x30, 0x37, 0x22, 0x25, 0x2C, 0x2B,
 986         0x06, 0x01, 0x08, 0x0F, 0x1A, 0x1D, 0x14, 0x13,
 987         0xAE, 0xA9, 0xA0, 0xA7, 0xB2, 0xB5, 0xBC, 0xBB,
 988         0x96, 0x91, 0x98, 0x9F, 0x8A, 0x8D, 0x84, 0x83,
 989         0xDE, 0xD9, 0xD0, 0xD7, 0xC2, 0xC5, 0xCC, 0xCB,
 990         0xE6, 0xE1, 0xE8, 0xEF, 0xFA, 0xFD, 0xF4, 0xF3
 991 };
 992
 993 static uint8_t flac_crc8( const uint8_t *data, unsigned len )
 994 {
 995     uint8_t crc = 0;
 996
 997     while(len--)
 998         crc = flac_crc8_table[crc ^ *data++];
 999
1000     return crc;
1001 }