Navigation

← Previous Changeset
Next Changeset →

Changeset 00906ea88ec8bb008008fdfe6ce029249d3fd8bf

Timestamp:

01/03/05 17:26:21 (4 years ago)

Author:

Gildas Bazin <gbazin@videolan.org>

git-committer:

Gildas Bazin <gbazin@videolan.org> 1109694381 +0000

git-parent:

[3c53e7b2030b2acbc072426d0ee7ab7b17822f0e]

git-author:

Gildas Bazin <gbazin@videolan.org> 1109694381 +0000

Message:

* modules/codec/lpcm.c: support for 20/24 bits LPCM.
* modules/audio_filter/converter/s16tofloat32*, modules/audio_filter/format.c: s24l/s24b conversion routines.

Files:

include/audio_output.h (modified) (2 diffs)
modules/audio_filter/converter/s16tofloat32.c (modified) (5 diffs)
modules/audio_filter/converter/s16tofloat32swab.c (modified) (4 diffs)
modules/audio_filter/format.c (modified) (23 diffs)
modules/codec/lpcm.c (modified) (7 diffs)
src/audio_output/common.c (modified) (2 diffs)

Legend:

: Unmodified
: Added
: Removed
: Modified
: Copied
: Moved

include/audio_output.h

r17f16d7	r00906ea
2	2	* audio_output.h : audio output interface
3	3	*****************************************************************************
4		* Copyright (C) 2002 VideoLAN
	4	* Copyright (C) 2002-2005 VideoLAN
5	5	* $Id$
6	6	*
…	…
41	41	# define AOUT_FMT_S16_NE VLC_FOURCC('s','1','6','b')
42	42	# define AOUT_FMT_U16_NE VLC_FOURCC('u','1','6','b')
	43	# define AOUT_FMT_S24_NE VLC_FOURCC('s','2','4','b')
43	44	#else
44	45	# define AOUT_FMT_S16_NE VLC_FOURCC('s','1','6','l')
45	46	# define AOUT_FMT_U16_NE VLC_FOURCC('u','1','6','l')
	47	# define AOUT_FMT_S24_NE VLC_FOURCC('s','2','4','l')
46	48	#endif
47	49

modules/audio_filter/converter/s16tofloat32.c

ra90a19a	r00906ea
2	2	* s16tofloat32.c : converter from signed 16 bits integer to float32
3	3	*****************************************************************************
4		* Copyright (C) 2002 VideoLAN
	4	* Copyright (C) 2002-2005 VideoLAN
5	5	* $Id$
6	6	*
…	…
39	39	static void DoWork ( aout_instance_t , aout_filter_t , aout_buffer_t *,
40	40	aout_buffer_t * );
	41	static void DoWork24 ( aout_instance_t , aout_filter_t , aout_buffer_t *,
	42	aout_buffer_t * );
41	43
42	44	/*****************************************************************************
…	…
60	62	aout_filter_t * p_filter = (aout_filter_t *)p_this;
61	63
62		if ( p_filter->input.i_format != AOUT_FMT_S16_NE
	64	if ( ( p_filter->input.i_format != AOUT_FMT_S16_NE &&
	65	p_filter->input.i_format != AOUT_FMT_S24_NE )
63	66	\|\| p_filter->output.i_format != VLC_FOURCC('f','l','3','2') )
64	67	{
…	…
71	74	}
72	75
73		p_filter->pf_do_work = DoWork;
	76	if( p_filter->input.i_format == AOUT_FMT_S24_NE )
	77	p_filter->pf_do_work = DoWork24;
	78	else
	79	p_filter->pf_do_work = DoWork;
	80
74	81	p_filter->b_in_place = VLC_TRUE;
75	82
…	…
110	117	}
111	118
	119	static void DoWork24( aout_instance_t * p_aout, aout_filter_t * p_filter,
	120	aout_buffer_t * p_in_buf, aout_buffer_t * p_out_buf )
	121	{
	122	int i = p_in_buf->i_nb_samples * aout_FormatNbChannels( &p_filter->input );
	123
	124	/* We start from the end because b_in_place is true */
	125	uint8_t * p_in = (uint8_t )p_in_buf->p_buffer + (i - 1) 3;
	126	float * p_out = (float *)p_out_buf->p_buffer + i - 1;
	127
	128	while( i-- )
	129	{
	130	#ifdef WORDS_BIGENDIAN
	131	p_out = ((float)( (((int32_t)(int16_t *)(p_in)) << 8) + p_in[2]))
	132	#else
	133	p_out = ((float)( (((int32_t)(int16_t *)(p_in+1)) << 8) + p_in[0]))
	134	#endif
	135	/ 8388608.0;
	136
	137	p_in -= 3; p_out--;
	138	}
	139
	140	p_out_buf->i_nb_samples = p_in_buf->i_nb_samples;
	141	p_out_buf->i_nb_bytes = p_in_buf->i_nb_bytes * 4 / 3;
	142	}

modules/audio_filter/converter/s16tofloat32swab.c

ra90a19a	r00906ea
3	3	* with endianness change
4	4	*****************************************************************************
5		* Copyright (C) 2002 VideoLAN
	5	* Copyright (C) 2002-2005 VideoLAN
6	6	* $Id$
7	7	*
…	…
50	50	static void DoWork ( aout_instance_t , aout_filter_t , aout_buffer_t *,
51	51	aout_buffer_t * );
	52	static void DoWork24 ( aout_instance_t , aout_filter_t , aout_buffer_t *,
	53	aout_buffer_t * );
