[fdkaac.git] / src / pcm_native_converter.c

/* 
 * Copyright (C) 2013 nu774
 * For conditions of distribution and use, see copyright notice in COPYING
 */
#if HAVE_CONFIG_H
#  include "config.h"
#endif
#include <stdlib.h>
#include <string.h>
#if HAVE_STDINT_H
#  include <stdint.h>
#endif
#include "m4af_endian.h"
#include "pcm_reader.h"

static
inline float pcm_i2f(int32_t n)
{
    union {
        int32_t ivalue;
        float fvalue;
    } u;
    u.ivalue = n;
    return u.fvalue;
}
static
inline double pcm_i2d(int64_t n)
{
    union {
        int64_t ivalue;
        double fvalue;
    } u;
    u.ivalue = n;
    return u.fvalue;
}
static
inline int32_t pcm_s8_to_s32(int8_t n)
{
    return n << 24;
}
static
inline int32_t pcm_u8_to_s32(uint8_t n)
{
    return (n << 24) ^ 0x80000000;
}
static
inline int32_t pcm_s16le_to_s32(int16_t n)
{
    return m4af_ltoh16(n) << 16;
}
static
inline int32_t pcm_s16be_to_s32(int16_t n)
{
    return m4af_btoh16(n) << 16;
}
static
inline int32_t pcm_u16le_to_s32(uint16_t n)
{
    return (m4af_ltoh16(n) << 16) ^ 0x80000000;
}
static
inline int32_t pcm_u16be_to_s32(uint16_t n)
{
    return (m4af_btoh16(n) << 16) ^ 0x80000000;
}
static
inline int32_t pcm_s24le_to_s32(uint8_t *p)
{
    return p[0]<<8 | p[1]<<16 | p[2]<<24;
}
static
inline int32_t pcm_s24be_to_s32(uint8_t *p)
{
    return p[0]<<24 | p[1]<<16 | p[2]<<8;
}
static
inline int32_t pcm_u24le_to_s32(uint8_t *p)
{
    return pcm_s24le_to_s32(p) ^ 0x80000000;
}
static
inline int32_t pcm_u24be_to_s32(uint8_t *p)
{
    return pcm_s24be_to_s32(p) ^ 0x80000000;
}
static
inline int32_t pcm_s32le_to_s32(int32_t n)
{
    return m4af_ltoh32(n);
}
static
inline int32_t pcm_s32be_to_s32(int32_t n)
{
    return m4af_btoh32(n);
}
static
inline int32_t pcm_u32le_to_s32(int32_t n)
{
    return m4af_ltoh32(n) ^ 0x80000000;
}
static
inline int32_t pcm_u32be_to_s32(int32_t n)
{
    return m4af_btoh32(n) ^ 0x80000000;
}
static
inline float pcm_f32le_to_f32(int32_t n)
{
    return pcm_i2f(m4af_ltoh32(n));
}
static
inline float pcm_f32be_to_f32(int32_t n)
{
    return pcm_i2f(m4af_btoh32(n));
}
static
inline float pcm_f64le_to_f32(int64_t n)
{
    return pcm_i2d(m4af_ltoh64(n));
}
static
inline float pcm_f64be_to_f32(int64_t n)
{
    return pcm_i2d(m4af_btoh64(n));
}

