X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=modules%2Faudio_filter%2Fconverter%2Fdtstofloat32.c;h=56f08a298ce7e1c0c4076bd0981950ba2f7e241d;hb=6ee1e193fd896ab9a4729fde14f009d9ce629815;hp=d42d60c9a9e0bf04d774cd933272e5da07e706c6;hpb=a4b486148b57b3bc15c165e1cebea1ee0e444284;p=vlc diff --git a/modules/audio_filter/converter/dtstofloat32.c b/modules/audio_filter/converter/dtstofloat32.c index d42d60c9a9..56f08a298c 100644 --- a/modules/audio_filter/converter/dtstofloat32.c +++ b/modules/audio_filter/converter/dtstofloat32.c @@ -1,18 +1,18 @@ /***************************************************************************** * dtstofloat32.c: DTS Coherent Acoustics decoder plugin for VLC. - * This plugin makes use of libdts to do the actual decoding - * (http://www.videolan.org/dtsdec/). + * This plugin makes use of libdca to do the actual decoding + * (http://developers.videolan.org/libdca.html). ***************************************************************************** - * Copyright (C) 2001, 2002 VideoLAN - * $Id: dtstofloat32.c,v 1.1 2004/02/05 22:56:12 gbazin Exp $ + * Copyright (C) 2001, 2002libdca the VideoLAN team + * $Id$ + * + * Author: Gildas Bazin * - * Author: Gildas Bazin - * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. - * + * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the @@ -20,7 +20,7 @@ * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA. + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA. *****************************************************************************/ /***************************************************************************** @@ -28,36 +28,49 @@ *****************************************************************************/ #include -#include /* malloc(), free() */ -#include /* strdup() */ -#ifdef USE_DTSDEC_TREE /* libdts header file */ -# include "include/dts.h" -#else -# include "dtsdec/dts.h" -#endif +#include /* libdca header file */ -#include "audio_output.h" -#include "aout_internal.h" +#include +#include +#include "vlc_filter.h" /***************************************************************************** * Local prototypes *****************************************************************************/ static int Create ( vlc_object_t * ); static void Destroy ( vlc_object_t * ); -static void DoWork ( aout_instance_t *, aout_filter_t *, aout_buffer_t *, +static void DoWork ( aout_instance_t *, aout_filter_t *, aout_buffer_t *, aout_buffer_t * ); +static int Open ( vlc_object_t *, filter_sys_t *, + audio_format_t, audio_format_t ); + +static int OpenFilter ( vlc_object_t * ); +static void CloseFilter( vlc_object_t * ); +static block_t *Convert( filter_t *, block_t * ); + +/* libdca channel order */ +static const uint32_t pi_channels_in[] = +{ AOUT_CHAN_CENTER, AOUT_CHAN_LEFT, AOUT_CHAN_RIGHT, + AOUT_CHAN_REARLEFT, AOUT_CHAN_REARRIGHT, AOUT_CHAN_LFE, 0 }; +/* our internal channel order (WG-4 order) */ +static const uint32_t pi_channels_out[] = +{ AOUT_CHAN_LEFT, AOUT_CHAN_RIGHT, AOUT_CHAN_REARLEFT, AOUT_CHAN_REARRIGHT, + AOUT_CHAN_CENTER, AOUT_CHAN_LFE, 0 }; + /***************************************************************************** * Local structures *****************************************************************************/ -struct aout_filter_sys_t +struct filter_sys_t { - dts_state_t * p_libdts; /* libdts internal structure */ + dca_state_t * p_libdca; /* libdca internal structure */ vlc_bool_t b_dynrng; /* see below */ - int i_flags; /* libdts flags, see dtsdec/doc/libdts.txt */ + int i_flags; /* libdca flags, see dtsdec/doc/libdts.txt */ vlc_bool_t b_dontwarn; int i_nb_channels; /* number of float32 per sample */ + + int pi_chan_table[AOUT_CHAN_MAX]; /* channel reordering */ }; /***************************************************************************** @@ -72,19 +85,28 @@ struct aout_filter_sys_t "listening room.") vlc_module_begin(); + set_category( CAT_INPUT ); + set_subcategory( SUBCAT_INPUT_ACODEC ); + set_shortname( "DCA" ); set_description( _("DTS Coherent Acoustics audio decoder") ); add_bool( "dts-dynrng", 1, NULL, DYNRNG_TEXT, DYNRNG_LONGTEXT, VLC_FALSE ); set_capability( "audio filter", 100 ); set_callbacks( Create, Destroy ); + + add_submodule(); + set_description( _("DTS Coherent Acoustics audio decoder") ); + set_capability( "audio filter2", 100 ); + set_callbacks( OpenFilter, CloseFilter ); vlc_module_end(); /***************************************************************************** - * Create: + * Create: *****************************************************************************/ -static int Create( vlc_object_t * _p_filter ) +static int Create( vlc_object_t *p_this ) { - aout_filter_t * p_filter = (aout_filter_t *)_p_filter; - struct aout_filter_sys_t * p_sys; + aout_filter_t *p_filter = (aout_filter_t *)p_this; + filter_sys_t *p_sys; + int i_ret; if ( p_filter->input.i_format != VLC_FOURCC('d','t','s',' ') || p_filter->output.i_format != VLC_FOURCC('f','l','3','2') ) @@ -98,140 +120,129 @@ static int Create( vlc_object_t * _p_filter ) } /* Allocate the memory needed to store the module's structure */ - p_sys = p_filter->p_sys = malloc( sizeof(struct aout_filter_sys_t) ); + p_sys = malloc( sizeof(filter_sys_t) ); + p_filter->p_sys = (struct aout_filter_sys_t *)p_sys; if( p_sys == NULL ) { msg_Err( p_filter, "out of memory" ); return -1; } - p_sys->b_dynrng = config_GetInt( p_filter, "dts-dynrng" ); + i_ret = Open( VLC_OBJECT(p_filter), p_sys, + p_filter->input, p_filter->output ); + + p_filter->pf_do_work = DoWork; + p_filter->b_in_place = 0; + + return i_ret; +} + +/***************************************************************************** + * Open: + *****************************************************************************/ +static int Open( vlc_object_t *p_this, filter_sys_t *p_sys, + audio_format_t input, audio_format_t output ) +{ + p_sys->b_dynrng = config_GetInt( p_this, "dts-dynrng" ); p_sys->b_dontwarn = 0; /* We'll do our own downmixing, thanks. */ - p_sys->i_nb_channels = aout_FormatNbChannels( &p_filter->output ); - switch ( (p_filter->output.i_physical_channels & AOUT_CHAN_PHYSMASK) + p_sys->i_nb_channels = aout_FormatNbChannels( &output ); + switch ( (output.i_physical_channels & AOUT_CHAN_PHYSMASK) & ~AOUT_CHAN_LFE ) { case AOUT_CHAN_CENTER: - if ( (p_filter->output.i_original_channels & AOUT_CHAN_CENTER) - || (p_filter->output.i_original_channels + if ( (output.i_original_channels & AOUT_CHAN_CENTER) + || (output.i_original_channels & (AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT)) ) { - p_sys->i_flags = DTS_MONO; + p_sys->i_flags = DCA_MONO; } break; case AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT: - if ( p_filter->output.i_original_channels & AOUT_CHAN_DOLBYSTEREO ) + if ( output.i_original_channels & AOUT_CHAN_DOLBYSTEREO ) { - p_sys->i_flags = DTS_DOLBY; + p_sys->i_flags = DCA_DOLBY; } - else if ( p_filter->input.i_original_channels == AOUT_CHAN_CENTER ) + else if ( input.i_original_channels == AOUT_CHAN_CENTER ) { - p_sys->i_flags = DTS_MONO; + p_sys->i_flags = DCA_MONO; } - else if ( p_filter->input.i_original_channels & AOUT_CHAN_DUALMONO ) + else if ( input.i_original_channels & AOUT_CHAN_DUALMONO ) { - p_sys->i_flags = DTS_CHANNEL; + p_sys->i_flags = DCA_CHANNEL; } else { - p_sys->i_flags = DTS_STEREO; + p_sys->i_flags = DCA_STEREO; } break; case AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER: - p_sys->i_flags = DTS_3F; + p_sys->i_flags = DCA_3F; break; case AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_REARCENTER: - p_sys->i_flags = DTS_2F1R; + p_sys->i_flags = DCA_2F1R; break; case AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER | AOUT_CHAN_REARCENTER: - p_sys->i_flags = DTS_3F1R; + p_sys->i_flags = DCA_3F1R; break; case AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT: - p_sys->i_flags = DTS_2F2R; + p_sys->i_flags = DCA_2F2R; break; case AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT: - p_sys->i_flags = DTS_3F2R; + p_sys->i_flags = DCA_3F2R; break; default: - msg_Warn( p_filter, "unknown sample format!" ); + msg_Warn( p_this, "unknown sample format!" ); free( p_sys ); return -1; } - if ( p_filter->output.i_physical_channels & AOUT_CHAN_LFE ) + if ( output.i_physical_channels & AOUT_CHAN_LFE ) { - p_sys->i_flags |= DTS_LFE; + p_sys->i_flags |= DCA_LFE; } - //p_sys->i_flags |= DTS_ADJUST_LEVEL; + //p_sys->i_flags |= DCA_ADJUST_LEVEL; - /* Initialize libdts */ - p_sys->p_libdts = dts_init( 0 ); - if( p_sys->p_libdts == NULL ) + /* Initialize libdca */ + p_sys->p_libdca = dca_init( 0 ); + if( p_sys->p_libdca == NULL ) { - msg_Err( p_filter, "unable to initialize libdts" ); - return -1; + msg_Err( p_this, "unable to initialize libdca" ); + return VLC_EGENERIC; } - p_filter->pf_do_work = DoWork; - p_filter->b_in_place = 0; + aout_CheckChannelReorder( pi_channels_in, pi_channels_out, + output.i_physical_channels & AOUT_CHAN_PHYSMASK, + p_sys->i_nb_channels, + p_sys->pi_chan_table ); - return 0; + return VLC_SUCCESS; } /***************************************************************************** * Interleave: helper function to interleave channels *****************************************************************************/ -static void Interleave( float * p_out, const float * p_in, int i_nb_channels ) +static void Interleave( float * p_out, const float * p_in, int i_nb_channels, + int *pi_chan_table ) { - /* We do not only have to interleave, but also reorder the channels - * Channel reordering according to number of output channels of libdts - * The reordering needs to be different for different channel configurations - * (3F2R, 1F2R etc), so this is only temporary. - * The WG-4 order is appropriate for stereo, quadrophonia, and 5.1 surround. - * - * 6 channel mode - * channel libdts order WG-4 order - * 0 C // L - * 1 L // R - * 2 R // LS - * 3 LS // RS - * 4 RS // C - * 5 LFE // LFE - * - * The libdts moves channels to the front if there are unused spaces, so - * there is no gap between channels. The translation table says which - * channel of the new stream is taken from which original channel [use - * the new channel as the array index, use the number you get from the - * array to address the original channel]. - */ - - static const int translation[7][6] = - {{ 0, 0, 0, 0, 0, 0 }, /* 0 channels (rarely used) */ - { 0, 0, 0, 0, 0, 0 }, /* 1 ch */ - { 0, 1, 0, 0, 0, 0 }, /* 2 */ - { 1, 2, 0, 0, 0, 0 }, /* 3 */ - { 0, 1, 2, 3, 0, 0 }, /* 4 */ - { 1, 2, 3, 4, 0, 0 }, /* 5 */ - { 1, 2, 3, 4, 0, 5 }}; /* 6 */ + /* We do not only have to interleave, but also reorder the channels. */ int i, j; for ( j = 0; j < i_nb_channels; j++ ) { for ( i = 0; i < 256; i++ ) { - p_out[i * i_nb_channels + j] = p_in[translation[i_nb_channels][j] - * 256 + i]; + p_out[i * i_nb_channels + pi_chan_table[j]] = p_in[j * 256 + i]; } } } @@ -273,7 +284,7 @@ static void Exchange( float * p_out, const float * p_in ) static void DoWork( aout_instance_t * p_aout, aout_filter_t * p_filter, aout_buffer_t * p_in_buf, aout_buffer_t * p_out_buf ) { - struct aout_filter_sys_t * p_sys = p_filter->p_sys; + filter_sys_t *p_sys = (filter_sys_t *)p_filter->p_sys; sample_t i_sample_level = 1; int i_flags = p_sys->i_flags; int i_bytes_per_block = 256 * p_sys->i_nb_channels @@ -287,48 +298,48 @@ static void DoWork( aout_instance_t * p_aout, aout_filter_t * p_filter, /* Needs to be called so the decoder knows which type of bitstream it is * dealing with. */ int i_sample_rate, i_bit_rate, i_frame_length; - if( !dts_syncinfo( p_sys->p_libdts, p_in_buf->p_buffer, &i_flags, + if( !dca_syncinfo( p_sys->p_libdca, p_in_buf->p_buffer, &i_flags, &i_sample_rate, &i_bit_rate, &i_frame_length ) ) { - msg_Warn( p_filter, "libdts couldn't sync on frame" ); + msg_Warn( p_aout, "libdca couldn't sync on frame" ); p_out_buf->i_nb_samples = p_out_buf->i_nb_bytes = 0; return; } i_flags = p_sys->i_flags; - dts_frame( p_sys->p_libdts, p_in_buf->p_buffer, + dca_frame( p_sys->p_libdca, p_in_buf->p_buffer, &i_flags, &i_sample_level, 0 ); - if ( (i_flags & DTS_CHANNEL_MASK) != (p_sys->i_flags & DTS_CHANNEL_MASK) + if ( (i_flags & DCA_CHANNEL_MASK) != (p_sys->i_flags & DCA_CHANNEL_MASK) && !p_sys->b_dontwarn ) { - msg_Warn( p_filter, - "libdts couldn't do the requested downmix 0x%x->0x%x", - p_sys->i_flags & DTS_CHANNEL_MASK, - i_flags & DTS_CHANNEL_MASK ); + msg_Warn( p_aout, + "libdca couldn't do the requested downmix 0x%x->0x%x", + p_sys->i_flags & DCA_CHANNEL_MASK, + i_flags & DCA_CHANNEL_MASK ); p_sys->b_dontwarn = 1; } if( 0)//!p_sys->b_dynrng ) { - dts_dynrng( p_filter->p_sys->p_libdts, NULL, NULL ); + dca_dynrng( p_sys->p_libdca, NULL, NULL ); } - for ( i = 0; i < dts_blocks_num(p_filter->p_sys->p_libdts); i++ ) + for ( i = 0; i < dca_blocks_num(p_sys->p_libdca); i++ ) { sample_t * p_samples; - if( dts_block( p_sys->p_libdts ) ) + if( dca_block( p_sys->p_libdca ) ) { - msg_Warn( p_filter, "dts_block failed for block %d", i ); + msg_Warn( p_aout, "dca_block failed for block %d", i ); break; } - p_samples = dts_samples( p_sys->p_libdts ); + p_samples = dca_samples( p_sys->p_libdca ); - if ( (p_sys->i_flags & DTS_CHANNEL_MASK) == DTS_MONO - && (p_filter->output.i_physical_channels + if ( (p_sys->i_flags & DCA_CHANNEL_MASK) == DCA_MONO + && (p_filter->output.i_physical_channels & (AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT)) ) { Duplicate( (float *)(p_out_buf->p_buffer + i * i_bytes_per_block), @@ -342,9 +353,9 @@ static void DoWork( aout_instance_t * p_aout, aout_filter_t * p_filter, } else { - /* Interleave the *$£%ù samples. */ + /* Interleave the *$£%ù samples. */ Interleave( (float *)(p_out_buf->p_buffer + i * i_bytes_per_block), - p_samples, p_sys->i_nb_channels ); + p_samples, p_sys->i_nb_channels, p_sys->pi_chan_table); } } @@ -355,11 +366,118 @@ static void DoWork( aout_instance_t * p_aout, aout_filter_t * p_filter, /***************************************************************************** * Destroy : deallocate data structures *****************************************************************************/ -static void Destroy( vlc_object_t * _p_filter ) +static void Destroy( vlc_object_t *p_this ) +{ + aout_filter_t *p_filter = (aout_filter_t *)p_this; + filter_sys_t *p_sys = (filter_sys_t *)p_filter->p_sys; + + dca_free( p_sys->p_libdca ); + free( p_sys ); +} + +/***************************************************************************** + * OpenFilter: + *****************************************************************************/ +static int OpenFilter( vlc_object_t *p_this ) +{ + filter_t *p_filter = (filter_t *)p_this; + filter_sys_t *p_sys; + int i_ret; + + if( p_filter->fmt_in.i_codec != VLC_FOURCC('d','t','s',' ') ) + { + return VLC_EGENERIC; + } + + p_filter->fmt_out.audio.i_format = + p_filter->fmt_out.i_codec = VLC_FOURCC('f','l','3','2'); + + /* Allocate the memory needed to store the module's structure */ + p_sys = p_filter->p_sys = malloc( sizeof(filter_sys_t) ); + if( p_sys == NULL ) + { + msg_Err( p_filter, "out of memory" ); + return VLC_EGENERIC; + } + + /* Allocate the memory needed to store the module's structure */ + p_filter->p_sys = p_sys = malloc( sizeof(filter_sys_t) ); + if( p_sys == NULL ) + { + msg_Err( p_filter, "out of memory" ); + return VLC_EGENERIC; + } + + i_ret = Open( VLC_OBJECT(p_filter), p_sys, + p_filter->fmt_in.audio, p_filter->fmt_out.audio ); + + p_filter->pf_audio_filter = Convert; + p_filter->fmt_out.audio.i_rate = p_filter->fmt_in.audio.i_rate; + + return i_ret; +} + +/***************************************************************************** + * CloseFilter : deallocate data structures + *****************************************************************************/ +static void CloseFilter( vlc_object_t *p_this ) { - aout_filter_t * p_filter = (aout_filter_t *)_p_filter; - struct aout_filter_sys_t * p_sys = p_filter->p_sys; + filter_t *p_filter = (filter_t *)p_this; + filter_sys_t *p_sys = p_filter->p_sys; - dts_free( p_sys->p_libdts ); + dca_free( p_sys->p_libdca ); free( p_sys ); } + +static block_t *Convert( filter_t *p_filter, block_t *p_block ) +{ + aout_filter_t aout_filter; + aout_buffer_t in_buf, out_buf; + block_t *p_out; + int i_out_size; + + if( !p_block || !p_block->i_samples ) + { + if( p_block ) p_block->pf_release( p_block ); + return NULL; + } + + i_out_size = p_block->i_samples * + p_filter->fmt_out.audio.i_bitspersample * + p_filter->fmt_out.audio.i_channels / 8; + + p_out = p_filter->pf_audio_buffer_new( p_filter, i_out_size ); + if( !p_out ) + { + msg_Warn( p_filter, "can't get output buffer" ); + p_block->pf_release( p_block ); + return NULL; + } + + p_out->i_samples = p_block->i_samples; + p_out->i_dts = p_block->i_dts; + p_out->i_pts = p_block->i_pts; + p_out->i_length = p_block->i_length; + + aout_filter.p_sys = (struct aout_filter_sys_t *)p_filter->p_sys; + aout_filter.input = p_filter->fmt_in.audio; + aout_filter.input.i_format = p_filter->fmt_in.i_codec; + aout_filter.output = p_filter->fmt_out.audio; + aout_filter.output.i_format = p_filter->fmt_out.i_codec; + + in_buf.p_buffer = p_block->p_buffer; + in_buf.i_nb_bytes = p_block->i_buffer; + in_buf.i_nb_samples = p_block->i_samples; + out_buf.p_buffer = p_out->p_buffer; + out_buf.i_nb_bytes = p_out->i_buffer; + out_buf.i_nb_samples = p_out->i_samples; + + DoWork( (aout_instance_t *)p_filter, &aout_filter, &in_buf, &out_buf ); + + p_out->i_buffer = out_buf.i_nb_bytes; + p_out->i_samples = out_buf.i_nb_samples; + + p_block->pf_release( p_block ); + + return p_out; +}