2 * Copyright (C) 2003-2010 The Music Player Daemon Project
3 * http://www.musicpd.org
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License along
16 * with this program; if not, write to the Free Software Foundation, Inc.,
17 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
21 #include "pcm_format.h"
22 #include "pcm_dither.h"
23 #include "pcm_buffer.h"
27 pcm_convert_8_to_16(int16_t *out
, const int8_t *in
,
30 while (num_samples
> 0) {
37 pcm_convert_24_to_16(struct pcm_dither
*dither
,
38 int16_t *out
, const int32_t *in
,
41 pcm_dither_24_to_16(dither
, out
, in
, num_samples
);
45 pcm_convert_32_to_16(struct pcm_dither
*dither
,
46 int16_t *out
, const int32_t *in
,
49 pcm_dither_32_to_16(dither
, out
, in
, num_samples
);
53 pcm_convert_24_to_24p32(struct pcm_buffer
*buffer
, const uint8_t *src
,
56 int32_t *dest
= pcm_buffer_get(buffer
, num_samples
* 4);
57 pcm_unpack_24(dest
, src
, num_samples
, false);
62 pcm_convert_to_16(struct pcm_buffer
*buffer
, struct pcm_dither
*dither
,
63 enum sample_format src_format
, const void *src
,
64 size_t src_size
, size_t *dest_size_r
)
71 case SAMPLE_FORMAT_UNDEFINED
:
74 case SAMPLE_FORMAT_S8
:
75 num_samples
= src_size
;
76 *dest_size_r
= src_size
* sizeof(*dest
);
77 dest
= pcm_buffer_get(buffer
, *dest_size_r
);
79 pcm_convert_8_to_16(dest
,
84 case SAMPLE_FORMAT_S16
:
85 *dest_size_r
= src_size
;
88 case SAMPLE_FORMAT_S24
:
89 /* convert to S24_P32 first */
90 num_samples
= src_size
/ 3;
92 dest32
= pcm_convert_24_to_24p32(buffer
, src
, num_samples
);
93 dest
= (int16_t *)dest32
;
95 /* convert to 16 bit in-place */
96 *dest_size_r
= num_samples
* sizeof(*dest
);
97 pcm_convert_24_to_16(dither
, dest
, dest32
,
101 case SAMPLE_FORMAT_S24_P32
:
102 num_samples
= src_size
/ 4;
103 *dest_size_r
= num_samples
* sizeof(*dest
);
104 dest
= pcm_buffer_get(buffer
, *dest_size_r
);
106 pcm_convert_24_to_16(dither
, dest
,
107 (const int32_t *)src
,
111 case SAMPLE_FORMAT_S32
:
112 num_samples
= src_size
/ 4;
113 *dest_size_r
= num_samples
* sizeof(*dest
);
114 dest
= pcm_buffer_get(buffer
, *dest_size_r
);
116 pcm_convert_32_to_16(dither
, dest
,
117 (const int32_t *)src
,
126 pcm_convert_8_to_24(int32_t *out
, const int8_t *in
,
127 unsigned num_samples
)
129 while (num_samples
> 0) {
130 *out
++ = *in
++ << 16;
136 pcm_convert_16_to_24(int32_t *out
, const int16_t *in
,
137 unsigned num_samples
)
139 while (num_samples
> 0) {
146 pcm_convert_32_to_24(int32_t *out
, const int16_t *in
,
147 unsigned num_samples
)
149 while (num_samples
> 0) {
156 pcm_convert_to_24(struct pcm_buffer
*buffer
,
157 enum sample_format src_format
, const void *src
,
158 size_t src_size
, size_t *dest_size_r
)
160 unsigned num_samples
;
163 switch (src_format
) {
164 case SAMPLE_FORMAT_UNDEFINED
:
167 case SAMPLE_FORMAT_S8
:
168 num_samples
= src_size
;
169 *dest_size_r
= src_size
* sizeof(*dest
);
170 dest
= pcm_buffer_get(buffer
, *dest_size_r
);
172 pcm_convert_8_to_24(dest
, (const int8_t *)src
,
176 case SAMPLE_FORMAT_S16
:
177 num_samples
= src_size
/ 2;
178 *dest_size_r
= num_samples
* sizeof(*dest
);
179 dest
= pcm_buffer_get(buffer
, *dest_size_r
);
181 pcm_convert_16_to_24(dest
, (const int16_t *)src
,
185 case SAMPLE_FORMAT_S24
:
186 num_samples
= src_size
/ 3;
187 *dest_size_r
= num_samples
* sizeof(*dest
);
189 return pcm_convert_24_to_24p32(buffer
, src
, num_samples
);
191 case SAMPLE_FORMAT_S24_P32
:
192 *dest_size_r
= src_size
;
195 case SAMPLE_FORMAT_S32
:
196 num_samples
= src_size
/ 4;
197 *dest_size_r
= num_samples
* sizeof(*dest
);
198 dest
= pcm_buffer_get(buffer
, *dest_size_r
);
200 pcm_convert_32_to_24(dest
, (const int16_t *)src
,
209 pcm_convert_8_to_32(int32_t *out
, const int8_t *in
,
210 unsigned num_samples
)
212 while (num_samples
> 0) {
213 *out
++ = *in
++ << 24;
219 pcm_convert_16_to_32(int32_t *out
, const int16_t *in
,
220 unsigned num_samples
)
222 while (num_samples
> 0) {
223 *out
++ = *in
++ << 16;
229 pcm_convert_24_to_32(int32_t *out
, const int32_t *in
,
230 unsigned num_samples
)
232 while (num_samples
> 0) {
239 pcm_convert_to_32(struct pcm_buffer
*buffer
,
240 enum sample_format src_format
, const void *src
,
241 size_t src_size
, size_t *dest_size_r
)
243 unsigned num_samples
;
246 switch (src_format
) {
247 case SAMPLE_FORMAT_UNDEFINED
:
250 case SAMPLE_FORMAT_S8
:
251 num_samples
= src_size
;
252 *dest_size_r
= src_size
* sizeof(*dest
);
253 dest
= pcm_buffer_get(buffer
, *dest_size_r
);
255 pcm_convert_8_to_32(dest
, (const int8_t *)src
,
259 case SAMPLE_FORMAT_S16
:
260 num_samples
= src_size
/ 2;
261 *dest_size_r
= num_samples
* sizeof(*dest
);
262 dest
= pcm_buffer_get(buffer
, *dest_size_r
);
264 pcm_convert_16_to_32(dest
, (const int16_t *)src
,
268 case SAMPLE_FORMAT_S24
:
269 /* convert to S24_P32 first */
270 num_samples
= src_size
/ 3;
272 dest
= pcm_convert_24_to_24p32(buffer
, src
, num_samples
);
274 /* convert to 32 bit in-place */
275 *dest_size_r
= num_samples
* sizeof(*dest
);
276 pcm_convert_24_to_32(dest
, dest
, num_samples
);
279 case SAMPLE_FORMAT_S24_P32
:
280 num_samples
= src_size
/ 4;
281 *dest_size_r
= num_samples
* sizeof(*dest
);
282 dest
= pcm_buffer_get(buffer
, *dest_size_r
);
284 pcm_convert_24_to_32(dest
, (const int32_t *)src
,
288 case SAMPLE_FORMAT_S32
:
289 *dest_size_r
= src_size
;