git.sesse.net Git - vlc/blob - modules/audio_filter/converter/dtstofloat32.c

   1 /*****************************************************************************
   2  * dtstofloat32.c: DTS Coherent Acoustics decoder plugin for VLC.
   3  *   This plugin makes use of libdca to do the actual decoding
   4  *   (http://developers.videolan.org/libdca.html).
   5  *****************************************************************************
   6  * Copyright (C) 2001, 2002libdca the VideoLAN team
   7  * $Id$
   8  *
   9  * Author: Gildas Bazin <gbazin@videolan.org>
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation; either version 2 of the License, or
  14  * (at your option) any later version.
  15  *
  16  * This program is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with this program; if not, write to the Free Software
  23  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  24  *****************************************************************************/
  25
  26 /*****************************************************************************
  27  * Preamble
  28  *****************************************************************************/
  29 #ifdef HAVE_CONFIG_H
  30 # include "config.h"
  31 #endif
  32
  33 #include <vlc_common.h>
  34 #include <vlc_plugin.h>
  35
  36
  37 #include <dca.h>                                       /* libdca header file */
  38
  39 #include <vlc_aout.h>
  40 #include <vlc_block.h>
  41 #include "vlc_filter.h"
  42
  43 /*****************************************************************************
  44  * Local prototypes
  45  *****************************************************************************/
  46 static int  Create    ( vlc_object_t * );
  47 static void Destroy   ( vlc_object_t * );
  48 static void DoWork    ( aout_instance_t *, aout_filter_t *, aout_buffer_t *,
  49                         aout_buffer_t * );
  50
  51 static int  Open      ( vlc_object_t *, filter_sys_t *,
  52                         audio_format_t, audio_format_t );
  53
  54 static int  OpenFilter ( vlc_object_t * );
  55 static void CloseFilter( vlc_object_t * );
  56 static block_t *Convert( filter_t *, block_t * );
  57
  58 /* libdca channel order
  59  * libdca currently only decodes 5.1, even if you have a DTS-ES source. */
  60 static const uint32_t pi_channels_in[] =
  61 { AOUT_CHAN_CENTER, AOUT_CHAN_LEFT, AOUT_CHAN_RIGHT,
  62   AOUT_CHAN_REARCENTER, AOUT_CHAN_REARLEFT, AOUT_CHAN_REARRIGHT,
  63   AOUT_CHAN_LFE,
  64   0 };
  65
  66 /*****************************************************************************
  67  * Local structures
  68  *****************************************************************************/
  69 struct filter_sys_t
  70 {
  71     dca_state_t * p_libdca; /* libdca internal structure */
  72     bool b_dynrng; /* see below */
  73     int i_flags; /* libdca flags, see dtsdec/doc/libdts.txt */
  74     bool b_dontwarn;
  75     int i_nb_channels; /* number of float32 per sample */
  76
  77     int pi_chan_table[AOUT_CHAN_MAX]; /* channel reordering */
  78 };
  79
  80 /*****************************************************************************
  81  * Module descriptor
  82  *****************************************************************************/
  83 #define DYNRNG_TEXT N_("DTS dynamic range compression")
  84 #define DYNRNG_LONGTEXT N_( \
  85     "Dynamic range compression makes the loud sounds softer, and the soft " \
  86     "sounds louder, so you can more easily listen to the stream in a noisy " \
  87     "environment without disturbing anyone. If you disable the dynamic range "\
  88     "compression the playback will be more adapted to a movie theater or a " \
  89     "listening room.")
  90
  91 vlc_module_begin ()
  92     set_category( CAT_INPUT )
  93     set_subcategory( SUBCAT_INPUT_ACODEC )
  94     set_shortname( "DCA" )
  95     set_description( N_("DTS Coherent Acoustics audio decoder") )
  96     add_bool( "dts-dynrng", 1, NULL, DYNRNG_TEXT, DYNRNG_LONGTEXT, false )
  97     set_capability( "audio filter", 100 )
  98     set_callbacks( Create, Destroy )
  99
 100     add_submodule ()
 101     set_description( N_("DTS Coherent Acoustics audio decoder") )
 102     set_capability( "audio filter2", 100 )
 103     set_callbacks( OpenFilter, CloseFilter )
 104 vlc_module_end ()
 105
 106 /*****************************************************************************
 107  * Create:
 108  *****************************************************************************/
 109 static int Create( vlc_object_t *p_this )
 110 {
 111     aout_filter_t *p_filter = (aout_filter_t *)p_this;
 112     filter_sys_t *p_sys;
 113     int i_ret;
 114
 115     if ( p_filter->input.i_format != VLC_CODEC_DTS
 116           || p_filter->output.i_format != VLC_CODEC_FL32 )
 117     {
 118         return -1;
 119     }
 120
 121     if ( p_filter->input.i_rate != p_filter->output.i_rate )
 122     {
 123         return -1;
 124     }
 125
 126     /* Allocate the memory needed to store the module's structure */
 127     p_sys = malloc( sizeof(filter_sys_t) );
 128     p_filter->p_sys = (struct aout_filter_sys_t *)p_sys;
 129     if( p_sys == NULL )
 130         return -1;
 131
 132     i_ret = Open( VLC_OBJECT(p_filter), p_sys,
 133                   p_filter->input, p_filter->output );
 134
 135     p_filter->pf_do_work = DoWork;
 136     p_filter->b_in_place = 0;
 137
 138     return i_ret;
 139 }
 140
 141 /*****************************************************************************
 142  * Open:
 143  *****************************************************************************/
 144 static int Open( vlc_object_t *p_this, filter_sys_t *p_sys,
 145                  audio_format_t input, audio_format_t output )
 146 {
 147     p_sys->b_dynrng = config_GetInt( p_this, "dts-dynrng" );
 148     p_sys->b_dontwarn = 0;
 149
 150     /* We'll do our own downmixing, thanks. */
 151     p_sys->i_nb_channels = aout_FormatNbChannels( &output );
 152     switch ( (output.i_physical_channels & AOUT_CHAN_PHYSMASK)
 153               & ~AOUT_CHAN_LFE )
 154     {
 155     case AOUT_CHAN_CENTER:
 156         if ( (output.i_original_channels & AOUT_CHAN_CENTER)
 157               || (output.i_original_channels
 158                    & (AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT)) )
 159         {
 160             p_sys->i_flags = DCA_MONO;
 161         }
 162         break;
 163
 164     case AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT:
 165         if ( output.i_original_channels & AOUT_CHAN_DOLBYSTEREO )
 166         {
 167             p_sys->i_flags = DCA_DOLBY;
 168         }
 169         else if ( input.i_original_channels == AOUT_CHAN_CENTER )
 170         {
 171             p_sys->i_flags = DCA_MONO;
 172         }
 173         else if ( input.i_original_channels & AOUT_CHAN_DUALMONO )
 174         {
 175             p_sys->i_flags = DCA_CHANNEL;
 176         }
 177         else
 178         {
 179             p_sys->i_flags = DCA_STEREO;
 180         }
 181         break;
 182
 183     case AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER:
 184         p_sys->i_flags = DCA_3F;
 185         break;
 186
 187     case AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_REARCENTER:
 188         p_sys->i_flags = DCA_2F1R;
 189         break;
 190
 191     case AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER
 192           | AOUT_CHAN_REARCENTER:
 193         p_sys->i_flags = DCA_3F1R;
 194         break;
 195
 196     case AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT
 197           | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT:
 198         p_sys->i_flags = DCA_2F2R;
 199         break;
 200
 201     case AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER
 202           | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT:
 203         p_sys->i_flags = DCA_3F2R;
 204         break;
 205
 206     default:
 207         msg_Warn( p_this, "unknown sample format!" );
 208         free( p_sys );
 209         return -1;
 210     }
 211     if ( output.i_physical_channels & AOUT_CHAN_LFE )
 212     {
 213         p_sys->i_flags |= DCA_LFE;
 214     }
 215     //p_sys->i_flags |= DCA_ADJUST_LEVEL;
 216
 217     /* Initialize libdca */
 218     p_sys->p_libdca = dca_init( 0 );
 219     if( p_sys->p_libdca == NULL )
 220     {
 221         msg_Err( p_this, "unable to initialize libdca" );
 222         return VLC_EGENERIC;
 223     }
 224
 225     aout_CheckChannelReorder( pi_channels_in, NULL,
 226                               output.i_physical_channels & AOUT_CHAN_PHYSMASK,
 227                               p_sys->i_nb_channels,
 228                               p_sys->pi_chan_table );
 229
 230     return VLC_SUCCESS;
 231 }
 232
 233 /*****************************************************************************
 234  * Interleave: helper function to interleave channels
 235  *****************************************************************************/
 236 static void Interleave( float * p_out, const float * p_in, int i_nb_channels,
 237                         int *pi_chan_table )
 238 {
 239     /* We do not only have to interleave, but also reorder the channels. */
 240
 241     int i, j;
 242     for ( j = 0; j < i_nb_channels; j++ )
 243     {
 244         for ( i = 0; i < 256; i++ )
 245         {
 246             p_out[i * i_nb_channels + pi_chan_table[j]] = p_in[j * 256 + i];
 247         }
 248     }
 249 }
 250
 251 /*****************************************************************************
 252  * Duplicate: helper function to duplicate a unique channel
 253  *****************************************************************************/
 254 static void Duplicate( float * p_out, const float * p_in )
 255 {
 256     int i;
 257
 258     for ( i = 256; i--; )
 259     {
 260         *p_out++ = *p_in;
 261         *p_out++ = *p_in;
 262         p_in++;
 263     }
 264 }
 265
 266 /*****************************************************************************
 267  * Exchange: helper function to exchange left & right channels
 268  *****************************************************************************/
 269 static void Exchange( float * p_out, const float * p_in )
 270 {
 271     int i;
 272     const float * p_first = p_in + 256;
 273     const float * p_second = p_in;
 274
 275     for ( i = 0; i < 256; i++ )
 276     {
 277         *p_out++ = *p_first++;
 278         *p_out++ = *p_second++;
 279     }
 280 }
 281
 282 /*****************************************************************************
 283  * DoWork: decode a DTS frame.
 284  *****************************************************************************/
 285 static void DoWork( aout_instance_t * p_aout, aout_filter_t * p_filter,
 286                     aout_buffer_t * p_in_buf, aout_buffer_t * p_out_buf )
 287 {
 288     filter_sys_t    *p_sys = (filter_sys_t *)p_filter->p_sys;
 289     sample_t        i_sample_level = 1;
 290     int             i_flags = p_sys->i_flags;
 291     int             i_bytes_per_block = 256 * p_sys->i_nb_channels
 292                       * sizeof(float);
 293     int             i;
 294
 295     /*
 296      * Do the actual decoding now.
 297      */
 298
 299     /* Needs to be called so the decoder knows which type of bitstream it is
 300      * dealing with. */
 301     int i_sample_rate, i_bit_rate, i_frame_length;
 302     if( !dca_syncinfo( p_sys->p_libdca, p_in_buf->p_buffer, &i_flags,
 303                        &i_sample_rate, &i_bit_rate, &i_frame_length ) )
 304     {
 305         msg_Warn( p_aout, "libdca couldn't sync on frame" );
 306         p_out_buf->i_nb_samples = p_out_buf->i_nb_bytes = 0;
 307         return;
 308     }
 309
 310     i_flags = p_sys->i_flags;
 311     dca_frame( p_sys->p_libdca, p_in_buf->p_buffer,
 312                &i_flags, &i_sample_level, 0 );
 313
 314     if ( (i_flags & DCA_CHANNEL_MASK) != (p_sys->i_flags & DCA_CHANNEL_MASK)
 315           && !p_sys->b_dontwarn )
 316     {
 317         msg_Warn( p_aout,
 318                   "libdca couldn't do the requested downmix 0x%x->0x%x",
 319                   p_sys->i_flags  & DCA_CHANNEL_MASK,
 320                   i_flags & DCA_CHANNEL_MASK );
 321
 322         p_sys->b_dontwarn = 1;
 323     }
 324
 325     if( 0)//!p_sys->b_dynrng )
 326     {
 327         dca_dynrng( p_sys->p_libdca, NULL, NULL );
 328     }
 329
 330     for ( i = 0; i < dca_blocks_num(p_sys->p_libdca); i++ )
 331     {
 332         sample_t * p_samples;
 333
 334         if( dca_block( p_sys->p_libdca ) )
 335         {
 336             msg_Warn( p_aout, "dca_block failed for block %d", i );
 337             break;
 338         }
 339
 340         p_samples = dca_samples( p_sys->p_libdca );
 341
 342         if ( (p_sys->i_flags & DCA_CHANNEL_MASK) == DCA_MONO
 343               && (p_filter->output.i_physical_channels
 344                    & (AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT)) )
 345         {
 346             Duplicate( (float *)(p_out_buf->p_buffer + i * i_bytes_per_block),
 347                        p_samples );
 348         }
 349         else if ( p_filter->output.i_original_channels
 350                     & AOUT_CHAN_REVERSESTEREO )
 351         {
 352             Exchange( (float *)(p_out_buf->p_buffer + i * i_bytes_per_block),
 353                       p_samples );
 354         }
 355         else
 356         {
 357             /* Interleave the *$£%ù samples. */
 358             Interleave( (float *)(p_out_buf->p_buffer + i * i_bytes_per_block),
 359                         p_samples, p_sys->i_nb_channels, p_sys->pi_chan_table);
 360         }
 361     }
 362
 363     p_out_buf->i_nb_samples = p_in_buf->i_nb_samples;
 364     p_out_buf->i_nb_bytes = i_bytes_per_block * i;
 365 }
 366
 367 /*****************************************************************************
 368  * Destroy : deallocate data structures
 369  *****************************************************************************/
 370 static void Destroy( vlc_object_t *p_this )
 371 {
 372     aout_filter_t *p_filter = (aout_filter_t *)p_this;
 373     filter_sys_t *p_sys = (filter_sys_t *)p_filter->p_sys;
 374
 375     dca_free( p_sys->p_libdca );
 376     free( p_sys );
 377 }
 378
 379 /*****************************************************************************
 380  * OpenFilter:
 381  *****************************************************************************/
 382 static int OpenFilter( vlc_object_t *p_this )
 383 {
 384     filter_t *p_filter = (filter_t *)p_this;
 385     filter_sys_t *p_sys;
 386     int i_ret;
 387
 388     if( p_filter->fmt_in.i_codec != VLC_CODEC_DTS  )
 389     {
 390         return VLC_EGENERIC;
 391     }
 392
 393     p_filter->fmt_out.audio.i_format =
 394         p_filter->fmt_out.i_codec = VLC_CODEC_FL32;
 395     p_filter->fmt_out.audio.i_bitspersample =
 396         aout_BitsPerSample( p_filter->fmt_out.i_codec );
 397
 398     /* Allocate the memory needed to store the module's structure */
 399     p_sys = p_filter->p_sys = malloc( sizeof(filter_sys_t) );
 400     if( p_sys == NULL )
 401         return VLC_ENOMEM;
 402
 403     i_ret = Open( VLC_OBJECT(p_filter), p_sys,
 404                   p_filter->fmt_in.audio, p_filter->fmt_out.audio );
 405
 406     p_filter->pf_audio_filter = Convert;
 407     p_filter->fmt_out.audio.i_rate = p_filter->fmt_in.audio.i_rate;
 408
 409     return i_ret;
 410 }
 411
 412 /*****************************************************************************
 413  * CloseFilter : deallocate data structures
 414  *****************************************************************************/
 415 static void CloseFilter( vlc_object_t *p_this )
 416 {
 417     filter_t *p_filter = (filter_t *)p_this;
 418     filter_sys_t *p_sys = p_filter->p_sys;
 419
 420     dca_free( p_sys->p_libdca );
 421     free( p_sys );
 422 }
 423
 424 static block_t *Convert( filter_t *p_filter, block_t *p_block )
 425 {
 426     aout_filter_t aout_filter;
 427     aout_buffer_t in_buf, out_buf;
 428     block_t *p_out;
 429     int i_out_size;
 430
 431     if( !p_block || !p_block->i_samples )
 432     {
 433         if( p_block )
 434             block_Release( p_block );
 435         return NULL;
 436     }
 437
 438     i_out_size = p_block->i_samples *
 439       p_filter->fmt_out.audio.i_bitspersample *
 440         p_filter->fmt_out.audio.i_channels / 8;
 441
 442     p_out = p_filter->pf_audio_buffer_new( p_filter, i_out_size );
 443     if( !p_out )
 444     {
 445         msg_Warn( p_filter, "can't get output buffer" );
 446         block_Release( p_block );
 447         return NULL;
 448     }
 449
 450     p_out->i_samples = p_block->i_samples;
 451     p_out->i_dts = p_block->i_dts;
 452     p_out->i_pts = p_block->i_pts;
 453     p_out->i_length = p_block->i_length;
 454
 455     aout_filter.p_sys = (struct aout_filter_sys_t *)p_filter->p_sys;
 456     aout_filter.input = p_filter->fmt_in.audio;
 457     aout_filter.input.i_format = p_filter->fmt_in.i_codec;
 458     aout_filter.output = p_filter->fmt_out.audio;
 459     aout_filter.output.i_format = p_filter->fmt_out.i_codec;
 460
 461     in_buf.p_buffer = p_block->p_buffer;
 462     in_buf.i_nb_bytes = p_block->i_buffer;
 463     in_buf.i_nb_samples = p_block->i_samples;
 464     out_buf.p_buffer = p_out->p_buffer;
 465     out_buf.i_nb_bytes = p_out->i_buffer;
 466     out_buf.i_nb_samples = p_out->i_samples;
 467
 468     DoWork( (aout_instance_t *)p_filter, &aout_filter, &in_buf, &out_buf );
 469
 470     p_out->i_buffer = out_buf.i_nb_bytes;
 471     p_out->i_samples = out_buf.i_nb_samples;
 472
 473     block_Release( p_block );
 474
 475     return p_out;
 476 }