git.sesse.net Git - vlc/blob - modules/audio_mixer/trivial.c

   1 /*****************************************************************************
   2  * trivial.c : trivial mixer plug-in (1 input, no downmixing)
   3  *****************************************************************************
   4  * Copyright (C) 2002 VideoLAN
   5  * $Id: trivial.c,v 1.3 2002/08/11 22:36:35 massiot Exp $
   6  *
   7  * Authors: Christophe Massiot <massiot@via.ecp.fr>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  22  *****************************************************************************/
  23
  24 /*****************************************************************************
  25  * Preamble
  26  *****************************************************************************/
  27 #include <errno.h>
  28 #include <stdlib.h>                                      /* malloc(), free() */
  29 #include <string.h>
  30
  31 #include <vlc/vlc.h>
  32 #include "audio_output.h"
  33 #include "aout_internal.h"
  34
  35 /*****************************************************************************
  36  * Local prototypes
  37  *****************************************************************************/
  38 static int  Create    ( vlc_object_t * );
  39
  40 static void DoWork    ( aout_instance_t *, aout_buffer_t * );
  41
  42 /*****************************************************************************
  43  * Module descriptor
  44  *****************************************************************************/
  45 vlc_module_begin();
  46     set_description( _("trivial aout mixer module") );
  47     set_capability( "audio mixer", 1 );
  48     add_shortcut( "trivial" );
  49     set_callbacks( Create, NULL );
  50 vlc_module_end();
  51
  52 /*****************************************************************************
  53  * Create: allocate trivial mixer
  54  *****************************************************************************/
  55 static int Create( vlc_object_t *p_this )
  56 {
  57     aout_instance_t * p_aout = (aout_instance_t *)p_this;
  58
  59     if ( p_aout->mixer.output.i_format != AOUT_FMT_FLOAT32
  60           && p_aout->mixer.output.i_format != AOUT_FMT_FIXED32 )
  61     {
  62         return -1;
  63     }
  64
  65     p_aout->mixer.pf_do_work = DoWork;
  66
  67     return 0;
  68 }
  69
  70 /*****************************************************************************
  71  * SparseCopy: trivially downmix or upmix a buffer
  72  *****************************************************************************/
  73 static void SparseCopy( u32 * p_dest, const u32 * p_src, size_t i_len,
  74                         int i_output_stride, int i_input_stride )
  75 {
  76     int i;
  77     for ( i = 0; i < i_len; i++ )
  78     {
  79         int j;
  80         for ( j = 0; j < i_output_stride; j++ )
  81         {
  82             p_dest[j] = p_src[j];
  83         }
  84         p_src += i_input_stride;
  85         p_dest += i_output_stride;
  86     }
  87 }
  88
  89 /*****************************************************************************
  90  * DoWork: mix a new output buffer
  91  *****************************************************************************/
  92 static void DoWork( aout_instance_t * p_aout, aout_buffer_t * p_buffer )
  93 {
  94     aout_input_t * p_input = p_aout->pp_inputs[0];
  95
  96     if ( p_input->input.i_channels == p_aout->mixer.output.i_channels )
  97     {
  98         int i_nb_bytes = p_buffer->i_nb_samples * sizeof(u32)
  99                           * p_input->input.i_channels;
 100         byte_t * p_in = (p_input->p_first_byte_to_mix == NULL) ?
 101                         p_input->fifo.p_first->p_buffer :
 102                         p_input->p_first_byte_to_mix;
 103         byte_t * p_out = p_buffer->p_buffer;
 104
 105         for ( ; ; )
 106         {
 107             ptrdiff_t i_available_bytes = (p_input->fifo.p_first->p_buffer
 108                                            - p_in)
 109                                            + p_input->fifo.p_first->i_nb_samples
 110                                               * sizeof(u32)
 111                                               * p_input->input.i_channels;
 112
 113             if ( i_available_bytes < i_nb_bytes )
 114             {
 115                 aout_buffer_t * p_old_buffer;
 116
 117                 if ( i_available_bytes > 0 )
 118                     p_aout->p_vlc->pf_memcpy( p_out, p_in, i_available_bytes );
 119                 i_nb_bytes -= i_available_bytes;
 120                 p_out += i_available_bytes;
 121
 122                 /* Next buffer */
 123                 p_old_buffer = aout_FifoPop( p_aout, &p_input->fifo );
 124                 aout_BufferFree( p_old_buffer );
 125                 if ( p_input->fifo.p_first == NULL )
 126                 {
 127                     msg_Err( p_aout, "internal amix error" );
 128                     return;
 129                 }
 130                 p_in = p_input->fifo.p_first->p_buffer;
 131             }
 132             else
 133             {
 134                 p_aout->p_vlc->pf_memcpy( p_out, p_in, i_nb_bytes );
 135                 p_input->p_first_byte_to_mix = p_in + i_nb_bytes;
 136                 break;
 137             }
 138         }
 139     }
 140     else
 141     {
 142         /* Downmixing or upmixing. */
 143         int i_nb_samples = p_buffer->i_nb_samples;
 144         u32 * p_in = (p_input->p_first_byte_to_mix == NULL) ?
 145                      (u32 *)p_input->fifo.p_first->p_buffer :
 146                      (u32 *)p_input->p_first_byte_to_mix;
 147         u32 * p_out = (u32 *)p_buffer->p_buffer;
 148
 149
 150         if ( p_input->input.i_channels < p_aout->mixer.output.i_channels )
 151         {
 152             /* Zero out the destination buffer, to avoid static on unavailable
 153              * channels. */
 154             memset( p_buffer->p_buffer, 0,
 155                     p_buffer->i_nb_samples * sizeof(u32)
 156                      * p_aout->mixer.output.i_channels );
 157         }
 158
 159         for ( ; ; )
 160         {
 161             ptrdiff_t i_available_bytes = (p_input->fifo.p_first->p_buffer
 162                                            - (byte_t *)p_in)
 163                                            + p_input->fifo.p_first->i_nb_samples
 164                                               * sizeof(u32)
 165                                               * p_input->input.i_channels;
 166             int i_available_samples = i_available_bytes
 167                                        / p_input->input.i_channels
 168                                        / sizeof(u32);
 169
 170             if ( i_available_samples < i_nb_samples )
 171             {
 172                 aout_buffer_t * p_old_buffer;
 173
 174                 if ( i_available_samples > 0 )
 175                     SparseCopy( p_out, p_in, i_available_samples,
 176                                 p_aout->mixer.output.i_channels,
 177                                 p_input->input.i_channels );
 178                 i_nb_samples -= i_available_samples;
 179                 p_out += i_available_samples * p_aout->mixer.output.i_channels;
 180
 181                 /* Next buffer */
 182                 p_old_buffer = aout_FifoPop( p_aout, &p_input->fifo );
 183                 aout_BufferFree( p_old_buffer );
 184                 if ( p_input->fifo.p_first == NULL )
 185                 {
 186                     msg_Err( p_aout, "internal amix error" );
 187                     return;
 188                 }
 189                 p_in = (u32 *)p_input->fifo.p_first->p_buffer;
 190             }
 191             else
 192             {
 193                 SparseCopy( p_out, p_in, i_nb_samples,
 194                             p_aout->mixer.output.i_channels,
 195                             p_input->input.i_channels );
 196                 p_input->p_first_byte_to_mix = (byte_t *)p_in
 197                                + i_nb_samples * p_input->input.i_channels
 198                                   * sizeof(u32);
 199                 break;
 200             }
 201         }
 202     }
 203 }
 204