52	54
53	55	/*****************************************************************************
…	…
83	85	{
84	86	p_filter->pf_do_work = DoWork;
	87	p_filter->b_in_place = VLC_TRUE;
	88
	89	return 0;
	90	}
	91
	92	if ( (p_filter->input.i_format == VLC_FOURCC('s','2','4','l') \|\|
	93	p_filter->input.i_format == VLC_FOURCC('s','2','4','b'))
	94	&& p_filter->output.i_format == VLC_FOURCC('f','l','3','2')
	95	&& p_filter->input.i_format != AOUT_FMT_S24_NE )
	96	{
	97	p_filter->pf_do_work = DoWork24;
85	98	p_filter->b_in_place = VLC_TRUE;
86	99
…	…
140	153	}
141	154
	155	static void DoWork24( aout_instance_t * p_aout, aout_filter_t * p_filter,
	156	aout_buffer_t * p_in_buf, aout_buffer_t * p_out_buf )
	157	{
	158	int i = p_in_buf->i_nb_samples * aout_FormatNbChannels( &p_filter->input );
	159
	160	/* We start from the end because b_in_place is true */
	161	uint8_t * p_in = (uint8_t )p_in_buf->p_buffer + (i - 1) 3;
	162	float * p_out = (float *)p_out_buf->p_buffer + i - 1;
	163
	164	byte_t p_tmp[3];
	165
	166	while( i-- )
	167	{
	168	p_tmp[0] = p_in[2];
	169	p_tmp[1] = p_in[1];
	170	p_tmp[2] = p_in[0];
	171
	172	#ifdef WORDS_BIGENDIAN
	173	p_out = ((float)( (((int32_t)(int16_t *)(p_tmp)) << 8) + p_tmp[2]))
	174	#else
	175	p_out = ((float)( (((int32_t)(int16_t *)(p_tmp+1)) << 8) + p_tmp[0]))
	176	#endif
	177	/ 8388608.0;
	178
	179	p_in -= 3; p_out--;
	180	}
	181
	182	p_out_buf->i_nb_samples = p_in_buf->i_nb_samples;
	183	p_out_buf->i_nb_bytes = p_in_buf->i_nb_bytes * 4 / 3;
	184	}

modules/audio_filter/format.c

ra4101b9	r00906ea
2	2	* format.c : PCM format converter
3	3	*****************************************************************************
4		* Copyright (C) 2002 VideoLAN
	4	* Copyright (C) 2002-2005 VideoLAN
5	5	* $Id$
6	6	*
…	…
34	34
35	35	#ifdef WORDS_BIGENDIAN
	36	# define AOUT_FMT_S24_IE VLC_FOURCC('s','2','4','l')
36	37	# define AOUT_FMT_S16_IE VLC_FOURCC('s','1','6','l')
37	38	# define AOUT_FMT_U16_IE VLC_FOURCC('u','1','6','l')
38	39	#else
	40	# define AOUT_FMT_S24_IE VLC_FOURCC('s','2','4','b')
39	41	# define AOUT_FMT_S16_IE VLC_FOURCC('s','1','6','b')
40	42	# define AOUT_FMT_U16_IE VLC_FOURCC('u','1','6','b')
…	…
47	49	static int Open ( vlc_object_t * );
48	50
	51	static block_t Float32toS24( filter_t , block_t * );
49	52	static block_t Float32toS16( filter_t , block_t * );
50	53	static block_t Float32toU16( filter_t , block_t * );
…	…
52	55	static block_t Float32toU8 ( filter_t , block_t * );
53	56
54		static block_t S16toFloat32( filter_t , block_t * );
55		static block_t S16toS8 ( filter_t p_filter, block_t *p_block );
56		static block_t S16toU8 ( filter_t p_filter, block_t *p_block );
57		static block_t S16toU16 ( filter_t p_filter, block_t *p_block );
	57	static block_t S24toFloat32 ( filter_t , block_t * );
	58	static block_t S24toS16 ( filter_t , block_t * );
	59	static block_t S24toS16Invert( filter_t , block_t * );
	60
	61	static block_t S16toFloat32 ( filter_t , block_t * );
	62	static block_t S16toS24 ( filter_t , block_t * );
	63	static block_t S16toS24Invert( filter_t , block_t * );
	64	static block_t S16toS8 ( filter_t , block_t * );
	65	static block_t S16toU8 ( filter_t , block_t * );
	66	static block_t S16toU16 ( filter_t , block_t * );
58	67
59	68	static block_t U16toFloat32( filter_t , block_t * );
60		static block_t U16toS8 ( filter_t p_filter, block_t *p_block );
61		static block_t U16toU8 ( filter_t p_filter, block_t *p_block );
62		static block_t U16toS16 ( filter_t p_filter, block_t *p_block );
63
	69	static block_t U16toS8 ( filter_t , block_t * );
	70	static block_t U16toU8 ( filter_t , block_t * );
	71	static block_t U16toS16 ( filter_t , block_t * );
	72
	73	static block_t Float32toS24Invert( filter_t , block_t * );
64	74	static block_t Float32toS16Invert( filter_t , block_t * );
65	75	static block_t Float32toU16Invert( filter_t , block_t * );
66	76
67		static block_t S16InverttoFloat32( filter_t , block_t * );
68		static block_t S16InverttoS8( filter_t p_filter, block_t *p_block );
69		static block_t S16InverttoU8( filter_t p_filter, block_t *p_block );
70		static block_t S16InverttoU16( filter_t p_filter, block_t *p_block );
	77	static block_t S24InverttoFloat32 ( filter_t , block_t * );
	78	static block_t S24InverttoS16 ( filter_t , block_t * );
	79	static block_t S24InverttoS16Invert( filter_t , block_t * );
	80
	81	static block_t S16InverttoFloat32 ( filter_t , block_t * );
	82	static block_t S16InverttoS24 ( filter_t , block_t * );
	83	static block_t S16InverttoS24Invert( filter_t , block_t * );
	84	static block_t S16InverttoS8 ( filter_t , block_t * );
	85	static block_t S16InverttoU8 ( filter_t , block_t * );
	86	static block_t S16InverttoU16 ( filter_t , block_t * );
