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

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