static
int pcm_convert_to_native(const pcm_sample_description_t *format,
                          const void *input, uint32_t nframes,
                          void *result)
{
#define CONVERT(type, rtype, conv) \
    do { \
        unsigned i; \
        type *ip = (type *)input; \
        for (i = 0; i < count; ++i) { \
            ((rtype *)result)[i] = conv(ip[i]); \
        } \
    } while(0)

#define CONVERT_BYTES(rtype, conv) \
    do { \
        unsigned i, bytes_per_channel; \
        uint8_t *ip = (uint8_t *)input; \
        bytes_per_channel = PCM_BYTES_PER_CHANNEL(format); \
        for (i = 0; i < count; ++i) { \
            ((rtype *)result)[i] = conv(ip); \
            ip += bytes_per_channel; \
        } \
    } while(0)

    uint32_t count = nframes * format->channels_per_frame;
    if (!count)
        return 0;
    switch (PCM_BYTES_PER_CHANNEL(format) | format->sample_type<<4) {
    case 1 | PCM_TYPE_SINT<<4:
        CONVERT(int8_t, int32_t, pcm_s8_to_s32); break;
    case 1 | PCM_TYPE_UINT<<4:
        CONVERT(uint8_t, int32_t, pcm_u8_to_s32); break;
    case 2 | PCM_TYPE_SINT<<4:
        CONVERT(int16_t, int32_t, pcm_s16le_to_s32); break;
    case 2 | PCM_TYPE_UINT<<4:
        CONVERT(uint16_t, int32_t, pcm_u16le_to_s32); break;
    case 2 | PCM_TYPE_SINT_BE<<4:
        CONVERT(int16_t, int32_t, pcm_s16be_to_s32); break;
    case 2 | PCM_TYPE_UINT_BE<<4:
        CONVERT(int16_t, int32_t, pcm_u16be_to_s32); break;
    case 3 | PCM_TYPE_SINT<<4:
        CONVERT_BYTES(int32_t, pcm_s24le_to_s32); break;
    case 3 | PCM_TYPE_UINT<<4:
        CONVERT_BYTES(int32_t, pcm_u24le_to_s32); break;
    case 3 | PCM_TYPE_SINT_BE<<4:
        CONVERT_BYTES(int32_t, pcm_s24be_to_s32); break;
    case 3 | PCM_TYPE_UINT_BE<<4:
        CONVERT_BYTES(int32_t, pcm_u24be_to_s32); break;
    case 4 | PCM_TYPE_SINT<<4:
        CONVERT(int32_t, int32_t, pcm_s32le_to_s32); break;
    case 4 | PCM_TYPE_UINT<<4:
        CONVERT(uint32_t, int32_t, pcm_u32le_to_s32); break;
    case 4 | PCM_TYPE_FLOAT<<4:
        CONVERT(int32_t, float, pcm_f32le_to_f32); break;
    case 4 | PCM_TYPE_SINT_BE<<4:
        CONVERT(int32_t, int32_t, pcm_s32be_to_s32); break;
    case 4 | PCM_TYPE_UINT_BE<<4:
        CONVERT(uint32_t, int32_t, pcm_u32be_to_s32); break;
    case 4 | PCM_TYPE_FLOAT_BE<<4:
        CONVERT(int32_t, float, pcm_f32be_to_f32); break;
    case 8 | PCM_TYPE_FLOAT<<4:
        CONVERT(int64_t, float, pcm_f64le_to_f32); break;
    case 8 | PCM_TYPE_FLOAT_BE<<4:
        CONVERT(int64_t, float, pcm_f64be_to_f32); break;
    default:
        return -1;
    }
    return 0;
}

typedef struct pcm_native_converter_t {
    pcm_reader_vtbl_t *vtbl;
    pcm_reader_t *src;
    pcm_sample_description_t format;
    void *pivot;
    unsigned capacity;
} pcm_native_converter_t;

static inline pcm_reader_t *get_source(pcm_reader_t *reader)
{
    return ((pcm_native_converter_t *)reader)->src;
}

static const
pcm_sample_description_t *get_format(pcm_reader_t *reader)
{
    return &((pcm_native_converter_t *)reader)->format;
}

static int64_t get_length(pcm_reader_t *reader)
{
    return pcm_get_length(get_source(reader));
}

static int64_t get_position(pcm_reader_t *reader)
{
    return pcm_get_position(get_source(reader));
}

static int read_frames(pcm_reader_t *reader, void *buffer, unsigned nframes)
{
    pcm_native_converter_t *self = (pcm_native_converter_t *)reader;
    const pcm_sample_description_t *sfmt = pcm_get_format(self->src);
    unsigned bytes = nframes * sfmt->bytes_per_frame;

    if (self->capacity < bytes) {
        void *p = realloc(self->pivot, bytes);
        if (!p) return -1;
        self->pivot = p;
        self->capacity = bytes;
    }
    nframes = pcm_read_frames(self->src, self->pivot, nframes);
    if (pcm_convert_to_native(sfmt, self->pivot, nframes, buffer) < 0)
        return -1;
    return nframes;
}