71	87
72	88	static block_t U16InverttoFloat32( filter_t , block_t * );
73		static block_t U16InverttoS8~~( filter_t p_filter, block_t *p_block~~ );
74		static block_t U16InverttoU8~~( filter_t p_filter, block_t *p_block~~ );
75		static block_t U16InverttoS16~~( filter_t p_filter, block_t *p_block~~ );
76
77		static block_t S8toFloat32( filter_t , block_t * );
78		static block_t S8toS16( filter_t , block_t * );
79		static block_t S8toU16( filter_t , block_t * );
80		static block_t S8toU8( filter_t , block_t * );
	89	static block_t U16InverttoS8 ( filter_t , block_t * );
	90	static block_t U16InverttoU8 ( filter_t , block_t * );
	91	static block_t U16InverttoS16 ( filter_t , block_t * );
	92
	93	static block_t S8toFloat32 ( filter_t , block_t * );
	94	static block_t S8toS16 ( filter_t , block_t * );
	95	static block_t S8toU16 ( filter_t , block_t * );
	96	static block_t S8toU8 ( filter_t , block_t * );
81	97	static block_t S8toS16Invert( filter_t , block_t * );
82	98	static block_t S8toU16Invert( filter_t , block_t * );
83	99
84		static block_t U8toFloat32( filter_t , block_t * );
85		static block_t U8toFloat32( filter_t , block_t * );
86		static block_t U8toS16( filter_t , block_t * );
87		static block_t U8toU16( filter_t , block_t * );
88		static block_t U8toS8( filter_t , block_t * );
	100	static block_t U8toFloat32 ( filter_t , block_t * );
	101	static block_t U8toFloat32 ( filter_t , block_t * );
	102	static block_t U8toS16 ( filter_t , block_t * );
	103	static block_t U8toU16 ( filter_t , block_t * );
	104	static block_t U8toS8 ( filter_t , block_t * );
89	105	static block_t U8toS16Invert( filter_t , block_t * );
90	106	static block_t U8toU16Invert( filter_t , block_t * );
…	…
95	111
96	112
97		static block_t Swap16 ( filter_t , block_t * );
	113	static block_t Swap16( filter_t , block_t * );
	114	static block_t Swap24( filter_t , block_t * );
