ref: e51c4bc6e493a9cd0d9e9d7f1d24c57ae77bab65
dir: /sys/src/cmd/audio/mp3enc/pcm.c/
/* -*- mode: C; mode: fold -*- */
/* $Id: pcm.c,v 1.7 2001/02/17 14:30:56 aleidinger Exp $ */
/*
* There are a lot of not tested return codes.
* This is currently intention to make the code more readable
* in the design phase.
* Keine Ber�cksichtigung des Ein- und Ausschwingens des Downsamplefilters am
* Anfang und am Ende wie bei meinem Resample-Programm
*/
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
#include "bitstream.h"
#include "id3tag.h"
#define FN(x) do { static unsigned int cnt = 0; if (cnt < 100000) fprintf (stderr,"[%3u]>>>%s<<<\n",++cnt,(x)), fflush(stderr); } while (0)
#ifdef KLEMM_44
/*{{{ #includes */
#include <assert.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <math.h>
#include <memory.h>
#include <unistd.h>
#include "pcm.h"
/*}}}*/
/*{{{ bitstream object */
/*
* About handling of octetstreams:
*
* CHAR_BIT = 8: data points to a normal memory block which can be written to
* disk via fwrite
* CHAR_BIT > 8: On every char only the bits from 0...7 are used. Depending on the
* host I/O it can be possible that you must first pack the data
* stream before writing to disk/network/...
* CHAR_BIT < 8: Not allowed by C
*/
octetstream_t* octetstream_open ( OUT size_t size )
{
octetstream_t* ret = (octetstream_t*) calloc ( 1, sizeof(octetstream_t) );
FN("octetstream_open");
ret -> data = (uint8_t*) calloc ( 1, size );
ret -> size = size;
return ret;
}
int octetstream_resize ( INOUT octetstream_t* const os, OUT size_t size )
{
FN("octetstream_resize");
if ( size > os->size ) {
os -> data = (uint8_t*) realloc ( os -> data, size );
memset ( os -> data + os -> size, 0, size - os -> size );
os -> size = size;
} else if ( size < os->size ) {
os -> data = (uint8_t*) realloc ( os -> data, os->size = size );
}
return 0;
}
int octetstream_close ( INOUT octetstream_t* const os )
{
FN("octetstream_close");
if ( os == NULL )
return -1;
if ( os -> data != NULL ) {
free (os -> data);
os -> data = NULL;
free (os);
return 0;
} else {
free (os);
return -1;
}
}
/*}}}*/
/*{{{ encode one frame */
static inline int lame_encode_frame (
INOUT lame_t* lame,
OUTTR sample_t** inbuf,
IN uint8_t* mp3buf,
OUT size_t mp3buf_size )
{
int ret;
#if 1
int i;
static int j = 0;
static FILE* fp = NULL;
if ( fp == NULL )
fp = fopen ("pcm_data.txt", "w");
for ( i = 0; i < lame->frame_size; i++ )
fprintf ( fp, "%7d %11.4f %11.4f\n", j++, inbuf[0][i], inbuf[1][i] );
fprintf ( fp, "\n" );
fflush ( fp );
#endif
FN("lame_encode_frame");
switch ( lame -> coding ) {
#ifdef HAVE_MPEG_LAYER1
case coding_MPEG_Layer_1:
ret = lame_encode_mp1_frame ( lame->global_flags, inbuf[0], inbuf[1], mp3buf, mp3buf_size );
break;
#endif
#ifdef HAVE_MPEG_LAYER2
case coding_MPEG_Layer_2:
ret = lame_encode_mp2_frame ( lame->global_flags, inbuf[0], inbuf[1], mp3buf, mp3buf_size );
break;
#endif
case coding_MPEG_Layer_3:
ret = lame_encode_mp3_frame ( lame->global_flags, inbuf[0], inbuf[1], mp3buf, mp3buf_size );
break;
#ifdef HAVE_MPEG_PLUS
case coding_MPEG_plus:
ret = lame_encode_mpp_frame ( lame->global_flags, inbuf[0], inbuf[1], mp3buf, mp3buf_size );
break;
#endif
#ifdef HAVE_AAC
case coding_MPEG_AAC:
ret = lame_encode_aac_frame ( lame->global_flags, inbuf[0], inbuf[1], mp3buf, mp3buf_size );
break;
#endif
#ifdef HAVE_VORBIS
case coding_Ogg_Vorbis:
ret = lame_encode_ogg_frame ( lame->global_flags, inbuf[0], inbuf[1], mp3buf, mp3buf_size );
break;
#endif
default:
ret = -5;
break;
}
if ( ret >= 0 ) {
lame->frame_count++;
if ( lame->analyzer_callback != NULL )
lame->analyzer_callback ( lame, lame->frame_size );
}
return ret;
}
/*}}}*/
/*{{{ demultiplexing tools */
/*
* Now there are following the so called peek functions. They got a pointer and returning
* the data to this pointer as a sample. The size of the memory object can be from
* 8 up to 80 bits. One sample must be fully determined by it's bits, not by the history
* or by other channels or things like that. Also the input must have a integral byte size.
*
* That means:
*
* - 4 or 6 bit PCM can't be decoded
* - APCM can't be decoded
* - ulaw/alaw *can* be decoded
*
* Note: In the future there will be a SMART define supported which only
* support native endian shorts.
*/
static const int16_t ulaw [256] = {
-32124, -31100, -30076, -29052, -28028, -27004, -25980, -24956,
-23932, -22908, -21884, -20860, -19836, -18812, -17788, -16764,
-15996, -15484, -14972, -14460, -13948, -13436, -12924, -12412,
-11900, -11388, -10876, -10364, -9852, -9340, -8828, -8316,
-7932, -7676, -7420, -7164, -6908, -6652, -6396, -6140,
-5884, -5628, -5372, -5116, -4860, -4604, -4348, -4092,
-3900, -3772, -3644, -3516, -3388, -3260, -3132, -3004,
-2876, -2748, -2620, -2492, -2364, -2236, -2108, -1980,
-1884, -1820, -1756, -1692, -1628, -1564, -1500, -1436,
-1372, -1308, -1244, -1180, -1116, -1052, -988, -924,
-876, -844, -812, -780, -748, -716, -684, -652,
-620, -588, -556, -524, -492, -460, -428, -396,
-372, -356, -340, -324, -308, -292, -276, -260,
-244, -228, -212, -196, -180, -164, -148, -132,
-120, -112, -104, -96, -88, -80, -72, -64,
-56, -48, -40, -32, -24, -16, -8, 0,
32124, 31100, 30076, 29052, 28028, 27004, 25980, 24956,
23932, 22908, 21884, 20860, 19836, 18812, 17788, 16764,
15996, 15484, 14972, 14460, 13948, 13436, 12924, 12412,
11900, 11388, 10876, 10364, 9852, 9340, 8828, 8316,
7932, 7676, 7420, 7164, 6908, 6652, 6396, 6140,
5884, 5628, 5372, 5116, 4860, 4604, 4348, 4092,
3900, 3772, 3644, 3516, 3388, 3260, 3132, 3004,
2876, 2748, 2620, 2492, 2364, 2236, 2108, 1980,
1884, 1820, 1756, 1692, 1628, 1564, 1500, 1436,
1372, 1308, 1244, 1180, 1116, 1052, 988, 924,
876, 844, 812, 780, 748, 716, 684, 652,
620, 588, 556, 524, 492, 460, 428, 396,
372, 356, 340, 324, 308, 292, 276, 260,
244, 228, 212, 196, 180, 164, 148, 132,
120, 112, 104, 96, 88, 80, 72, 64,
56, 48, 40, 32, 24, 16, 8, 0,
};
static const int16_t alaw [256] = {
-5504, -5248, -6016, -5760, -4480, -4224, -4992, -4736,
-7552, -7296, -8064, -7808, -6528, -6272, -7040, -6784,
-2752, -2624, -3008, -2880, -2240, -2112, -2496, -2368,
-3776, -3648, -4032, -3904, -3264, -3136, -3520, -3392,
-22016, -20992, -24064, -23040, -17920, -16896, -19968, -18944,
-30208, -29184, -32256, -31232, -26112, -25088, -28160, -27136,
-11008, -10496, -12032, -11520, -8960, -8448, -9984, -9472,
-15104, -14592, -16128, -15616, -13056, -12544, -14080, -13568,
-344, -328, -376, -360, -280, -264, -312, -296,
-472, -456, -504, -488, -408, -392, -440, -424,
-88, -72, -120, -104, -24, -8, -56, -40,
-216, -200, -248, -232, -152, -136, -184, -168,
-1376, -1312, -1504, -1440, -1120, -1056, -1248, -1184,
-1888, -1824, -2016, -1952, -1632, -1568, -1760, -1696,
-688, -656, -752, -720, -560, -528, -624, -592,
-944, -912, -1008, -976, -816, -784, -880, -848,
5504, 5248, 6016, 5760, 4480, 4224, 4992, 4736,
7552, 7296, 8064, 7808, 6528, 6272, 7040, 6784,
2752, 2624, 3008, 2880, 2240, 2112, 2496, 2368,
3776, 3648, 4032, 3904, 3264, 3136, 3520, 3392,
22016, 20992, 24064, 23040, 17920, 16896, 19968, 18944,
30208, 29184, 32256, 31232, 26112, 25088, 28160, 27136,
11008, 10496, 12032, 11520, 8960, 8448, 9984, 9472,
15104, 14592, 16128, 15616, 13056, 12544, 14080, 13568,
344, 328, 376, 360, 280, 264, 312, 296,
472, 456, 504, 488, 408, 392, 440, 424,
88, 72, 120, 104, 24, 8, 56, 40,
216, 200, 248, 232, 152, 136, 184, 168,
1376, 1312, 1504, 1440, 1120, 1056, 1248, 1184,
1888, 1824, 2016, 1952, 1632, 1568, 1760, 1696,
688, 656, 752, 720, 560, 528, 624, 592,
944, 912, 1008, 976, 816, 784, 880, 848,
};
/*
* These macros get 1...4 bytes and calculating a value between -32768 and +32768.
* The first argument of the macros is the MSB, the last the LSB.
* These are used to decode integer PCM (if there is no faster code available).
*/
#define BYTES1(x1) ((((int8_t)(x1)) << 8))
#define BYTES2(x1,x2) ((((int8_t)(x1)) << 8) + (uint8_t)(x2))
#define BYTES3(x1,x2,x3) ((((int8_t)(x1)) << 8) + (uint8_t)(x2) + 1/256.*(uint8_t)(x3))
#define BYTES4(x1,x2,x3,x4) ((((int8_t)(x1)) << 8) + (uint8_t)(x2) + 1/256.*(uint8_t)(x3) + 1/65536.*(uint8_t)(x4))
/*
* The next two functions can read a 32 and 64 bit floating pointer number
* of an opposite byte order machine. This is done by byte swaping and using
* the normal way to read such a variable.
* Also note: peek function got their data from a variable called src, which is a pointer
* to const unsigned char.
*/
static inline sample_t read_opposite_float32 ( OUT uint8_t* const src )
{
uint8_t tmp [4];
tmp[0] = src[3];
tmp[1] = src[2];
tmp[2] = src[1];
tmp[3] = src[0];
return *(const float32_t*)tmp;
}
static inline sample_t read_opposite_float64 ( OUT uint8_t* const src )
{
uint8_t tmp [8];
tmp[0] = src[7];
tmp[1] = src[6];
tmp[2] = src[5];
tmp[3] = src[4];
tmp[4] = src[3];
tmp[5] = src[2];
tmp[6] = src[1];
tmp[7] = src[0];
return *(const float64_t*)tmp;
}
/*
* The next two functions can read a 80 bit extended precision
* IEEE-854 floating point number. This code also can read the numbers
* on a machine not supporting 80 bit floats.
*/
static sample_t read_float80_le ( OUT uint8_t* const src )
{
int sign = src [9] & 128 ? -1 : +1;
long exponent =(src [9] & 127) * 256 +
src [8] - 16384 - 62;
long double mantisse = src [7] * 72057594037927936.L +
src [6] * 281474976710656.L +
src [5] * 1099511627776.L +
src [4] * 4294967296.L +
src [3] * 16777216.L +
src [2] * 65536.L +
src [1] * 256.L +
src [0];
return sign * ldexp (mantisse, exponent);
}
static sample_t read_float80_be ( OUT uint8_t* const src )
{
int sign = src [0] & 128 ? -1 : +1;
long exponent =(src [0] & 127) * 256 +
src [1] - 16384 - 62;
long double mantisse = src [2] * 72057594037927936.L +
src [3] * 281474976710656.L +
src [4] * 1099511627776.L +
src [5] * 4294967296.L +
src [6] * 16777216.L +
src [7] * 65536.L +
src [8] * 256.L +
src [9];
return sign * ldexp (mantisse, exponent);
}
static inline sample_t read_opposite_float80 ( OUT uint8_t* const src )
{
uint8_t tmp [10];
tmp[0] = src[9];
tmp[1] = src[8];
tmp[2] = src[7];
tmp[3] = src[6];
tmp[4] = src[5];
tmp[5] = src[4];
tmp[6] = src[3];
tmp[7] = src[2];
tmp[8] = src[1];
tmp[9] = src[0];
return *(const float80_t*)tmp;
}
/*
* Now we are building all resorting functions. The macro wants the name of the function
* and a peek function or macro. The created function wants the following input:
*
* destination: Where to store the result as sample_t vector? The distance between
* the elements is sizeof(sample_t)
* source: Where to get the bytes which should converted to destination
* step size: The distance between the input samples. This is at least the size
* of one input element, but can be more due to
* - alignment
* - interleaved multi-channel input
* length: The number of elements to process. Number must be positive.
*/
typedef void (*demux_t) ( IN sample_t* dst, OUT uint8_t* src, OUT ssize_t step, OUT size_t len );
#define FUNCTION(name,expr) \
static void name ( \
IN sample_t* dst, \
OUT uint8_t* src, \
OUT ssize_t step, \
OUT size_t len ) \
{ \
size_t i = len; \
do { \
*dst++ = (expr); \
src += (step); \
} while (--i); \
}
/* Some of these function can be implemented byte order independent ... */
FUNCTION ( copy_silence, 0 )
FUNCTION ( copy_u8 , BYTES1 (src[0]-128) )
FUNCTION ( copy_s8 , BYTES1 (src[0] ) )
FUNCTION ( copy_alaw , alaw[*src] )
FUNCTION ( copy_ulaw , ulaw[*src] )
FUNCTION ( copy_s24_le , BYTES3 (src[2], src[1], src[0] ) )
FUNCTION ( copy_s24_be , BYTES3 (src[0], src[1], src[2] ) )
FUNCTION ( copy_u24_le , BYTES3 (src[2]-128, src[1], src[0] ) )
FUNCTION ( copy_u24_be , BYTES3 (src[0]-128, src[1], src[2] ) )
FUNCTION ( copy_f80_le , read_float80_le (src) )
FUNCTION ( copy_f80_be , read_float80_be (src) )
/* ... and some are not or there are faster but byte order dependent possiblities */
#ifndef WORDS_BIGENDIAN
/* little endian */
FUNCTION ( copy_s16_le , *(const int16_t*)src )
FUNCTION ( copy_s16_be , BYTES2 (src[0], src[1] ) )
FUNCTION ( copy_u16_le , *(const uint16_t*)src - 32768 )
FUNCTION ( copy_u16_be , BYTES2 (src[0]-128, src[1] ) )
FUNCTION ( copy_s32_le , 1/65536. * *(const int32_t*)src )
FUNCTION ( copy_s32_be , BYTES4 (src[0], src[1], src[2], src[3] ) )
FUNCTION ( copy_u32_le , 1/65536. * *(const uint32_t*)src - 32768. )
FUNCTION ( copy_u32_be , BYTES4 (src[0]-128, src[1], src[2], src[3] ) )
FUNCTION ( copy_f32_le , *(const float32_t*)src )
FUNCTION ( copy_f32_be , read_opposite_float32 (src) )
FUNCTION ( copy_f64_le , *(const float64_t*)src )
FUNCTION ( copy_f64_be , read_opposite_float64 (src) )
#else
/* big endian */
FUNCTION ( copy_s16_le , BYTES2 (src[1], src[0] ) )
FUNCTION ( copy_s16_be , *(const int16_t*)src )
FUNCTION ( copy_u16_le , BYTES2 (src[1]-128, src[0] ) )
FUNCTION ( copy_u16_be , *(const uint16_t*)src - 32768 )
FUNCTION ( copy_s32_le , BYTES4 (src[3], src[2], src[1], src[0] ) )
FUNCTION ( copy_s32_be , 1/65536. * *(const int32_t*)src )
FUNCTION ( copy_u32_le , BYTES4 (src[3]-128, src[2], src[1], src[0] ) )
FUNCTION ( copy_u32_be , 1/65536. * *(const uint32_t*)src - 32768. )
FUNCTION ( copy_f32_le , read_opposite_float32 (src) )
FUNCTION ( copy_f32_be , *(const float32_t*)src )
FUNCTION ( copy_f64_le , read_opposite_float64 (src) )
FUNCTION ( copy_f64_be , *(const float64_t*)src )
#endif
/*
* The global collection of channel demultiplexer.
* For every data type we have the size of one memory object and two
* demultiplexer, one for big endians, one for little endians.
* The demultiplexers
* - 1st argument is the destination of the data converted to sample_t (and normalized to +/-32768)
* - 2nd argument is a pointer to the source data, in any format
* - 3rd argument is 1st argument of the table (multiplied by the channel count in the case of
* interleaved data)
* - 4th argument is the count of samples per channel to convert
*/
typedef struct {
const ssize_t size;
const demux_t demultiplexer_be;
const demux_t demultiplexer_le;
} demux_info_t;
const demux_info_t demux_info [] = {
{ -1, NULL , NULL }, /* 00: */
{ 0, copy_silence, copy_silence }, /* 01: */
{ 1, copy_u8 , copy_u8 }, /* 02: */
{ 1, copy_s8 , copy_s8 }, /* 03: */
{ 2, copy_u16_be , copy_u16_le }, /* 04: */
{ 2, copy_s16_be , copy_s16_le }, /* 05: */
{ 3, copy_u24_be , copy_u24_le }, /* 06: */
{ 3, copy_s24_be , copy_s24_le }, /* 07: */
{ 4, copy_u32_be , copy_u32_le }, /* 08: */
{ 4, copy_s32_be , copy_s32_le }, /* 09: */
{ -1, NULL , NULL }, /* 0A: */
{ -1, NULL , NULL }, /* 0B: */
{ -1, NULL , NULL }, /* 0C: */
{ -1, NULL , NULL }, /* 0D: */
{ -1, NULL , NULL }, /* 0E: */
{ -1, NULL , NULL }, /* 0F: */
{ -1, NULL , NULL }, /* 10: */
{ -1, NULL , NULL }, /* 11: */
{ -1, NULL , NULL }, /* 12: */
{ -1, NULL , NULL }, /* 13: */
{ 4, copy_f32_be , copy_f32_le }, /* 14: */
{ -1, NULL , NULL }, /* 15: */
{ -1, NULL , NULL }, /* 16: */
{ -1, NULL , NULL }, /* 17: */
{ 8, copy_f64_be , copy_f64_le }, /* 18: */
{ -1, NULL , NULL }, /* 19: */
{ 10, copy_f80_be , copy_f80_le }, /* 1A: */
{ -1, NULL , NULL }, /* 1B: */
{ 12, copy_f80_be , copy_f80_le }, /* 1C: */
{ -1, NULL , NULL }, /* 1D: */
{ -1, NULL , NULL }, /* 1E: */
{ -1, NULL , NULL }, /* 1F: */
{ 16, copy_f80_be , copy_f80_le }, /* 20: */
{ sizeof(short) , NULL , NULL }, /* 21: */
{ sizeof(int) , NULL , NULL }, /* 22: */
{ sizeof(long) , NULL , NULL }, /* 23: */
{ sizeof(float) , copy_f32_be , copy_f32_le }, /* 24: */
{ sizeof(double) , copy_f64_be , copy_f64_le }, /* 25: */
{ sizeof(long double), NULL , NULL }, /* 26: */
{ -1, NULL , NULL }, /* 27: */
{ -1, NULL , NULL }, /* 28: */
{ -1, NULL , NULL }, /* 29: */
{ -1, NULL , NULL }, /* 2A: */
{ -1, NULL , NULL }, /* 2B: */
{ -1, NULL , NULL }, /* 2C: */
{ -1, NULL , NULL }, /* 2D: */
{ -1, NULL , NULL }, /* 2E: */
{ -1, NULL , NULL }, /* 2F: */
{ -1, NULL , NULL }, /* 30: */
{ 1, copy_alaw , copy_alaw }, /* 31: */
{ 1, copy_ulaw , copy_ulaw }, /* 32: */
{ -1, NULL , NULL }, /* 33: */
{ -1, NULL , NULL }, /* 34: */
{ -1, NULL , NULL }, /* 35: */
{ -1, NULL , NULL }, /* 36: */
{ -1, NULL , NULL }, /* 37: */
{ -1, NULL , NULL }, /* 38: */
{ -1, NULL , NULL }, /* 39: */
{ -1, NULL , NULL }, /* 3A: */
{ -1, NULL , NULL }, /* 3B: */
{ -1, NULL , NULL }, /* 3C: */
{ -1, NULL , NULL }, /* 3D: */
{ -1, NULL , NULL }, /* 3E: */
{ -1, NULL , NULL }, /* 3F: */
};
/*
* Selects the right demultiplexer from the attribute field
* (currently endian and type information is used, rest is done in
* lame_encode_pcm)
*/
static inline int select_demux ( OUT uint32_t mode, IN demux_t* retf, IN ssize_t* size )
{
int big = mode >> 24;
const demux_info_t* tabptr = demux_info + ((mode >> 16) & 0x3F);
FN("select_demux");
#ifdef WORDS_BIGENDIAN
/* big endian */
big = (big >> 1) ^ big ^ 1; // 0=big, 1=little, 2=little, 3=big
#else
/* little endian */ // 0=little, 1=big, 2=little, 3=big
#endif
*size = tabptr -> size;
*retf = big & 1 ? tabptr -> demultiplexer_be
: tabptr -> demultiplexer_le;
return *retf != NULL ? 0 : -1;
}
/*}}}*/
/*{{{ amplify/resample stuff */
/*
* routine to feed EXACTLY one frame (lame->frame_size) worth of data to the
* encoding engine. All buffering, resampling, etc, handled by calling program.
*/
static inline int internal_lame_encoding_pcm (
INOUT lame_t* const lame,
INOUT octetstream_t* const os,
OUT sample_t* const * const data,
OUT size_t len )
{
size_t i;
double ampl;
double dampl;
int ampl_on;
size_t ch;
size_t mf_needed;
int ret;
size_t n_in;
size_t n_out;
size_t remaining = len;
sample_t* mfbuf [MAX_CHANNELS];
const sample_t* pdata [MAX_CHANNELS];
FN("internal_lame_encoding_pcm");
/// this should be moved to lame_init_params();
// some sanity checks
#if ENCDELAY < MDCTDELAY
# error ENCDELAY is less than MDCTDELAY, see <encoder.h>
#endif
#if FFTOFFSET > BLKSIZE
# error FFTOFFSET is greater than BLKSIZE, see <encoder.h>
#endif
mf_needed = BLKSIZE + lame->frame_size - FFTOFFSET; // amount needed for FFT
mf_needed = MAX ( mf_needed, 286 + 576 * (1+lame->mode_gr) ); // amount needed for MDCT/filterbank
assert ( mf_needed <= MFSIZE );
///
os -> length = 0;
pdata [0] = data [0];
pdata [1] = data [1];
mfbuf [0] = lame->mfbuf [0];
mfbuf [1] = lame->mfbuf [1];
ampl = lame->last_ampl;
dampl = 0.;
if ( lame->ampl != ampl ) {
if (remaining <= 1) { // constant amplification
ampl_on = 1;
} else { // fading
ampl_on = 2;
dampl = (lame->ampl - ampl) / remaining * lame->sampfreq_out / lame->sampfreq_in;
}
lame->last_ampl = lame->ampl;
} else if ( lame->ampl != 1. ) { // constant amplification
ampl_on = 1;
} else { // no manipulation (fastest)
ampl_on = 0;
}
while ( (int) remaining > 0 ) {
FN("internal_lame_encoding_pcm 3");
/* copy in new samples into mfbuf, with resampling if necessary */
if ( lame->resample_in != NULL ) {
FN("internal_lame_encoding_pcm 10");
for ( ch = 0; ch < lame->channels_out; ch++ ) {
n_in = remaining;
n_out = lame->frame_size;
FN("internal_lame_encoding_pcm 12");
// resample filter virtually should have no delay !
ret = resample_buffer (
lame->resample_in,
mfbuf [ch] + lame->mf_size, &n_out,
pdata [ch] , &n_in,
ch );
if ( ret < 0 )
return ret;
pdata [ch] += n_in;
}
FN("internal_lame_encoding_pcm 13");
}
else {
FN("internal_lame_encoding_pcm 14");
n_in = n_out = MIN ( lame->frame_size, remaining );
FN("internal_lame_encoding_pcm 15");
for ( ch = 0; ch < lame->channels_out; ch++ ) {
memcpy ( mfbuf [ch] + lame->mf_size,
pdata [ch],
n_out * sizeof (**mfbuf) );
pdata [ch] += n_in;
}
FN("internal_lame_encoding_pcm 16");
}
FN("internal_lame_encoding_pcm 4");
switch ( ampl_on ) {
case 0:
break;
case 1:
for ( ch = 0; ch < lame->channels_out; ch++ )
for ( i = 0; i < n_out; i++ )
mfbuf [ch] [lame->mf_size + i] *= ampl;
break;
case 2:
for ( i = 0; i < n_out; i++, ampl += dampl )
for ( ch = 0; ch < lame->channels_out; ch++ )
mfbuf [ch] [lame->mf_size + i] *= ampl;
break;
default:
assert (0);
break;
}
FN("internal_lame_encoding_pcm 4");
fprintf ( stderr, "n_in=%d, n_out=%d, remaining=%d, remaining=%d\n", n_in, n_out, remaining, remaining-n_in );
remaining -= n_in;
lame->mf_size += n_out;
lame->mf_samples_to_encode += n_out;
// encode ONE frame if enough data available
if ( lame->mf_size >= mf_needed ) {
// Enlarge octetstream buffer if (possibly) needed by (25% + 16K)
if ( os->size < 16384 + os->length )
octetstream_resize ( os, os->size + os->size/4 + 16384 );
// Encode one frame
ret = lame_encode_frame ( lame, mfbuf,
os->data + os->length, os->size - os->length );
if (ret < 0)
return ret;
os->length += ret;
FN("internal_lame_encoding_pcm 5");
// shift out old samples
lame->mf_size -= lame->frame_size;
lame->mf_samples_to_encode -= lame->frame_size;
for ( ch = 0; ch < lame->channels_out; ch++ )
memmove ( mfbuf [ch] + 0, mfbuf [ch] + lame->frame_size, lame->mf_size * sizeof (**mfbuf) );
FN("internal_lame_encoding_pcm 6");
}
}
assert (remaining == 0);
return 0;
}
/*}}}*/
/*{{{ demultiplexing stuff */
static inline void average ( sample_t* dst, const sample_t* src1, const sample_t* src2, size_t len )
{
FN("average");
while (len--)
*dst++ = (*src1++ + *src2++) * 0.5;
}
int lame_encode_pcm (
lame_t* const lame,
octetstream_t* os,
const void* pcm,
size_t len,
uint32_t flags )
{
sample_t* data [2];
demux_t retf;
ssize_t size;
const uint8_t* p;
const uint8_t* const* q;
int ret;
size_t channels_in = flags & 0xFFFF;
FN("lame_encode_pcm");
if (len == 0)
return 0;
if (select_demux ( flags, &retf, &size ) < 0)
return -1;
data[0] = (sample_t*) calloc (sizeof(sample_t), len);
data[1] = (sample_t*) calloc (sizeof(sample_t), len);
switch (flags >> 28) {
case LAME_INTERLEAVED >> 28:
p = (const uint8_t*) pcm;
switch ( lame->channels_out ) {
case 1:
switch ( channels_in ) {
case 1:
retf ( data[0], p+0*size, 1*size, len );
break;
case 2:
retf ( data[0], p+0*size, 2*size, len );
retf ( data[1], p+1*size, 2*size, len );
average ( data[0], data[0], data[1], len );
memset ( data[1], 0, sizeof(sample_t)*len );
break;
default:
return -1;
break;
}
break;
case 2:
switch ( channels_in ) {
case 1:
retf ( data[0], p+0*size, 1*size, len );
memcpy ( data[1], data[0], sizeof(sample_t)*len );
break;
case 2:
retf ( data[0], p+0*size, 2*size, len );
retf ( data[1], p+1*size, 2*size, len );
break;
default:
return -1;
break;
}
break;
default:
return -1;
}
break;
case LAME_CHAINED >> 28:
p = (const uint8_t*) pcm;
switch ( lame->channels_out ) {
case 1:
switch ( channels_in ) {
case 1:
retf ( data[0], p+0*size*len, size, len );
break;
case 2:
retf ( data[0], p+0*size*len, size, len );
retf ( data[1], p+1*size*len, size, len );
average ( data[0], data[0], data[1], len );
memset ( data[1], 0, sizeof(sample_t)*len );
break;
default:
return -1;
break;
}
break;
case 2:
switch ( channels_in ) {
case 1:
retf ( data[0], p+0*size*len, size, len );
memcpy ( data[1], data[0], sizeof(sample_t)*len );
break;
case 2:
retf ( data[0], p+0*size*len, size, len );
retf ( data[1], p+1*size*len, size, len );
break;
default:
return -1;
break;
}
break;
default:
return -1;
}
break;
case LAME_INDIRECT >> 28:
q = (const uint8_t* const*) pcm;
switch ( lame->channels_out ) {
case 1:
switch ( channels_in ) {
case 1:
retf ( data[0], q[0], size, len );
break;
case 2:
retf ( data[0], q[0], size, len );
retf ( data[1], q[1], size, len );
average ( data[0], data[0], data[1], len );
memset ( data[1], 0, sizeof(sample_t)*len );
break;
default:
return -1;
break;
}
break;
case 2:
switch ( channels_in ) {
case 1:
retf ( data[0], q[0], size, len );
memcpy ( data[1], data[0], sizeof(sample_t)*len );
break;
case 2:
retf ( data[0], q[0], size, len );
retf ( data[1], q[1], size, len );
break;
default:
return -1;
break;
}
break;
default:
return -1;
}
break;
default:
return -1;
}
ret = internal_lame_encoding_pcm ( lame, os, (sample_t const* const*) data, len );
free ( data[0] );
free ( data[1] );
return ret;
}
/*}}}*/
/*{{{ lame_encode_pcm_flush */
int lame_encode_pcm_flush (
lame_t* const lame,
octetstream_t* const os )
{
int ret;
int ret_cb;
FN("lame_encode_pcm_flush");
ret = lame_encode_pcm ( lame, os, NULL,
lame->mf_samples_to_encode + lame->frame_size,
LAME_INTERLEAVED | LAME_SILENCE | 1 );
// ugly, not encapsulated
flush_bitstream (lame -> global_flags); // mp3 related stuff. bit buffer might still contain some mp3 data
id3tag_write_v1 (lame -> global_flags); // write a ID3 tag to the bitstream
ret_cb = copy_buffer (os->data, os->size - os->length, &lame->bs);
if (ret_cb < 0)
return ret_cb;
os->length += ret_cb;
return ret;
}
/*
* Data flow
* ~~~~~~~~~
* lame_encode_buffer (public)
* lame_encode_buffer_interleaved (public)
* - do some little preparations and calls lame_encode_pcm
* lame_encode_pcm (public)
* - demultiplexing
* - type converting
* - endian handling
* - alignment handling
* - channel number converting (currently averaging or duplicating)
* internal_lame_encoding_pcm
* - resampling
* - level attenuator/amplifier, fader
* - divide input into frames
* - merge encoded data to one stream
* - does a lot of things which should be done in the setup
* lame_encode_frame
* - calls the right next stage encoder
* - counts the number of encoded frames
* - analyzer call back
* lame_encode_???_frame
* - out of the scope of this file
*/
/*}}}*/
/*{{{ Legacy stuff */
static lame_t* pointer2lame ( void* const handle )
{
lame_t* lame = (lame_t*)handle;
lame_global_flags* gfp = (lame_global_flags*)handle;
FN("pointer2lame");
if ( lame == NULL )
return NULL;
if ( lame->Class_ID == LAME_ID )
return lame;
if ( gfp->num_channels == 1 || gfp->num_channels == 2 ) {
lame = (lame_t*) (gfp->internal_flags);
if ( lame == NULL )
return NULL;
if ( lame->Class_ID == LAME_ID )
return lame;
}
return NULL;
}
int lame_encode_buffer (
void* const gfp,
const int16_t buffer_l [],
const int16_t buffer_r [],
const size_t nsamples,
void* const mp3buf,
const size_t mp3buf_size )
{
const int16_t* pcm [2];
octetstream_t* os;
int ret;
lame_t* lame;
FN("lame_encode_buffer");
lame = pointer2lame (gfp);
os = octetstream_open (mp3buf_size);
pcm [0] = buffer_l;
pcm [1] = buffer_r;
ret = lame_encode_pcm ( lame, os, pcm, nsamples,
LAME_INDIRECT | LAME_NATIVE_ENDIAN | LAME_INT16 |
lame->channels_in );
memcpy ( mp3buf, os->data, os->length );
if (ret == 0) ret = os->length;
octetstream_close (os);
return ret;
}
int lame_encode_buffer_interleaved (
void* const gfp,
const int16_t buffer [],
size_t nsamples,
void* const mp3buf,
const size_t mp3buf_size )
{
octetstream_t* os;
int ret;
lame_t* lame;
FN("lame_encode_buffer_interleaved");
lame = pointer2lame (gfp);
os = octetstream_open (mp3buf_size);
ret = lame_encode_pcm ( lame, os, buffer, nsamples,
LAME_INTERLEAVED | LAME_NATIVE_ENDIAN | LAME_INT16 |
lame->channels_in );
memcpy ( mp3buf, os->data, os->length );
if (ret == 0) ret = os->length;
octetstream_close (os);
return ret;
}
int lame_encode_flush (
void* const gfp,
void* const mp3buf,
const size_t mp3buf_size )
{
octetstream_t* os;
int ret;
lame_t* lame;
FN("lame_encode_flush");
lame = pointer2lame (gfp);
os = octetstream_open (mp3buf_size);
ret = lame_encode_pcm_flush ( lame, os );
memcpy ( mp3buf, os->data, os->length );
if (ret == 0) ret = os->length;
octetstream_close (os);
return ret;
}
/*}}}*/
/*{{{ sin/cos/sinc/rounding functions */
static inline long round_nearest ( long double x )
{
if ( x >= 0. )
return (long)(x+0.5);
else
return (long)(x-0.5);
}
static inline long round_down ( long double x )
{
if ( x >= 0. )
return +(long)(+x);
else
return -(long)(-x);
}
static inline long double sinpi ( long double x )
{
x -= round_down (x) & ~1;
switch ( (int)(4.*x) ) {
default: assert (0);
case 0: return +SIN ( M_PIl * (0.0+x) );
case 1: return +COS ( M_PIl * (0.5-x) );
case 2: return +COS ( M_PIl * (x-0.5) );
case 3: return +SIN ( M_PIl * (1.0-x) );
case 4: return -SIN ( M_PIl * (x-1.0) );
case 5: return -COS ( M_PIl * (1.5-x) );
case 6: return -COS ( M_PIl * (x-1.5) );
case 7: return -SIN ( M_PIl * (2.0-x) );
}
}
static inline long double cospi ( long double x )
{
x -= round_down (x) & ~1;
switch ( (int)(4.*x) ) {
default: assert (0);
case 0: return +COS ( M_PIl * (x-0.0) );
case 1: return +SIN ( M_PIl * (0.5-x) );
case 2: return -SIN ( M_PIl * (x-0.5) );
case 3: return -COS ( M_PIl * (1.0-x) );
case 4: return -COS ( M_PIl * (x-1.0) );
case 5: return -SIN ( M_PIl * (1.5-x) );
case 6: return +SIN ( M_PIl * (x-1.5) );
case 7: return +COS ( M_PIl * (2.0-x) );
}
}
static inline long double sinc ( long double x )
{
if ( x == 0. )
return 1.;
if ( x < 0. )
x = -x;
return sinpi ( x ) / ( M_PIl * x );
}
/*}}}*/
/*{{{ some window functions */
static inline double hanning ( double x )
{
if ( fabs (x) >= 1 )
return 0.;
x = cospi (0.5 * x);
return x * x;
}
static inline double hamming ( double x )
{
if ( fabs (x) >= 1 )
return 0.;
x = cospi (x);
return 0.54 + 0.46 * x;
}
static inline double blackman ( double x )
{
if ( fabs (x) >= 1 )
return 0.;
x = cospi (x);
return (0.16 * x + 0.50) * x + 0.34; // using addition theorem of arc functions
}
static inline double blackman1 ( double x )
{
if ( fabs (x) >= 1 )
return 0.;
x += 1.;
return 0.42 - 0.50*cospi(x) + 0.08*cospi(2*x);
}
static inline double blackman2 ( double x )
{
if ( fabs (x) >= 1 )
return 0.;
x += 1.;
return 0.375 - 0.50*cospi(x) + 0.125*cospi(2*x);
}
static inline double blackmanharris_nuttall ( double x )
{
if ( fabs (x) >= 1 )
return 0.;
x += 1.;
return (10 - 15*cospi (x) + 6*cospi (2*x) - cospi (3*x) ) * (1./32);
}
static inline double blackmanharris_min4 ( double x )
{
if ( fabs (x) >= 1 )
return 0.;
x += 1.;
return 0.355768 - 0.487396*cospi (x) + 0.144232*cospi (2*x) - 0.012604*cospi (3*x);
}
/*
* Blackman-Harris windows, which have the general equation:
*
* w(n) = a0 - a1 cos(2pn/N) + a2 cos(4pn/N) - a3 cos(6pn/N).
*
* When Nuttall set the ak coefficients to the "minimum 4-term" values of a0 = 0.355768, a1 =
* 0.487396, a2 = 0.144232, and a3 = 0.012604, he obtained the window and the frequency
* response shown in Figure 8. The minimum-4-term window loses some frequency
* resolution because it has a wide main lobe, but the first side lobe drops to -93 db.
*
* If you require fast side-lobe rolloff in an application, consider Nuttall's Equation (30). It
* applies the following coefficients to the general equation above: a0 = 10/32, a1 = 15/32, a2 =
* 6/32, and a3 = 1/32. Figure 8 also includes the window and frequency response for Nuttall's
* Equation (30). This window has a first side-lobe level of -61 dB and a significant side-lobe
* rolloff of -42 dB/octave.
*
* The first investigators of windowing functions determined that window functions should
* have zero values at their boundaries and so should their successive derivatives. If a
* window's kth derivative is zero at the boundaries, the peaks of the window's side lobes will
* decay at a rate of 6(k+2) dB/octave. T&MW.
*/
/*}}}*/
/*{{{ scalar stuff */
/**********************************************************
* *
* Functions taken from scalar.nas *
* *
**********************************************************/
/*
* The scalarxx versions with xx=04,08,12,16,20,24 are fixed size for xx element scalars
* The scalar1n version is suitable for every non negative length
* The scalar4n version is only suitable for positive lengths which are a multiple of 4
*
* The following are equivalent:
* scalar12 (p, q);
* scalar4n (p, q, 3);
* scalar1n (p, q, 12);
*/
float_t scalar04_float32 ( const sample_t* p, const sample_t* q )
{
return p[0]*q[0] + p[1]*q[1] + p[2]*q[2] + p[3]*q[3];
}
float_t scalar08_float32 ( const sample_t* p, const sample_t* q )
{
return p[0]*q[0] + p[1]*q[1] + p[2]*q[2] + p[3]*q[3]
+ p[4]*q[4] + p[5]*q[5] + p[6]*q[6] + p[7]*q[7];
}
float_t scalar12_float32 ( const sample_t* p, const sample_t* q )
{
return p[0]*q[0] + p[1]*q[1] + p[ 2]*q[ 2] + p[ 3]*q[ 3]
+ p[4]*q[4] + p[5]*q[5] + p[ 6]*q[ 6] + p[ 7]*q[ 7]
+ p[8]*q[8] + p[9]*q[9] + p[10]*q[10] + p[11]*q[11];
}
float_t scalar16_float32 ( const sample_t* p, const sample_t* q )
{
return p[ 0]*q[ 0] + p[ 1]*q[ 1] + p[ 2]*q[ 2] + p[ 3]*q[ 3]
+ p[ 4]*q[ 4] + p[ 5]*q[ 5] + p[ 6]*q[ 6] + p[ 7]*q[ 7]
+ p[ 8]*q[ 8] + p[ 9]*q[ 9] + p[10]*q[10] + p[11]*q[11]
+ p[12]*q[12] + p[13]*q[13] + p[14]*q[14] + p[15]*q[15];
}
float_t scalar20_float32 ( const sample_t* p, const sample_t* q )
{
return p[ 0]*q[ 0] + p[ 1]*q[ 1] + p[ 2]*q[ 2] + p[ 3]*q[ 3]
+ p[ 4]*q[ 4] + p[ 5]*q[ 5] + p[ 6]*q[ 6] + p[ 7]*q[ 7]
+ p[ 8]*q[ 8] + p[ 9]*q[ 9] + p[10]*q[10] + p[11]*q[11]
+ p[12]*q[12] + p[13]*q[13] + p[14]*q[14] + p[15]*q[15]
+ p[16]*q[16] + p[17]*q[17] + p[18]*q[18] + p[19]*q[19];
}
float_t scalar24_float32 ( const sample_t* p, const sample_t* q )
{
return p[ 0]*q[ 0] + p[ 1]*q[ 1] + p[ 2]*q[ 2] + p[ 3]*q[ 3]
+ p[ 4]*q[ 4] + p[ 5]*q[ 5] + p[ 6]*q[ 6] + p[ 7]*q[ 7]
+ p[ 8]*q[ 8] + p[ 9]*q[ 9] + p[10]*q[10] + p[11]*q[11]
+ p[12]*q[12] + p[13]*q[13] + p[14]*q[14] + p[15]*q[15]
+ p[16]*q[16] + p[17]*q[17] + p[18]*q[18] + p[19]*q[19]
+ p[20]*q[20] + p[21]*q[21] + p[22]*q[22] + p[23]*q[23];
}
float_t scalar32_float32 ( const sample_t* p, const sample_t* q )
{
return p[ 0]*q[ 0] + p[ 1]*q[ 1] + p[ 2]*q[ 2] + p[ 3]*q[ 3]
+ p[ 4]*q[ 4] + p[ 5]*q[ 5] + p[ 6]*q[ 6] + p[ 7]*q[ 7]
+ p[ 8]*q[ 8] + p[ 9]*q[ 9] + p[10]*q[10] + p[11]*q[11]
+ p[12]*q[12] + p[13]*q[13] + p[14]*q[14] + p[15]*q[15]
+ p[16]*q[16] + p[17]*q[17] + p[18]*q[18] + p[19]*q[19]
+ p[20]*q[20] + p[21]*q[21] + p[22]*q[22] + p[23]*q[23]
+ p[24]*q[24] + p[25]*q[25] + p[26]*q[26] + p[27]*q[27]
+ p[28]*q[28] + p[29]*q[29] + p[30]*q[30] + p[31]*q[31];
}
float_t scalar4n_float32 ( const sample_t* p, const sample_t* q, size_t len )
{
double sum = p[0]*q[0] + p[1]*q[1] + p[2]*q[2] + p[3]*q[3];
while (--len) {
p += 4;
q += 4;
sum += p[0]*q[0] + p[1]*q[1] + p[2]*q[2] + p[3]*q[3];
}
return sum;
}
float_t scalar1n_float32 ( const sample_t* p, const sample_t* q, size_t len )
{
float_t sum;
switch (len & 3) {
case 0:
sum = 0.;
break;
case 1:
sum = p[0]*q[0];
p += 1;
q += 1;
break;
case 2:
sum = p[0]*q[0] + p[1]*q[1];
p += 2;
q += 2;
break;
default:
sum = p[0]*q[0] + p[1]*q[1] + p[2]*q[2];
p += 3;
q += 3;
break;
}
for ( len >>= 2; len--; ) {
sum += p[0]*q[0] + p[1]*q[1] + p[2]*q[2] + p[3]*q[3];
p += 4;
q += 4;
}
return sum;
}
scalar_t scalar04 = scalar04_float32;
scalar_t scalar08 = scalar08_float32;
scalar_t scalar12 = scalar12_float32;
scalar_t scalar16 = scalar16_float32;
scalar_t scalar20 = scalar20_float32;
scalar_t scalar24 = scalar24_float32;
scalar_t scalar32 = scalar32_float32;
scalarn_t scalar4n = scalar4n_float32;
scalarn_t scalar1n = scalar1n_float32;
void init_scalar_functions ( OUT lame_t* const lame )
{
if ( lame -> CPU_features.i387 ) {
scalar04 = scalar04_float32_i387;
scalar08 = scalar08_float32_i387;
scalar12 = scalar12_float32_i387;
scalar16 = scalar16_float32_i387;
scalar20 = scalar20_float32_i387;
scalar24 = scalar24_float32_i387;
scalar32 = scalar32_float32_i387;
scalar4n = scalar4n_float32_i387;
scalar1n = scalar1n_float32_i387;
}
if ( lame -> CPU_features.AMD_3DNow ) {
scalar04 = scalar04_float32_3DNow;
scalar08 = scalar08_float32_3DNow;
scalar12 = scalar12_float32_3DNow;
scalar16 = scalar16_float32_3DNow;
scalar20 = scalar20_float32_3DNow;
scalar24 = scalar24_float32_3DNow;
scalar32 = scalar32_float32_3DNow;
scalar4n = scalar4n_float32_3DNow;
scalar1n = scalar1n_float32_3DNow;
}
if ( lame -> CPU_features.SIMD ) {
scalar04 = scalar04_float32_SIMD;
scalar08 = scalar08_float32_SIMD;
scalar12 = scalar12_float32_SIMD;
scalar16 = scalar16_float32_SIMD;
scalar20 = scalar20_float32_SIMD;
scalar24 = scalar24_float32_SIMD;
scalar32 = scalar32_float32_SIMD;
scalar4n = scalar4n_float32_SIMD;
scalar1n = scalar1n_float32_SIMD;
}
}
/*}}}*/
/*{{{ factorize */
/*
* Tries to find the best integral ratio for two sampling frequencies
* It searches the best ratio a:b with b <= MAX_TABLES
*/
static double factorize (
OUT long double f1,
OUT long double f2,
IN int* const x1,
IN int* const x2 )
{
unsigned i;
long ltmp;
long double ftmp;
double minerror = 1.;
double abserror = 1.;
assert ( f1 > 0. );
assert ( f2 > 0. );
assert ( x1 != NULL );
assert ( x2 != NULL );
for ( i = 1; i <= MAX_TABLES; i++ ) {
ftmp = f2 * i / f1;
ltmp = (long) ( ftmp + 0.5 );
if ( fabs ( (ltmp-ftmp)/ftmp ) < minerror ) {
*x1 = i;
*x2 = (int)ltmp;
abserror = (ltmp-ftmp) / ftmp;
minerror = 0.9999847412109375 * fabs (abserror);
}
}
return abserror;
}
/*
* Some programmers and some file format only supporting integral sampling frequencies
* This patch tries to find the right sampling frequency for some know rounding victims.
* Better is to support directly 64 or 80 bit FPU precision.
*/
long double unround_samplefrequency ( OUT long double freq )
{
if ( freq != (unsigned short)freq )
return freq;
switch ( (unsigned short)freq ) {
case 48662: case 48663: return 1411200/ 29.L; // SB 128 "48 kHz" 48662.06896551724137931034
case 44055: case 44056: return 2863636/ 65.L; // NTSC PCM/LD PCM 44055.93846153846153846153
case 32072: case 32073: return 1411200/ 44.L; // SB 128 "32 kHz" 32072.72727272727272727272
case 31468: case 31469: return 2863636/ 91.L; // NTSC Hi8 Digital Audio 31468.52747252747252747252
case 23918: case 23919: return 1411200/ 59.L; // SB 128 "24 kHz" 23918.64406779661016949152
case 22254: case 22255: return 244800/ 11.L; // MAC HQ 22254.54545454545454545454
case 16036: case 16037: return 1411200/ 88.L; // SB 128 "16 kHz" 16036.36363636363636363636
case 11959: case 11960: return 1411200/118.L; // SB 128 "12 kHz" 11959.32203389830508474576
case 11127: case 11128: return 122400/ 11.L; // MAC LQ 11127.27272727272727272727
case 8018: case 8019: return 1411200/176.L; // SB 128 "8 kHz" 8018.18181818181818181818
case 8012: case 8013: return 312500/ 39.L; // NeXT/Telco 8012.82051282051282051282
case 5512: case 5513: return 44100/ 8.L; // 1/8 CD 5512.50000000000000000000
}
return freq;
}
/*}}}*/
/*{{{ resampling stuff */
static inline void Calc_Coeffs (
IN sample_t* Coeff,
OUT int iNew,
OUT int iOld,
OUT long i,
OUT long k,
OUT double bandwidth ) // 0.0 ... 1.0: used bandwidth from 0...fs_out/2
{
long double w = 1.L / (WINDOW_SIZE + 0.5);
long double sum = 0.;
long double tmp1;
long double tmp2;
long j;
for ( j = 0; j <= 2*WINDOW_SIZE; j++ ) {
tmp1 = ((k+j)*iNew - i*iOld) / (long double)iNew * bandwidth;
tmp2 = ((k+j)*iNew - i*iOld) / (long double)iNew;
sum += Coeff [j] = sinc (tmp1) * WINDOW (tmp2 * w);
}
for ( j = 0; j <= 2*WINDOW_SIZE; j++ )
Coeff [j] /= sum;
}
resample_t* resample_open (
OUT long double sampfreq_in, // [Hz]
OUT long double sampfreq_out, // [Hz]
OUT double lowpass_freq, // [Hz] or <0 for auto mode
OUT int quality ) // Proposal: 0: default, 1: sample select, 2: linear interpolation
// 4: 4-point interpolation, 32: 32-point interpolation
{
resample_t* const ret = calloc ( sizeof(resample_t), 1 );
long i;
sample_t* p;
double err;
FN("resample_open");
if ( sampfreq_in == sampfreq_out )
return NULL;
err = factorize ( sampfreq_out, sampfreq_in, &(ret->scale_out), &(ret->scale_in) );
fprintf ( stderr, "(%.6g => %.6g Hz, Ratio %d:%d",
(double)sampfreq_in, (double)sampfreq_out, ret->scale_in, ret->scale_out );
if ( fabs (err) > 5.e-10 ) // 16 msec/year
fprintf ( stderr, ", Error %+.3f ppm", 1.e6*err );
fprintf ( stderr, ")\n" );
fflush ( stderr );
if ( ret->scale_out == ret->scale_in )
return NULL;
ret->Class_ID = RESAMPLE_ID;
ret->samplefreq_in = sampfreq_in;
ret->samplefreq_out = sampfreq_out;
ret->taps = TAPS;
ret->lowpass_freq = lowpass_freq < 0. ? 0.50 * MIN (sampfreq_in, sampfreq_out) : lowpass_freq;
ret->in_old [0] = calloc ( sizeof(sample_t*) , 2*TAPS );
ret->in_old [1] = calloc ( sizeof(sample_t*) , 2*TAPS );
ret->src_step = calloc ( sizeof(unsigned char*), (unsigned)ret->scale_out );
ret->fir = calloc ( sizeof(sample_t*) , (unsigned)ret->scale_out );
ret->firfree = calloc ( sizeof(sample_t) , TAPS * ret->scale_out + 64/sizeof(sample_t) );
p = (sample_t*) ( ((ptrdiff_t)(ret->firfree) | 63) + 1 ); /* 64 byte alignment */
for ( i = 0; i < ret->scale_out; i++, p += TAPS ) {
ret->src_step [i] = round_nearest ( (i+1.L) * ret->scale_in / ret->scale_out )
- round_nearest ( (i+0.L) * ret->scale_in / ret->scale_out );
Calc_Coeffs ( ret->fir [i] = p,
ret->scale_out, ret->scale_in,
i, round_nearest ( (double)i * ret->scale_in / ret->scale_out - WINDOW_SIZE ),
2.*ret->lowpass_freq / sampfreq_out );
}
return ret;
}
/* Should be done with more sanity checks */
int resample_close ( INOUT resample_t* const r )
{
FN("resample_close");
if ( r == NULL )
return -1;
free ( r->in_old [0] );
free ( r->in_old [1] );
free ( r->fir [0] );
free ( r->fir );
free ( r->src_step );
return 0;
}
// in the future some of the copies should be avoided by usage of mfbuf
// also by the fill_buffer_resample() routine
/*
* Current working scheme:
*
* | old | new data in in_buf, consist of old *and new data
* |0 1 2|3 4 5 6 ...
*
* <--1-->
* <--2-->
* <--3-->
*
* | new data in in, only new data
* |0 1 2 3 4 5 6
* <--4-->
* <--5-->
* <--6-->
*/
int resample_buffer ( // return code, 0 for success
INOUT resample_t *const r, // internal structure
IN sample_t *const out, // where to write the output data
INOUT size_t *const out_req_len, // requested output data len/really written output data len
OUT sample_t *const in, // where are the input data?
INOUT size_t *const in_avail_len, // available input data len/consumed input data len
OUT size_t channel ) // number of the channel (needed for internal buffering)
{
sample_t* p = out;
sample_t* in_old = r->in_old [channel];
size_t len = *in_avail_len;
size_t desired_len = *out_req_len;
size_t i;
size_t k;
int l;
FN("resample_buffer");
// copy TAPS samples to the second half of in_old
memcpy ( in_old + TAPS, in, MIN (len*sizeof(*in), TAPS*sizeof(*in)) );
// calculating k and l
l = r->fir_stepper [channel];
k = r->inp_stepper [channel];
// doing converting for all samples which can be done in 'in_old'
for ( i = 0; i < desired_len && k < TAPS; i++ ) {
*p++ = scalar32 ( in_old + k, r->fir [l] );
k += r->src_step [l];
if ( ++l >= r->scale_out ) l = 0;
}
// doing converting for all samples which can be done in 'in'
k -= TAPS;
for ( ; i < desired_len && k < len - TAPS; i++ ) {
*p++ = scalar32 ( in + k, r->fir [l] );
k += r->src_step [l];
if ( ++l >= r->scale_out ) l = 0;
}
// writing back processed in and out
*in_avail_len = k - r->inp_stepper [channel];
*out_req_len = p - out;
r->fir_stepper [channel] = l;
r->inp_stepper [channel] = k - r->inp_stepper [channel] - len;
// make of copy of the overlap
if ( len >= TAPS )
memcpy ( in_old, in + len - TAPS, TAPS*sizeof(sample_t) );
else
memmove ( in_old, in_old + len , TAPS*sizeof(sample_t) );
return 0;
}
/*}}}*/
#endif /* KLEMM_44 */
/* end of pcm.c */