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

   1 /*****************************************************************************
   2  * shine_mod.c: MP3 encoder using Shine, a fixed point implementation
   3  *****************************************************************************
   4  * Copyright (C) 2008-2009 M2X
   5  *
   6  * Authors: Rafaël Carré <rcarre@m2x.nl>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  21  *****************************************************************************/
  22
  23 /*****************************************************************************
  24  * Preamble
  25  *****************************************************************************/
  26 #ifdef HAVE_CONFIG_H
  27 # include "config.h"
  28 #endif
  29
  30 #include <vlc_common.h>
  31 #include <vlc_plugin.h>
  32 #include <vlc_codec.h>
  33 #include <vlc_aout.h>
  34 #include <vlc_block.h>
  35 #include <vlc_block_helper.h>
  36 #include <vlc_bits.h>
  37
  38 #include <assert.h>
  39 #include <inttypes.h>
  40
  41 /* shine.c uses a lot of static variables, so we include the C file to keep
  42  * the scope.
  43  * Note that it makes this decoder non reentrant, this is why we have the
  44  * struct entrant below */
  45 #include "shine.c"
  46
  47 struct encoder_sys_t
  48 {
  49     block_fifo_t *p_fifo;
  50
  51     unsigned int i_buffer;
  52     uint8_t *p_buffer;
  53 };
  54
  55 /*****************************************************************************
  56  * Local prototypes
  57  *****************************************************************************/
  58 static int  OpenEncoder   ( vlc_object_t * );
  59 static void CloseEncoder  ( vlc_object_t * );
  60
  61 static block_t *EncodeFrame  ( encoder_t *, aout_buffer_t * );
  62
  63 vlc_module_begin();
  64     set_category( CAT_INPUT );
  65     set_subcategory( SUBCAT_INPUT_ACODEC );
  66     set_description( _("MP3 fixed point audio encoder") );
  67     set_capability( "encoder", 50 );
  68     set_callbacks( OpenEncoder, CloseEncoder );
  69 vlc_module_end();
  70
  71 static struct
  72 {
  73     bool busy;
  74     vlc_mutex_t lock;
  75 } entrant = { false, VLC_STATIC_MUTEX, };
  76
  77 static int OpenEncoder( vlc_object_t *p_this )
  78 {
  79     encoder_t *p_enc = (encoder_t*)p_this;
  80     encoder_sys_t *p_sys;
  81
  82     /* FIXME: what about layers 1 and 2 ? shine is an 'MP3' encoder */
  83     if( p_enc->fmt_out.i_codec != VLC_CODEC_MP3 ||
  84         p_enc->fmt_out.audio.i_channels > 2 )
  85         return VLC_EGENERIC;
  86
  87     /* Shine is strict on its input */
  88     if( p_enc->fmt_in.audio.i_channels != 2 )
  89     {
  90         msg_Err( p_enc, "Only stereo input is accepted, rejecting %d channels",
  91             p_enc->fmt_in.audio.i_channels );
  92         return VLC_EGENERIC;
  93     }
  94
  95     if( p_enc->fmt_out.i_bitrate <= 0 )
  96     {
  97         msg_Err( p_enc, "unknown bitrate" );
  98         return VLC_EGENERIC;
  99     }
 100
 101     msg_Dbg( p_enc, "bitrate %d, samplerate %d, channels %d",
 102              p_enc->fmt_out.i_bitrate, p_enc->fmt_out.audio.i_rate,
 103              p_enc->fmt_out.audio.i_channels );
 104
 105     vlc_mutex_lock( &entrant.lock );
 106     if( entrant.busy )
 107     {
 108         msg_Err( p_enc, "encoder already in progress" );
 109         vlc_mutex_unlock( &entrant.lock );
 110         return VLC_EGENERIC;
 111     }
 112     entrant.busy = true;
 113     vlc_mutex_unlock( &entrant.lock );
 114
 115     p_enc->p_sys = p_sys = calloc( 1, sizeof( *p_sys ) );
 116     if( !p_sys )
 117         goto enomem;
 118
 119     if( !( p_sys->p_fifo = block_FifoNew() ) )
 120     {
 121         free( p_sys );
 122         goto enomem;
 123     }
 124
 125     init_mp3_encoder_engine( p_enc->fmt_out.audio.i_rate,
 126         p_enc->fmt_out.audio.i_channels, p_enc->fmt_out.i_bitrate / 1000 );
 127
 128     p_enc->pf_encode_audio = EncodeFrame;
 129     p_enc->fmt_out.i_cat = AUDIO_ES;
 130
 131     return VLC_SUCCESS;
 132
 133 enomem:
 134     vlc_mutex_lock( &entrant.lock );
 135     entrant.busy = false;
 136     vlc_mutex_unlock( &entrant.lock );
 137     return VLC_ENOMEM;
 138 }
 139
 140 /* We split/pack PCM blocks to a fixed size: pcm_chunk_size bytes */
 141 static block_t *GetPCM( encoder_t *p_enc, aout_buffer_t *p_block )
 142 {
 143     encoder_sys_t *p_sys = p_enc->p_sys;
 144     block_t *p_pcm_block;
 145
 146     if( !p_block ) goto buffered; /* just return a block if we can */
 147
 148     /* Put the PCM samples sent by VLC in the Fifo */
 149     while( p_sys->i_buffer + p_block->i_buffer >= pcm_chunk_size )
 150     {
 151         unsigned int i_buffer = 0;
 152         p_pcm_block = block_New( p_enc, pcm_chunk_size );
 153         if( !p_pcm_block )
 154             break;
 155
 156         if( p_sys->i_buffer )
 157         {
 158             vlc_memcpy( p_pcm_block->p_buffer, p_sys->p_buffer, p_sys->i_buffer );
 159
 160             i_buffer = p_sys->i_buffer;
 161             p_sys->i_buffer = 0;
 162             free( p_sys->p_buffer );
 163         }
 164
 165         vlc_memcpy( p_pcm_block->p_buffer + i_buffer,
 166                     p_block->p_buffer, pcm_chunk_size - i_buffer );
 167         p_block->p_buffer += pcm_chunk_size - i_buffer;
 168
 169         p_block->i_buffer -= pcm_chunk_size - i_buffer;
 170
 171         block_FifoPut( p_sys->p_fifo, p_pcm_block );
 172     }
 173
 174     /* We hadn't enough data to make a block, put it in standby */
 175     if( p_block->i_buffer )
 176     {
 177         uint8_t *p_tmp;
 178
 179         if( p_sys->i_buffer > 0 )
 180             p_tmp = realloc( p_sys->p_buffer, p_block->i_buffer + p_sys->i_buffer );
 181         else
 182             p_tmp = malloc( p_block->i_buffer );
 183
 184         if( !p_tmp )
 185         {
 186             p_sys->i_buffer = 0;
 187             free( p_sys->p_buffer );
 188             p_sys->p_buffer = NULL;
 189             return NULL;
 190         }
 191         p_sys->p_buffer = p_tmp;
 192         vlc_memcpy( p_sys->p_buffer + p_sys->i_buffer,
 193                     p_block->p_buffer, p_block->i_buffer );
 194
 195         p_sys->i_buffer += p_block->i_buffer;
 196         p_block->i_buffer = 0;
 197     }
 198
 199 buffered:
 200     /* and finally get a block back */
 201     return block_FifoCount( p_sys->p_fifo ) > 0 ? block_FifoGet( p_sys->p_fifo ) : NULL;
 202 }
 203
 204 static block_t *EncodeFrame( encoder_t *p_enc, aout_buffer_t *p_block )
 205 {
 206     block_t *p_pcm_block;
 207     block_t *p_chain = NULL;
 208     unsigned int i_samples = p_block->i_buffer >> 2 /* s16l stereo */;
 209     mtime_t start_date = p_block->i_pts;
 210     start_date -= (mtime_t)i_samples * (mtime_t)1000000 / (mtime_t)p_enc->fmt_out.audio.i_rate;
 211
 212     VLC_UNUSED(p_enc);
 213
 214     do {
 215         p_pcm_block = GetPCM( p_enc, p_block );
 216         if( !p_pcm_block )
 217             break;
 218
 219         p_block = NULL; /* we don't need it anymore */
 220
 221         uint32_t enc_buffer[16384]; /* storage for 65536 Bytes XXX: too much */
 222         struct enc_chunk_hdr *chunk = (void*) enc_buffer;
 223         chunk->enc_data = ENC_CHUNK_SKIP_HDR(chunk->enc_data, chunk);
 224
 225         encode_frame( (char*)p_pcm_block->p_buffer, chunk );
 226         block_Release( p_pcm_block );
 227
 228         block_t *p_mp3_block = block_New( p_enc, chunk->enc_size );
 229         if( !p_mp3_block )
 230             break;
 231
 232         vlc_memcpy( p_mp3_block->p_buffer, chunk->enc_data, chunk->enc_size );
 233
 234         /* date management */
 235         p_mp3_block->i_length = SAMP_PER_FRAME1 * 1000000 /
 236             p_enc->fmt_out.audio.i_rate;
 237
 238         start_date += p_mp3_block->i_length;
 239         p_mp3_block->i_dts = p_mp3_block->i_pts = start_date;
 240
 241         p_mp3_block->i_nb_samples = SAMP_PER_FRAME1;
 242
 243         block_ChainAppend( &p_chain, p_mp3_block );
 244
 245     } while( p_pcm_block );
 246
 247     return p_chain;
 248 }
 249
 250 static void CloseEncoder( vlc_object_t *p_this )
 251 {
 252     encoder_sys_t *p_sys = ((encoder_t*)p_this)->p_sys;
 253
 254     vlc_mutex_lock( &entrant.lock );
 255     entrant.busy = false;
 256     vlc_mutex_unlock( &entrant.lock );
 257
 258     /* TODO: we should send the last PCM block padded with 0
 259      * But we don't know if other blocks will come before it's too late */
 260     if( p_sys->i_buffer )
 261         free( p_sys->p_buffer );
 262
 263     block_FifoRelease( p_sys->p_fifo );
 264     free( p_sys );
 265 }