98	115
99	116	static struct
…	…
105	122	{
106	123	/* From fl32 */
	124	{ VLC_FOURCC('f','l','3','2'), AOUT_FMT_S24_NE, Float32toS24 },
107	125	{ VLC_FOURCC('f','l','3','2'), AOUT_FMT_S16_NE, Float32toS16 },
108	126	{ VLC_FOURCC('f','l','3','2'), AOUT_FMT_U16_NE, Float32toU16 },
	127	{ VLC_FOURCC('f','l','3','2'), AOUT_FMT_S24_IE, Float32toS24Invert },
109	128	{ VLC_FOURCC('f','l','3','2'), AOUT_FMT_S16_IE, Float32toS16Invert },
110	129	{ VLC_FOURCC('f','l','3','2'), AOUT_FMT_U16_IE, Float32toU16Invert },
…	…
112	131	{ VLC_FOURCC('f','l','3','2'), VLC_FOURCC('u','8',' ',' '), Float32toU8 },
113	132
	133	/* From s24 invert */
	134	{ AOUT_FMT_S24_NE, VLC_FOURCC('f','l','3','2'), S24toFloat32 },
	135	{ AOUT_FMT_S24_NE, AOUT_FMT_S24_IE, Swap24 },
	136	{ AOUT_FMT_S24_NE, AOUT_FMT_S16_NE, S24toS16 },
	137	{ AOUT_FMT_S24_NE, AOUT_FMT_S16_IE, S24toS16Invert },
	138
114	139	/* From s16 */
115	140	{ AOUT_FMT_S16_NE, VLC_FOURCC('f','l','3','2'), S16toFloat32 },
116		{ AOUT_FMT_S16_NE, AOUT_FMT_S16_IE, Swap16 },
117		{ AOUT_FMT_S16_NE, AOUT_FMT_U16_IE, S16toU16 },
	141	{ AOUT_FMT_S16_NE, AOUT_FMT_S24_NE, S16toS24 },
	142	{ AOUT_FMT_S16_NE, AOUT_FMT_S24_IE, S16toS24Invert },
	143	{ AOUT_FMT_S16_NE, AOUT_FMT_S16_IE, Swap16 },
	144	{ AOUT_FMT_S16_NE, AOUT_FMT_U16_IE, S16toU16 },
118	145	{ AOUT_FMT_S16_NE, VLC_FOURCC('s','8',' ',' '), S16toS8 },
119	146	{ AOUT_FMT_S16_NE, VLC_FOURCC('u','8',' ',' '), S16toU8 },
…	…
121	148	/* From u16 */
122	149	{ AOUT_FMT_U16_NE, VLC_FOURCC('f','l','3','2'), U16toFloat32 },
123		{ AOUT_FMT_U16_NE, AOUT_FMT_U16_IE, Swap16 },
124		{ AOUT_FMT_U16_NE, AOUT_FMT_S16_IE, U16toS16 },
	150	{ AOUT_FMT_U16_NE, AOUT_FMT_U16_IE, Swap16 },
	151	{ AOUT_FMT_U16_NE, AOUT_FMT_S16_IE, U16toS16 },
125	152	{ AOUT_FMT_U16_NE, VLC_FOURCC('s','8',' ',' '), U16toS8 },
126	153	{ AOUT_FMT_U16_NE, VLC_FOURCC('u','8',' ',' '), U16toU8 },
…	…
142	169	{ VLC_FOURCC('u','8',' ',' '), VLC_FOURCC('s','8',' ',' '), U8toS8 },
143	170
	171	/* From s24 invert */
	172	{ AOUT_FMT_S24_IE, VLC_FOURCC('f','l','3','2'), S24InverttoFloat32 },
	173	{ AOUT_FMT_S24_IE, AOUT_FMT_S24_NE, Swap24 },
	174	{ AOUT_FMT_S24_IE, AOUT_FMT_S16_NE, S24InverttoS16 },
	175	{ AOUT_FMT_S24_IE, AOUT_FMT_S16_IE, S24InverttoS16Invert },
	176
144	177	/* From s16 invert */
145	178	{ AOUT_FMT_S16_IE, VLC_FOURCC('f','l','3','2'), S16InverttoFloat32 },
146		{ AOUT_FMT_S16_IE, AOUT_FMT_S16_NE, Swap16 },
147		{ AOUT_FMT_S16_IE, AOUT_FMT_U16_NE, S16InverttoU16 },
	179	{ AOUT_FMT_S16_IE, AOUT_FMT_S24_NE, S16InverttoS24 },
	180	{ AOUT_FMT_S16_IE, AOUT_FMT_S24_IE, S16InverttoS24Invert },
	181	{ AOUT_FMT_S16_IE, AOUT_FMT_S16_NE, Swap16 },
	182	{ AOUT_FMT_S16_IE, AOUT_FMT_U16_NE, S16InverttoU16 },
148	183	{ AOUT_FMT_S16_IE, VLC_FOURCC('s','8',' ',' '), S16InverttoS8 },
149	184	{ AOUT_FMT_S16_IE, VLC_FOURCC('u','8',' ',' '), S16InverttoU8 },
…	…
151	186	/* From u16 invert */
152	187	{ AOUT_FMT_U16_IE, VLC_FOURCC('f','l','3','2'), U16InverttoFloat32 },
153		{ AOUT_FMT_U16_IE, AOUT_FMT_U16_NE, Swap16 },
154		{ AOUT_FMT_U16_IE, AOUT_FMT_S16_NE, U16InverttoS16 },
	188	{ AOUT_FMT_U16_IE, AOUT_FMT_U16_NE, Swap16 },
	189	{ AOUT_FMT_U16_IE, AOUT_FMT_S16_NE, U16InverttoS16 },
155	190	{ AOUT_FMT_U16_IE, VLC_FOURCC('s','8',' ',' '), U16InverttoS8 },
156	191	{ AOUT_FMT_U16_IE, VLC_FOURCC('u','8',' ',' '), U16InverttoU8 },
…	…
200	235	* Convert a buffer
201	236	*****************************************************************************/
	237	static block_t Float32toS24( filter_t p_filter, block_t *p_block )
	238	{
	239	int i;
	240	float p_in = (float )p_block->p_buffer;
	241	uint8_t p_out = (uint8_t )p_in;
	242	int32_t out;
	243
	244	for( i = p_block->i_buffer*8/p_filter->fmt_in.audio.i_bitspersample; i--; )
	245	{
	246	if ( *p_in >= 1.0 ) out = 8388607;
	247	else if ( *p_in < -1.0 ) out = -8388608;
	248	else out = p_in 8388608.0;
	249
	250	#ifdef WORDS_BIGENDIAN
	251	((int16_t )p_out) = out >> 8;
	252	p_out[2] = out & 0xFF;
	253	#else
	254	((int16_t )(p_out+1)) = out >> 8;
	255	p_out[0] = out & 0xFF;
	256	#endif
	257
	258	p_in++; p_out += 3;
	259	}
	260
	261	p_block->i_buffer = p_block->i_buffer * 3 / 4;
	262	return p_block;
	263	}
	264
202	265	static block_t Float32toS16( filter_t p_filter, block_t *p_block )
203	266	{
…	…
246	309	}
247	310
	311	static block_t S24toFloat32( filter_t p_filter, block_t *p_block )
	312	{
	313	block_t *p_block_out;
	314	uint8_t *p_in;
	315	float *p_out;
	316	int i;
	317
	318	p_block_out =
	319	p_filter->pf_audio_buffer_new( p_filter, p_block->i_buffer*4/3 );
	320	if( !p_block_out )
	321	{
	322	msg_Warn( p_filter, "can't get output buffer" );
	323	return NULL;
	324	}
	325
	326	p_in = p_block->p_buffer;
	327	p_out = (float *)p_block_out->p_buffer;
	328
	329	for( i = p_block->i_buffer*8/p_filter->fmt_in.audio.i_bitspersample; i--; )
	330	{
	331	#ifdef WORDS_BIGENDIAN
	332	p_out = ((float)( (((int32_t)(int16_t *)(p_in)) << 8) + p_in[2]))
	333	#else
	334	p_out = ((float)( (((int32_t)(int16_t *)(p_in+1)) << 8) + p_in[0]))
	335	#endif
	336	/ 8388608.0;
	337
	338	p_in += 3; p_out++;
	339	}
	340
	341	p_block_out->i_samples = p_block->i_samples;
	342	p_block_out->i_dts = p_block->i_dts;
	343	p_block_out->i_pts = p_block->i_pts;
	344	p_block_out->i_length = p_block->i_length;
	345	p_block_out->i_rate = p_block->i_rate;
	346
	347	p_block->pf_release( p_block );
	348	return p_block_out;
	349	}
	350
	351	static block_t S24toS16( filter_t p_filter, block_t *p_block )
	352	{
	353	int i;
	354	uint8_t p_in = (uint8_t )p_block->p_buffer;
	355	uint8_t p_out = (uint8_t )p_in;
	356
	357	for( i = p_block->i_buffer*8/p_filter->fmt_in.audio.i_bitspersample; i--; )
	358	{
	359	#ifdef WORDS_BIGENDIAN
	360	p_out++ = p_in++;
	361	p_out++ = p_in++;
	362	p_in++;
	363	#else
	364	p_in++;
	365	p_out++ = p_in++;
	366	p_out++ = p_in++;
	367	#endif
	368	}
	369
	370	p_block->i_buffer = p_block->i_buffer * 2 / 3;
	371	return p_block;
	372	}
	373
248	374	static block_t S16toFloat32( filter_t p_filter, block_t *p_block )
249	375	{
…	…
324	450	}
325	451
326		static block_t S16toS8( filter_t p_filter, block_t *p_block )
327		{
328		int i;
329		int16_t p_in = (int16_t )p_block->p_buffer;
330		int8_t p_out = (int8_t )p_in;
331
332		for( i = p_block->i_buffer*8/p_filter->fmt_in.audio.i_bitspersample; i--; )
333		p_out++ = (p_in++) >> 8;
334
335		p_block->i_buffer /= 2;
336		return p_block;
337		}
338		static block_t S16toU8( filter_t p_filter, block_t *p_block )
339		{
340		int i;
341		int16_t p_in = (int16_t )p_block->p_buffer;
342		uint8_t p_out = (uint8_t )p_in;
343
344		for( i = p_block->i_buffer*8/p_filter->fmt_in.audio.i_bitspersample; i--; )
345		p_out++ = ((p_in++) + 32768) >> 8;
346
347		p_block->i_buffer /= 2;
348		return p_block;
349		}
350		static block_t S16toU16( filter_t p_filter, block_t *p_block )
351		{
352		int i;
353		int16_t p_in = (int16_t )p_block->p_buffer;
354		uint16_t p_out = (uint16_t )p_in;
355
356		for( i = p_block->i_buffer*8/p_filter->fmt_in.audio.i_bitspersample; i--; )
357		p_out++ = (p_in++) + 32768;
358
359		return p_block;
360		}
361
362		static block_t U16toS8( filter_t p_filter, block_t *p_block )
363		{
364		int i;
365		uint16_t p_in = (uint16_t )p_block->p_buffer;
366		int8_t p_out = (int8_t )p_in;
367
368		for( i = p_block->i_buffer*8/p_filter->fmt_in.audio.i_bitspersample; i--; )
369		p_out++ = ((int)(p_in++) - 32768) >> 8;
370
371		p_block->i_buffer /= 2;
372		return p_block;
373		}
374		static block_t U16toU8( filter_t p_filter, block_t *p_block )
375		{
376		int i;
377		uint16_t p_in = (uint16_t )p_block->p_buffer;
378		uint8_t p_out = (uint8_t )p_in;
379
380		for( i = p_block->i_buffer*8/p_filter->fmt_in.audio.i_bitspersample; i--; )
381		p_out++ = (p_in++) >> 8;
382
383		p_block->i_buffer /= 2;
384		return p_block;
385		}
386		static block_t U16toS16( filter_t p_filter, block_t *p_block )
387		{
388		int i;
389		int16_t p_in = (int16_t )p_block->p_buffer;
390		uint16_t p_out = (uint16_t )p_in;
391
392		for( i = p_block->i_buffer*8/p_filter->fmt_in.audio.i_bitspersample; i--; )
393		p_out++ = (int)(p_in++) - 32768;
394
395		return p_block;
396		}
397
398		static block_t S8toU8( filter_t p_filter, block_t *p_block )
399		{
400		int i;
401		int8_t p_in = (int8_t )p_block->p_buffer;
402		uint8_t p_out = (uint8_t )p_in;
403
404		for( i = p_block->i_buffer*8/p_filter->fmt_in.audio.i_bitspersample; i--; )
405		p_out++ = ((p_in++) + 128);
406
407		return p_block;
408		}
409		static block_t U8toS8( filter_t p_filter, block_t *p_block )
410		{
411		int i;
412		uint8_t p_in = (uint8_t )p_block->p_buffer;
413		int8_t p_out = (int8_t )p_in;
414
415		for( i = p_block->i_buffer*8/p_filter->fmt_in.audio.i_bitspersample; i--; )
416		p_out++ = ((p_in++) - 128);
417
418		return p_block;
419		}
420
421		/* */
422		static block_t S8toU16( filter_t p_filter, block_t *p_block )
	452	static block_t S16toS24( filter_t p_filter, block_t *p_block )
423	453	{
424	454	block_t *p_block_out;
425		int8_t *p_in;
426		uint16_t *p_out;
	455	uint8_t p_in, p_out;
427	456	int i;
428	457
429	458	p_block_out =
430		p_filter->pf_audio_buffer_new( p_filter, p_block->i_buffer*2 );
	459	p_filter->pf_audio_buffer_new( p_filter, p_block->i_buffer*3/2 );
431	460	if( !p_block_out )
432	461	{
…	…
435	464	}
436	465
437		p_in = (int8_t *)p_block->p_buffer;
438		p_out = (uint16_t *)p_block_out->p_buffer;
439
440		for( i = p_block->i_buffer*8/p_filter->fmt_in.audio.i_bitspersample; i--; )
441		p_out++ = ((p_in++) + 128) << 8;
	466	p_in = (uint8_t *)p_block->p_buffer;
	467	p_out = (uint8_t *)p_block_out->p_buffer;
	468
	469	for( i = p_block->i_buffer*8/p_filter->fmt_in.audio.i_bitspersample; i--; )
	470	{
	471	#ifdef WORDS_BIGENDIAN
	472	p_out++ = p_in++;
	473	p_out++ = p_in++;
	474	*p_out++ = 0;
	475	#else
	476	*p_out++ = 0;
	477	p_out++ = p_in++;
	478	p_out++ = p_in++;
	479	#endif
	480	}
442	481
443	482	p_block_out->i_samples = p_block->i_samples;
…	…
451	490	}
452	491
453		static block_t U8toS16( filter_t p_filter, block_t *p_block )
	492	static block_t S16toS8( filter_t p_filter, block_t *p_block )
	493	{
	494	int i;
	495	int16_t p_in = (int16_t )p_block->p_buffer;
	496	int8_t p_out = (int8_t )p_in;
	497
	498	for( i = p_block->i_buffer*8/p_filter->fmt_in.audio.i_bitspersample; i--; )
	499	p_out++ = (p_in++) >> 8;
	500
	501	p_block->i_buffer /= 2;
	502	return p_block;
	503	}
	504	static block_t S16toU8( filter_t p_filter, block_t *p_block )
	505	{
	506	int i;
	507	int16_t p_in = (int16_t )p_block->p_buffer;
	508	uint8_t p_out = (uint8_t )p_in;
	509
	510	for( i = p_block->i_buffer*8/p_filter->fmt_in.audio.i_bitspersample; i--; )
	511	p_out++ = ((p_in++) + 32768) >> 8;
	512
	513	p_block->i_buffer /= 2;
	514	return p_block;
	515	}
	516	static block_t S16toU16( filter_t p_filter, block_t *p_block )
	517	{
	518	int i;
	519	int16_t p_in = (int16_t )p_block->p_buffer;
	520	uint16_t p_out = (uint16_t )p_in;
	521
	522	for( i = p_block->i_buffer*8/p_filter->fmt_in.audio.i_bitspersample; i--; )
	523	p_out++ = (p_in++) + 32768;
	524
	525	return p_block;
	526	}
	527
	528	static block_t U16toS8( filter_t p_filter, block_t *p_block )
	529	{
	530	int i;
	531	uint16_t p_in = (uint16_t )p_block->p_buffer;
	532	int8_t p_out = (int8_t )p_in;
	533
	534	for( i = p_block->i_buffer*8/p_filter->fmt_in.audio.i_bitspersample; i--; )
	535	p_out++ = ((int)(p_in++) - 32768) >> 8;
	536
	537	p_block->i_buffer /= 2;
	538	return p_block;
	539	}
	540	static block_t U16toU8( filter_t p_filter, block_t *p_block )
	541	{
	542	int i;
	543	uint16_t p_in = (uint16_t )p_block->p_buffer;
	544	uint8_t p_out = (uint8_t )p_in;
	545
	546	for( i = p_block->i_buffer*8/p_filter->fmt_in.audio.i_bitspersample; i--; )
	547	p_out++ = (p_in++) >> 8;
	548
	549	p_block->i_buffer /= 2;
	550	return p_block;
	551	}
	552	static block_t U16toS16( filter_t p_filter, block_t *p_block )
	553	{
	554	int i;
	555	int16_t p_in = (int16_t )p_block->p_buffer;
	556	uint16_t p_out = (uint16_t )p_in;
	557
	558	for( i = p_block->i_buffer*8/p_filter->fmt_in.audio.i_bitspersample; i--; )
	559	p_out++ = (int)(p_in++) - 32768;
	560
	561	return p_block;
	562	}
	563
	564	static block_t S8toU8( filter_t p_filter, block_t *p_block )
	565	{
	566	int i;
	567	int8_t p_in = (int8_t )p_block->p_buffer;
	568	uint8_t p_out = (uint8_t )p_in;
	569
	570	for( i = p_block->i_buffer*8/p_filter->fmt_in.audio.i_bitspersample; i--; )
	571	p_out++ = ((p_in++) + 128);
	572
	573	return p_block;
	574	}
	575	static block_t U8toS8( filter_t p_filter, block_t *p_block )
	576	{
	577	int i;
	578	uint8_t p_in = (uint8_t )p_block->p_buffer;
	579	int8_t p_out = (int8_t )p_in;
	580
	581	for( i = p_block->i_buffer*8/p_filter->fmt_in.audio.i_bitspersample; i--; )
	582	p_out++ = ((p_in++) - 128);
	583
	584	return p_block;
	585	}
	586
	587	/* */
	588	static block_t S8toU16( filter_t p_filter, block_t *p_block )
454	589	{
455	590	block_t *p_block_out;
456		uint8_t *p_in;
457		int16_t *p_out;
	591	int8_t *p_in;
	592	uint16_t *p_out;
458	593	int i;
459	594
…	…
466	601	}
467	602
468		p_in = (uint8_t *)p_block->p_buffer;
469		p_out = (int16_t *)p_block_out->p_buffer;
470
471		for( i = p_block->i_buffer*8/p_filter->fmt_in.audio.i_bitspersample; i--; )
472		p_out++ = ((p_in++) - 128) << 8;
	603	p_in = (int8_t *)p_block->p_buffer;
	604	p_out = (uint16_t *)p_block_out->p_buffer;
	605
	606	for( i = p_block->i_buffer*8/p_filter->fmt_in.audio.i_bitspersample; i--; )
	607	p_out++ = ((p_in++) + 128) << 8;
473	608
474	609	p_block_out->i_samples = p_block->i_samples;
…	…
482	617	}
483	618
484
485		static block_t S8toS16( filter_t p_filter, block_t *p_block )
	619	static block_t U8toS16( filter_t p_filter, block_t *p_block )
