开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 查看源码
flac.c
资源名称：vlc-0.8.1.tar.gz　[点击查看]
上传用户：riyaled888
上传日期：2009-03-27
资源大小：7338k
文件大小：40k
源码类别：

多媒体

开发平台：

MultiPlatform

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