static void teardown(pcm_reader_t **reader)
{
    pcm_native_converter_t *self = (pcm_native_converter_t *)*reader;
    pcm_teardown(&self->src);
    free(self->pivot);
    free(self);
    *reader = 0;
}

static pcm_reader_vtbl_t my_vtable = {
    get_format, get_length, get_position, read_frames, teardown
};

pcm_reader_t *pcm_open_native_converter(pcm_reader_t *reader)
{
    pcm_native_converter_t *self = 0;
    pcm_sample_description_t *fmt;

    if ((self = calloc(1, sizeof(pcm_native_converter_t))) == 0)
        return 0;
    self->src = reader;
    self->vtbl = &my_vtable;
    memcpy(&self->format, pcm_get_format(reader), sizeof(self->format));
    fmt = &self->format;
    fmt->sample_type = PCM_IS_FLOAT(fmt) ?  PCM_TYPE_FLOAT : PCM_TYPE_SINT;
    fmt->bytes_per_frame = 4 * fmt->channels_per_frame;
    return (pcm_reader_t *)self;
}
Commit	Line	Data
a7e00a42	1	/*
	2	* Copyright (C) 2013 nu774
	3	* For conditions of distribution and use, see copyright notice in COPYING
	4	*/
	5	#if HAVE_CONFIG_H
	6	# include "config.h"
	7	#endif
	8	#include <stdlib.h>
	9	#include <string.h>
	10	#if HAVE_STDINT_H
	11	# include <stdint.h>
	12	#endif
	13	#include "m4af_endian.h"
	14	#include "pcm_reader.h"
	15
	16	static
	17	inline float pcm_i2f(int32_t n)
	18	{
	19	union {
	20	int32_t ivalue;
	21	float fvalue;
	22	} u;
	23	u.ivalue = n;
	24	return u.fvalue;
	25	}
	26	static
	27	inline double pcm_i2d(int64_t n)
	28	{
	29	union {
	30	int64_t ivalue;
	31	double fvalue;
	32	} u;
	33	u.ivalue = n;
	34	return u.fvalue;
	35	}
	36	static
	37	inline int32_t pcm_s8_to_s32(int8_t n)
	38	{
	39	return n << 24;
	40	}
	41	static
	42	inline int32_t pcm_u8_to_s32(uint8_t n)
	43	{
	44	return (n << 24) ^ 0x80000000;
	45	}
	46	static
	47	inline int32_t pcm_s16le_to_s32(int16_t n)
	48	{
	49	return m4af_ltoh16(n) << 16;
	50	}
	51	static
	52	inline int32_t pcm_s16be_to_s32(int16_t n)
	53	{
	54	return m4af_btoh16(n) << 16;
	55	}
	56	static
	57	inline int32_t pcm_u16le_to_s32(uint16_t n)
	58	{
	59	return (m4af_ltoh16(n) << 16) ^ 0x80000000;
	60	}
	61	static
	62	inline int32_t pcm_u16be_to_s32(uint16_t n)
	63	{
	64	return (m4af_btoh16(n) << 16) ^ 0x80000000;
65	}
66	static
67	inline int32_t pcm_s24le_to_s32(uint8_t *p)
68	{
69	return p[0]<<8 \| p[1]<<16 \| p[2]<<24;
70	}
71	static
72	inline int32_t pcm_s24be_to_s32(uint8_t *p)
73	{
74	return p[0]<<24 \| p[1]<<16 \| p[2]<<8;
75	}
76	static
77	inline int32_t pcm_u24le_to_s32(uint8_t *p)
78	{
79	return pcm_s24le_to_s32(p) ^ 0x80000000;
80	}
81	static
82	inline int32_t pcm_u24be_to_s32(uint8_t *p)
83	{
84	return pcm_s24be_to_s32(p) ^ 0x80000000;
85	}
86	static
87	inline int32_t pcm_s32le_to_s32(int32_t n)
88	{
89	return m4af_ltoh32(n);
90	}
91	static
92	inline int32_t pcm_s32be_to_s32(int32_t n)
93	{
94	return m4af_btoh32(n);
95	}
96	static
97	inline int32_t pcm_u32le_to_s32(int32_t n)
98	{
99	return m4af_ltoh32(n) ^ 0x80000000;
100	}
101	static
102	inline int32_t pcm_u32be_to_s32(int32_t n)
103	{
104	return m4af_btoh32(n) ^ 0x80000000;
105	}
106	static
107	inline float pcm_f32le_to_f32(int32_t n)
108	{
109	return pcm_i2f(m4af_ltoh32(n));
110	}
111	static
112	inline float pcm_f32be_to_f32(int32_t n)
113	{
114	return pcm_i2f(m4af_btoh32(n));
115	}
116	static
117	inline float pcm_f64le_to_f32(int64_t n)
118	{
119	return pcm_i2d(m4af_ltoh64(n));
120	}
121	static
122	inline float pcm_f64be_to_f32(int64_t n)
123	{
124	return pcm_i2d(m4af_btoh64(n));
125	}
126
127	static
128	int pcm_convert_to_native(const pcm_sample_description_t *format,
129	const void *input, uint32_t nframes,
130	void *result)
131	{
132	#define CONVERT(type, rtype, conv) \
133	do { \
134	unsigned i; \
135	type ip = (type )input; \
136	for (i = 0; i < count; ++i) { \
137	((rtype *)result)[i] = conv(ip[i]); \
138	} \
139	} while(0)
140
141	#define CONVERT_BYTES(rtype, conv) \
142	do { \
143	unsigned i, bytes_per_channel; \
144	uint8_t ip = (uint8_t )input; \
145	bytes_per_channel = PCM_BYTES_PER_CHANNEL(format); \
146	for (i = 0; i < count; ++i) { \
147	((rtype *)result)[i] = conv(ip); \
148	ip += bytes_per_channel; \
149	} \
150	} while(0)
151
152	uint32_t count = nframes * format->channels_per_frame;
153	if (!count)
154	return 0;
155	switch (PCM_BYTES_PER_CHANNEL(format) \| format->sample_type<<4) {
156	case 1 \| PCM_TYPE_SINT<<4:
157	CONVERT(int8_t, int32_t, pcm_s8_to_s32); break;
158	case 1 \| PCM_TYPE_UINT<<4:
159	CONVERT(uint8_t, int32_t, pcm_u8_to_s32); break;
160	case 2 \| PCM_TYPE_SINT<<4:
161	CONVERT(int16_t, int32_t, pcm_s16le_to_s32); break;
162	case 2 \| PCM_TYPE_UINT<<4:
163	CONVERT(uint16_t, int32_t, pcm_u16le_to_s32); break;
164	case 2 \| PCM_TYPE_SINT_BE<<4:
165	CONVERT(int16_t, int32_t, pcm_s16be_to_s32); break;
166	case 2 \| PCM_TYPE_UINT_BE<<4:
167	CONVERT(int16_t, int32_t, pcm_u16be_to_s32); break;
168	case 3 \| PCM_TYPE_SINT<<4:
169	CONVERT_BYTES(int32_t, pcm_s24le_to_s32); break;
170	case 3 \| PCM_TYPE_UINT<<4:
171	CONVERT_BYTES(int32_t, pcm_u24le_to_s32); break;
172	case 3 \| PCM_TYPE_SINT_BE<<4:
173	CONVERT_BYTES(int32_t, pcm_s24be_to_s32); break;
174	case 3 \| PCM_TYPE_UINT_BE<<4:
175	CONVERT_BYTES(int32_t, pcm_u24be_to_s32); break;
176	case 4 \| PCM_TYPE_SINT<<4:
177	CONVERT(int32_t, int32_t, pcm_s32le_to_s32); break;
178	case 4 \| PCM_TYPE_UINT<<4:
179	CONVERT(uint32_t, int32_t, pcm_u32le_to_s32); break;
180	case 4 \| PCM_TYPE_FLOAT<<4:
181	CONVERT(int32_t, float, pcm_f32le_to_f32); break;
182	case 4 \| PCM_TYPE_SINT_BE<<4:
183	CONVERT(int32_t, int32_t, pcm_s32be_to_s32); break;
184	case 4 \| PCM_TYPE_UINT_BE<<4:
185	CONVERT(uint32_t, int32_t, pcm_u32be_to_s32); break;
186	case 4 \| PCM_TYPE_FLOAT_BE<<4:
187	CONVERT(int32_t, float, pcm_f32be_to_f32); break;
188	case 8 \| PCM_TYPE_FLOAT<<4:
189	CONVERT(int64_t, float, pcm_f64le_to_f32); break;
190	case 8 \| PCM_TYPE_FLOAT_BE<<4:
191	CONVERT(int64_t, float, pcm_f64be_to_f32); break;
192	default:
193	return -1;
194	}
195	return 0;
196	}
197
198	typedef struct pcm_native_converter_t {
199	pcm_reader_vtbl_t *vtbl;
200	pcm_reader_t *src;
201	pcm_sample_description_t format;
202	void *pivot;
203	unsigned capacity;
204	} pcm_native_converter_t;
205
206	static inline pcm_reader_t get_source(pcm_reader_t reader)
207	{
208	return ((pcm_native_converter_t *)reader)->src;
209	}
210
211	static const
212	pcm_sample_description_t get_format(pcm_reader_t reader)
213	{
214	return &((pcm_native_converter_t *)reader)->format;
215	}
216
217	static int64_t get_length(pcm_reader_t *reader)
218	{
219	return pcm_get_length(get_source(reader));
220	}
221
222	static int64_t get_position(pcm_reader_t *reader)
223	{
224	return pcm_get_position(get_source(reader));
225	}
226
227	static int read_frames(pcm_reader_t reader, void buffer, unsigned nframes)
228	{
229	pcm_native_converter_t self = (pcm_native_converter_t )reader;
230	const pcm_sample_description_t *sfmt = pcm_get_format(self->src);
231	unsigned bytes = nframes * sfmt->bytes_per_frame;
232
233	if (self->capacity < bytes) {
234	void *p = realloc(self->pivot, bytes);
235	if (!p) return -1;
236	self->pivot = p;
237	self->capacity = bytes;
238	}
239	nframes = pcm_read_frames(self->src, self->pivot, nframes);
240	if (pcm_convert_to_native(sfmt, self->pivot, nframes, buffer) < 0)
241	return -1;
242	return nframes;
243	}
244
245	static void teardown(pcm_reader_t **reader)
246	{
247	pcm_native_converter_t self = (pcm_native_converter_t )*reader;
248	pcm_teardown(&self->src);
249	free(self->pivot);
250	free(self);
251	*reader = 0;
252	}
253
254	static pcm_reader_vtbl_t my_vtable = {
255	get_format, get_length, get_position, read_frames, teardown
256	};
257
258	pcm_reader_t pcm_open_native_converter(pcm_reader_t reader)
259	{
260	pcm_native_converter_t *self = 0;
261	pcm_sample_description_t *fmt;
262
263	if ((self = calloc(1, sizeof(pcm_native_converter_t))) == 0)
264	return 0;
265	self->src = reader;
266	self->vtbl = &my_vtable;
267	memcpy(&self->format, pcm_get_format(reader), sizeof(self->format));
268	fmt = &self->format;
269	fmt->sample_type = PCM_IS_FLOAT(fmt) ? PCM_TYPE_FLOAT : PCM_TYPE_SINT;
270	fmt->bytes_per_frame = 4 * fmt->channels_per_frame;
271	return (pcm_reader_t *)self;
272	}