486	620	{
487	621	block_t *p_block_out;
488		int8_t *p_in;
	622	uint8_t *p_in;
489	623	int16_t *p_out;
490	624	int i;
…	…
498	632	}
499	633
500		p_in = (int8_t *)p_block->p_buffer;
	634	p_in = (uint8_t *)p_block->p_buffer;
501	635	p_out = (int16_t *)p_block_out->p_buffer;
502	636
503	637	for( i = p_block->i_buffer*8/p_filter->fmt_in.audio.i_bitspersample; i--; )
504		p_out++ = (p_in++) << 8;
	638	p_out++ = ((p_in++) - 128) << 8;
505	639
506	640	p_block_out->i_samples = p_block->i_samples;
…	…
514	648	}
515	649
516		static block_t U8toU16( filter_t p_filter, block_t *p_block )
	650
	651	static block_t S8toS16( filter_t p_filter, block_t *p_block )
517	652	{
518	653	block_t *p_block_out;
519		uint8_t *p_in;
520		uint16_t *p_out;
	654	int8_t *p_in;
	655	int16_t *p_out;
521	656	int i;
522	657
…	…
529	664	}
530	665
531		p_in = (uint8_t *)p_block->p_buffer;
532		p_out = (uint16_t *)p_block_out->p_buffer;
	666	p_in = (int8_t *)p_block->p_buffer;
	667	p_out = (int16_t *)p_block_out->p_buffer;
533	668
534	669	for( i = p_block->i_buffer*8/p_filter->fmt_in.audio.i_bitspersample; i--; )
…	…
545	680	}
546	681
	682	static block_t U8toU16( filter_t p_filter, block_t *p_block )
	683	{
	684	block_t *p_block_out;
	685	uint8_t *p_in;
	686	uint16_t *p_out;
	687	int i;
	688
	689	p_block_out =
	690	p_filter->pf_audio_buffer_new( p_filter, p_block->i_buffer*2 );
	691	if( !p_block_out )
	692	{
	693	msg_Warn( p_filter, "can't get output buffer" );
	694	return NULL;
	695	}
	696
	697	p_in = (uint8_t *)p_block->p_buffer;
	698	p_out = (uint16_t *)p_block_out->p_buffer;
	699
	700	for( i = p_block->i_buffer*8/p_filter->fmt_in.audio.i_bitspersample; i--; )
	701	p_out++ = (p_in++) << 8;
	702
	703	p_block_out->i_samples = p_block->i_samples;
	704	p_block_out->i_dts = p_block->i_dts;
	705	p_block_out->i_pts = p_block->i_pts;
	706	p_block_out->i_length = p_block->i_length;
	707	p_block_out->i_rate = p_block->i_rate;
	708
	709	p_block->pf_release( p_block );
	710	return p_block_out;
	711	}
	712
547	713	/*****************************************************************************
548		* Swap a buffer of word
	714	* Swap a buffer of words
549	715	*****************************************************************************/
550	716	static block_t Swap16( filter_t p_filter, block_t *p_block )
…	…
565	731	}
566	732
567		#define CONVERT_NN( func, f_in, f_out, b_pre_invert, b_post_invert ) \
	733	static block_t Swap24( filter_t p_filter, block_t *p_block )
	734	{
	735	int i;
	736	uint8_t p_in = (uint8_t )p_block->p_buffer;
	737	uint8_t tmp;
	738
	739	for( i = 0; i < p_block->i_buffer / 3; i++ )
	740	{
	741	tmp = p_in[0];
	742	p_in[0] = p_in[2];
	743	p_in[2] = tmp;
	744	p_in += 3;
	745	}
	746
	747	return p_block;
	748	}
	749
	750	#define CONVERT_NN( func, f_in, f_out, b_pre_invert, b_post_invert, swapa, swapb ) \
568	751	static block_t func( filter_t p_filter, block_t *p_block ) \
569	752	{ \
570	753	if( b_pre_invert ) \
571		~~Swap16( p_filter, p_block );~~ \
	754	swapa( p_filter, p_block ); \
572	755	\
573	756	p_block = f_in##to##f_out( p_filter, p_block ); \
574	757	\
575	758	if( b_post_invert ) \
576		~~Swap16( p_filter, p_block );~~ \
	759	swapb( p_filter, p_block ); \
577	760	\
578	761	return p_block; \
579	762	}
580	763
581		CONVERT_NN( Float32toS16Invert, Float32, S16, 0, 1 )
582		CONVERT_NN( Float32toU16Invert, Float32, U16, 0, 1 )
583
584		CONVERT_NN( S16InverttoFloat32, S16, Float32, 1, 0 )
585		CONVERT_NN( S16InverttoS8, S16, S8, 1, 0 )
586		CONVERT_NN( S16InverttoU8, S16, U8, 1, 0 )
587		CONVERT_NN( S16InverttoU16, S16, U16, 1, 0 )
588
589		CONVERT_NN( U16InverttoFloat32, U16, Float32, 1, 0 )
590		CONVERT_NN( U16InverttoS8, U16, S8, 1, 0 )
591		CONVERT_NN( U16InverttoU8, U16, U8, 1, 0 )
592		CONVERT_NN( U16InverttoS16, U16, S16, 1, 0 )
	764	CONVERT_NN( Float32toS24Invert, Float32, S24, 0, 1, Swap24, Swap24 )
	765	CONVERT_NN( Float32toS16Invert, Float32, S16, 0, 1, Swap16, Swap16 )
	766	CONVERT_NN( Float32toU16Invert, Float32, U16, 0, 1, Swap16, Swap16 )
	767
	768	CONVERT_NN( S24InverttoFloat32, S24, Float32, 1, 0, Swap24, Swap24 )
	769	CONVERT_NN( S24InverttoS16, S24, S16, 1, 0, Swap24, Swap16 )
	770	CONVERT_NN( S24InverttoS16Invert, S24, S16, 1, 1, Swap24, Swap16 )
	771	CONVERT_NN( S24toS16Invert, S24, S16, 0, 1, Swap24, Swap16 )
	772
	773	CONVERT_NN( S16InverttoFloat32, S16, Float32, 1, 0, Swap16, Swap16 )
	774	CONVERT_NN( S16InverttoS24, S16, S24, 1, 0, Swap16, Swap24 )
	775	CONVERT_NN( S16toS24Invert, S16, S24, 0, 1, Swap16, Swap24 )
	776	CONVERT_NN( S16InverttoS24Invert, S16, S24, 1, 1, Swap16, Swap24 )
	777	CONVERT_NN( S16InverttoS8, S16, S8, 1, 0, Swap16, Swap16 )
	778	CONVERT_NN( S16InverttoU8, S16, U8, 1, 0, Swap16, Swap16 )
	779	CONVERT_NN( S16InverttoU16, S16, U16, 1, 0, Swap16, Swap16 )
	780
	781	CONVERT_NN( U16InverttoFloat32, U16, Float32, 1, 0, Swap16, Swap16 )
	782	CONVERT_NN( U16InverttoS8, U16, S8, 1, 0, Swap16, Swap16 )
	783	CONVERT_NN( U16InverttoU8, U16, U8, 1, 0, Swap16, Swap16 )
	784	CONVERT_NN( U16InverttoS16, U16, S16, 1, 0, Swap16, Swap16 )
593	785
594	786	#undef CONVERT_NN
…	…
616	808
617	809	#undef CONVERT_INDIRECT
618
619
620

modules/codec/lpcm.c

ra90a19a	r00906ea
2	2	* lpcm.c: lpcm decoder/packetizer module
3	3	*****************************************************************************
4		* Copyright (C) 1999-2003 VideoLAN
	4	* Copyright (C) 1999-2005 VideoLAN
5	5	* $Id$
6	6	*
…	…
8	8	* Henri Fallon <henri@videolan.org>
9	9	* Christophe Massiot <massiot@via.ecp.fr>
10		* Gildas Bazin <gbazin@~~netcourrier.com~~>
	10	* Gildas Bazin <gbazin@videolan.org>
11	11	*
12	12	* This program is free software; you can redistribute it and/or modify
…	…
119	119	/* Set output properties */
120	120	p_dec->fmt_out.i_cat = AUDIO_ES;
121		p_dec->fmt_out.i_codec = VLC_FOURCC('s','1','6','b');
	121
	122	if( p_dec->fmt_out.audio.i_bitspersample == 24 )
	123	{
	124	p_dec->fmt_out.i_codec = VLC_FOURCC('s','2','4','b');
	125	}
	126	else
	127	{
	128	p_dec->fmt_out.i_codec = VLC_FOURCC('s','1','6','b');
	129	p_dec->fmt_out.audio.i_bitspersample = 16;
	130	}
122	131
123	132	/* Set callback */
…	…
155	164	block_t *p_block;
156	165	unsigned int i_rate = 0, i_original_channels = 0, i_channels = 0;
157		int i_frame_length;
	166	int i_frame_length, i_bitspersample;
158	167	uint8_t i_header;
159	168
…	…
240	249	\| AOUT_CHAN_CENTER \| AOUT_CHAN_MIDDLELEFT
241	250	\| AOUT_CHAN_MIDDLERIGHT \| AOUT_CHAN_LFE;
	251	break;
	252	}
	253
	254	switch ( (i_header >> 6) & 0x3 )
	255	{
	256	case 2:
	257	p_dec->fmt_out.i_codec = VLC_FOURCC('s','2','4','b');
	258	p_dec->fmt_out.audio.i_bitspersample = 24;
	259	i_bitspersample = 24;
	260	break;
	261	case 1:
	262	p_dec->fmt_out.i_codec = VLC_FOURCC('s','2','4','b');
	263	p_dec->fmt_out.audio.i_bitspersample = 24;
	264	i_bitspersample = 20;
	265	break;
	266	case 0:
	267	default:
	268	p_dec->fmt_out.i_codec = VLC_FOURCC('s','1','6','b');
	269	p_dec->fmt_out.audio.i_bitspersample = 16;
	270	i_bitspersample = 16;
242	271	break;
243	272	}
…	…
264	293
265	294	i_frame_length = (p_block->i_buffer - LPCM_HEADER_LEN) /
266		~~( p_dec->fmt_out.audio.i_channels * 2 )~~;
	295	p_dec->fmt_out.audio.i_channels * 8 / i_bitspersample;
267	296
268	297	if( p_sys->b_packetizer )
269	298	{
	299	p_dec->fmt_out.i_codec = VLC_FOURCC('l','p','c','m');
270	300	p_block->i_pts = p_block->i_dts = aout_DateGet( &p_sys->end_date );
271	301	p_block->i_length =
…	…
286	316	aout_DateIncrement( &p_sys->end_date, i_frame_length );
287	317
288		memcpy( p_aout_buffer->p_buffer,
289		p_block->p_buffer + LPCM_HEADER_LEN,
290		p_block->i_buffer - LPCM_HEADER_LEN );
	318	p_block->p_buffer += LPCM_HEADER_LEN;
	319	p_block->i_buffer -= LPCM_HEADER_LEN;
	320
	321	/* 20/24 bits LPCM use special packing */
	322	if( i_bitspersample == 24 )
	323	{
	324	uint8_t *p_out = p_aout_buffer->p_buffer;
	325
	326	while( p_block->i_buffer / 12 )
	327	{
	328	/* Sample 1 */
	329	p_out[0] = p_block->p_buffer[0];
	330	p_out[1] = p_block->p_buffer[1];
	331	p_out[2] = p_block->p_buffer[8];
	332	/* Sample 2 */
	333	p_out[3] = p_block->p_buffer[2];
	334	p_out[4] = p_block->p_buffer[3];
	335	p_out[5] = p_block->p_buffer[9];
	336	/* Sample 3 */
	337	p_out[6] = p_block->p_buffer[4];
	338	p_out[7] = p_block->p_buffer[5];
	339	p_out[8] = p_block->p_buffer[10];
	340	/* Sample 4 */
	341	p_out[9] = p_block->p_buffer[6];
	342	p_out[10] = p_block->p_buffer[7];
	343	p_out[11] = p_block->p_buffer[11];
	344
	345	p_block->i_buffer -= 12;
	346	p_block->p_buffer += 12;
	347	p_out += 12;
	348	}
	349	}
	350	else if( i_bitspersample == 20 )
	351	{
	352	uint8_t *p_out = p_aout_buffer->p_buffer;
	353
	354	while( p_block->i_buffer / 10 )
	355	{
	356	/* Sample 1 */
	357	p_out[0] = p_block->p_buffer[0];
	358	p_out[1] = p_block->p_buffer[1];
	359	p_out[2] = p_block->p_buffer[8] & 0xF0;
	360	/* Sample 2 */
	361	p_out[3] = p_block->p_buffer[2];
	362	p_out[4] = p_block->p_buffer[3];
	363	p_out[5] = p_block->p_buffer[8] << 4;
	364	/* Sample 3 */
	365	p_out[6] = p_block->p_buffer[4];
	366	p_out[7] = p_block->p_buffer[5];
	367	p_out[8] = p_block->p_buffer[9] & 0xF0;
	368	/* Sample 4 */
	369	p_out[9] = p_block->p_buffer[6];
	370	p_out[10] = p_block->p_buffer[7];
	371	p_out[11] = p_block->p_buffer[9] << 4;
	372
	373	p_block->i_buffer -= 10;
	374	p_block->p_buffer += 10;
	375	p_out += 12;
	376	}
	377	}
	378	else
	379	{
	380	memcpy( p_aout_buffer->p_buffer,
	381	p_block->p_buffer, p_block->i_buffer );
	382	}
291	383
292	384	block_Release( p_block );