From 66f4e56389d97b61a4a17325201643ef6bd87e37 Mon Sep 17 00:00:00 2001 From: anders Date: Tue, 12 Nov 2002 12:33:56 +0000 Subject: New features: -- Support for runtime cpu detection -- Stand alone compile of libaf -- Unlimited number of channels (compiletime switch) -- Sample format defined by bit-fields -- New formats: float, A-Law and mu-law -- Format conversion set in human readable format i.e. format=4:us_be to set 32 bit unsigned big endian output -- Format reporting in human readable format -- Volume control has only one parameter for setting the volume i.e. volume=-10.0:1:0:1 to set atenuation = -10dB git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8168 b3059339-0415-0410-9bf9-f77b7e298cf2 --- libaf/Makefile | 4 +- libaf/af.c | 124 ++++---- libaf/af.h | 65 +++- libaf/af_channels.c | 9 +- libaf/af_delay.c | 9 +- libaf/af_dummy.c | 7 +- libaf/af_equalizer.c | 19 +- libaf/af_format.c | 557 ++++++++++++++++++++------------ libaf/af_format.h | 32 ++ libaf/af_format_alaw.c | 315 ++++++++++++++++++ libaf/af_format_ulaw.c | 828 ++++++++++++++++++++++++++++++++++++++++++++++++ libaf/af_mp.c | 41 +++ libaf/af_mp.h | 26 ++ libaf/af_resample.c | 19 +- libaf/af_volume.c | 75 ++--- libaf/config.h | 15 + libmpcodecs/dec_audio.c | 6 +- 17 files changed, 1799 insertions(+), 352 deletions(-) create mode 100644 libaf/af_format.h create mode 100644 libaf/af_format_alaw.c create mode 100644 libaf/af_format_ulaw.c create mode 100644 libaf/af_mp.c create mode 100644 libaf/af_mp.h create mode 100644 libaf/config.h diff --git a/libaf/Makefile b/libaf/Makefile index 381d9fcf1b..05aac6d3cb 100644 --- a/libaf/Makefile +++ b/libaf/Makefile @@ -2,7 +2,7 @@ include ../config.mak LIBNAME = libaf.a -SRCS=af.c af_dummy.c af_delay.c af_channels.c af_format.c af_resample.c window.c filter.c af_volume.c af_equalizer.c +SRCS=af.c af_mp.c af_dummy.c af_delay.c af_channels.c af_format.c af_resample.c window.c filter.c af_volume.c af_equalizer.c OBJS=$(SRCS:.c=.o) @@ -15,7 +15,7 @@ CFLAGS = $(OPTFLAGS) -I. -Wall $(LIBNAME): $(OBJS) Makefile $(AR) r $(LIBNAME) $(OBJS) -$(OBJS):af.h control.h dsp.h filter.h window.h +$(OBJS):af.h control.h dsp.h filter.h window.h af_mp.h all: $(LIBNAME) diff --git a/libaf/af.c b/libaf/af.c index 63cb692bad..5216c6dcdb 100644 --- a/libaf/af.c +++ b/libaf/af.c @@ -6,9 +6,6 @@ #include #endif -#include "../config.h" -#include "../mp_msg.h" - #include "af.h" // Static list of filters @@ -31,6 +28,12 @@ static af_info_t* filter_list[]={ \ NULL \ }; +// Message printing +af_msg_cfg_t af_msg_cfg={0,NULL,NULL}; + +// CPU speed +int* af_cpu_speed = NULL; + /* Find a filter in the static list of filters using it's name. This function is used internally */ af_info_t* af_find(char*name) @@ -41,7 +44,7 @@ af_info_t* af_find(char*name) return filter_list[i]; i++; } - mp_msg(MSGT_AFILTER,MSGL_ERR,"Couldn't find audio filter '%s'\n",name); + af_msg(AF_MSG_ERROR,"Couldn't find audio filter '%s'\n",name); return NULL; } @@ -69,7 +72,7 @@ af_instance_t* af_create(af_stream_t* s, char* name) // Allocate space for the new filter and reset all pointers af_instance_t* new=malloc(sizeof(af_instance_t)); if(!new){ - mp_msg(MSGT_AFILTER,MSGL_ERR,"Could not allocate memory\n"); + af_msg(AF_MSG_ERROR,"Could not allocate memory\n"); return NULL; } memset(new,0,sizeof(af_instance_t)); @@ -85,13 +88,13 @@ af_instance_t* af_create(af_stream_t* s, char* name) non-reentrant */ if(new->info->flags & AF_FLAGS_NOT_REENTRANT){ if(af_get(s,name)){ - mp_msg(MSGT_AFILTER,MSGL_ERR,"There can only be one instance of the filter '%s' in each stream\n",name); + af_msg(AF_MSG_ERROR,"There can only be one instance of the filter '%s' in each stream\n",name); free(new); return NULL; } } - mp_msg(MSGT_AFILTER,MSGL_V,"Adding filter %s \n",name); + af_msg(AF_MSG_VERBOSE,"Adding filter %s \n",name); // Initialize the new filter if(AF_OK == new->info->open(new) && @@ -105,7 +108,7 @@ af_instance_t* af_create(af_stream_t* s, char* name) } free(new); - mp_msg(MSGT_AFILTER,MSGL_ERR,"Couldn't create or open audio filter '%s'\n",name); + af_msg(AF_MSG_ERROR,"Couldn't create or open audio filter '%s'\n",name); return NULL; } @@ -206,56 +209,62 @@ int af_reinit(af_stream_t* s, af_instance_t* af) case AF_OK: break; case AF_FALSE:{ // Configuration filter is needed - af_instance_t* new = NULL; - // Insert channels filter - if((af->prev?af->prev->data->nch:s->input.nch) != in.nch){ - // Create channels filter - if(NULL == (new = af_prepend(s,af,"channels"))) - return AF_ERROR; - // Set number of output channels - if(AF_OK != (rv = new->control(new,AF_CONTROL_CHANNELS,&in.nch))) - return rv; - // Initialize channels filter - if(!new->prev) - memcpy(&in,&(s->input),sizeof(af_data_t)); - else - memcpy(&in,new->prev->data,sizeof(af_data_t)); - if(AF_OK != (rv = new->control(new,AF_CONTROL_REINIT,&in))) - return rv; - } - // Insert format filter - if(((af->prev?af->prev->data->format:s->input.format) != in.format) || - ((af->prev?af->prev->data->bps:s->input.bps) != in.bps)){ - // Create format filter - if(NULL == (new = af_prepend(s,af,"format"))) + // Do auto insertion only if force is not specified + if((AF_INIT_TYPE_MASK & s->cfg.force) != AF_INIT_FORCE){ + af_instance_t* new = NULL; + // Insert channels filter + if((af->prev?af->prev->data->nch:s->input.nch) != in.nch){ + // Create channels filter + if(NULL == (new = af_prepend(s,af,"channels"))) + return AF_ERROR; + // Set number of output channels + if(AF_OK != (rv = new->control(new,AF_CONTROL_CHANNELS,&in.nch))) + return rv; + // Initialize channels filter + if(!new->prev) + memcpy(&in,&(s->input),sizeof(af_data_t)); + else + memcpy(&in,new->prev->data,sizeof(af_data_t)); + if(AF_OK != (rv = new->control(new,AF_CONTROL_REINIT,&in))) + return rv; + } + // Insert format filter + if(((af->prev?af->prev->data->format:s->input.format) != in.format) || + ((af->prev?af->prev->data->bps:s->input.bps) != in.bps)){ + // Create format filter + if(NULL == (new = af_prepend(s,af,"format"))) + return AF_ERROR; + // Set output format + if(AF_OK != (rv = new->control(new,AF_CONTROL_FORMAT,&in))) + return rv; + // Initialize format filter + if(!new->prev) + memcpy(&in,&(s->input),sizeof(af_data_t)); + else + memcpy(&in,new->prev->data,sizeof(af_data_t)); + if(AF_OK != (rv = new->control(new,AF_CONTROL_REINIT,&in))) + return rv; + } + if(!new) // Should _never_ happen return AF_ERROR; - // Set output format - if(AF_OK != (rv = new->control(new,AF_CONTROL_FORMAT,&in))) - return rv; - // Initialize format filter - if(!new->prev) - memcpy(&in,&(s->input),sizeof(af_data_t)); - else - memcpy(&in,new->prev->data,sizeof(af_data_t)); - if(AF_OK != (rv = new->control(new,AF_CONTROL_REINIT,&in))) - return rv; + af=new; } - if(!new) // Should _never_ happen - return AF_ERROR; - af=new; break; } case AF_DETACH:{ // Filter is redundant and wants to be unloaded - af_instance_t* aft=af->prev; - af_remove(s,af); - if(aft) - af=aft; - else - af=s->first; // Restart configuration + // Do auto remove only if force is not specified + if((AF_INIT_TYPE_MASK & s->cfg.force) != AF_INIT_FORCE){ + af_instance_t* aft=af->prev; + af_remove(s,af); + if(aft) + af=aft; + else + af=s->first; // Restart configuration + } break; } default: - mp_msg(MSGT_AFILTER,MSGL_ERR,"Reinitialization did not work, audio filter '%s' returned error code %i\n",af->info->name,rv); + af_msg(AF_MSG_ERROR,"Reinitialization did not work, audio filter '%s' returned error code %i\n",af->info->name,rv); return AF_ERROR; } af=af->next; @@ -289,13 +298,8 @@ int af_init(af_stream_t* s) s->input.len = s->output.len = 0; // Figure out how fast the machine is - if(AF_INIT_AUTO == (AF_INIT_TYPE_MASK & s->cfg.force)){ -# if defined(HAVE_SSE) || defined(HAVE_3DNOWEX) - s->cfg.force = (s->cfg.force & ~AF_INIT_TYPE_MASK) | AF_INIT_FAST; -# else - s->cfg.force = (s->cfg.force & ~AF_INIT_TYPE_MASK) | AF_INIT_SLOW; -# endif - } + if(AF_INIT_AUTO == (AF_INIT_TYPE_MASK & s->cfg.force)) + s->cfg.force = (s->cfg.force & ~AF_INIT_TYPE_MASK) | AF_INIT_TYPE; // Check if this is the first call if(!s->first){ @@ -379,7 +383,7 @@ int af_init(af_stream_t* s) (s->last->data->nch != s->output.nch) || (s->last->data->rate != s->output.rate)) { // Something is stuffed audio out will not work - mp_msg(MSGT_AFILTER,MSGL_ERR,"Unable to setup filter system can not meet sound-card demands, please report this error on MPlayer development mailing list. \n"); + af_msg(AF_MSG_ERROR,"Unable to setup filter system can not meet sound-card demands, please report this error on MPlayer development mailing list. \n"); af_uninit(s); return -1; } @@ -527,14 +531,14 @@ inline int af_resize_local_buffer(af_instance_t* af, af_data_t* data) { // Calculate new length register int len = af_lencalc(af->mul,data); - mp_msg(MSGT_AFILTER,MSGL_V,"Reallocating memory in module %s, old len = %i, new len = %i\n",af->info->name,af->data->len,len); + af_msg(AF_MSG_VERBOSE,"Reallocating memory in module %s, old len = %i, new len = %i\n",af->info->name,af->data->len,len); // If there is a buffer free it if(af->data->audio) free(af->data->audio); // Create new buffer and check that it is OK af->data->audio = malloc(len); if(!af->data->audio){ - mp_msg(MSGT_AFILTER,MSGL_ERR,"Could not allocate memory \n"); + af_msg(AF_MSG_FATAL,"Could not allocate memory \n"); return AF_ERROR; } af->data->len=len; diff --git a/libaf/af.h b/libaf/af.h index 82a065ac95..33d0b271d4 100644 --- a/libaf/af.h +++ b/libaf/af.h @@ -1,4 +1,9 @@ +#include + +#include "config.h" #include "control.h" +#include "af_format.h" +#include "af_mp.h" #ifndef __aop_h__ #define __aop_h__ @@ -23,7 +28,7 @@ typedef struct frac_s int d; // Denominator } frac_t; -// Flags used for defining the behavour of an audio filter +// Flags used for defining the behavior of an audio filter #define AF_FLAGS_REENTRANT 0x00000000 #define AF_FLAGS_NOT_REENTRANT 0x00000001 @@ -56,16 +61,27 @@ typedef struct af_instance_s }af_instance_t; // Initialization flags +extern int* af_cpu_speed; + #define AF_INIT_AUTO 0x00000000 #define AF_INIT_SLOW 0x00000001 #define AF_INIT_FAST 0x00000002 #define AF_INIT_FORCE 0x00000003 #define AF_INIT_TYPE_MASK 0x00000003 +// Default init type +#ifndef AF_INIT_TYPE +#if defined(HAVE_SSE) || defined(HAVE_3DNOW) +#define AF_INIT_TYPE (af_cpu_speed?*af_cpu_speed:AF_INIT_FAST) +#else +#define AF_INIT_TYPE (af_cpu_speed?*af_cpu_speed:AF_INIT_SLOW) +#endif +#endif + // Configuration switches typedef struct af_cfg_s{ int force; // Initialization type - char** list; /* list of names of plugins that are added to filter + char** list; /* list of names of filters that are added to filter list during first initialization of stream */ }af_cfg_t; @@ -78,7 +94,7 @@ typedef struct af_stream_s // Storage for input and output data formats af_data_t input; af_data_t output; - // Cofiguration for this stream + // Configuration for this stream af_cfg_t cfg; }af_stream_t; @@ -92,7 +108,7 @@ typedef struct af_stream_s #define AF_FALSE 0 #define AF_UNKNOWN -1 #define AF_ERROR -2 -#define AF_NA -3 +#define AF_FATAL -3 @@ -100,12 +116,12 @@ typedef struct af_stream_s // Export functions */ -/* Initialize the stream "s". This function creates a new fileterlist - if nessesary according to the values set in input and output. Input +/* Initialize the stream "s". This function creates a new filter list + if necessary according to the values set in input and output. Input and output should contain the format of the current movie and the formate of the preferred output respectively. The function is - reentreant i.e. if called wit an already initialized stream the - stream will be reinitialized. The return value is 0 if sucess and + reentrant i.e. if called wit an already initialized stream the + stream will be reinitialized. The return value is 0 if success and -1 if failure */ int af_init(af_stream_t* s); @@ -187,8 +203,37 @@ int af_lencalc(frac_t mul, af_data_t* data); #define sign(a) (((a)>0)?(1):(-1)) #endif -#ifndef lround -#define lround(a,b) ((b)((a)>=0.0?(a)+0.5:(a)-0.5)) +#ifndef lrnd +#define lrnd(a,b) ((b)((a)>=0.0?(a)+0.5:(a)-0.5)) #endif +/* Error messages */ + +typedef struct af_msg_cfg_s +{ + int level; /* Message level for debug and error messages max = 2 + min = -2 default = 0 */ + FILE* err; // Stream to print error messages to + FILE* msg; // Stream to print information messages to +}af_msg_cfg_t; + +extern af_msg_cfg_t af_msg_cfg; // Message + +#define AF_MSG_FATAL -3 // Fatal error exit immediately +#define AF_MSG_ERROR -2 // Error return gracefully +#define AF_MSG_WARN -1 // Print warning but do not exit (can be suppressed) +#define AF_MSG_INFO 0 // Important information +#define AF_MSG_VERBOSE 1 // Print this if verbose is enabled +#define AF_MSG_DEBUG0 2 // Print if very verbose +#define AF_MSG_DEBUG1 3 // Print if very very verbose + +/* Macro for printing error messages */ +#ifndef af_msg +#define af_msg(lev, args... ) \ +((lev #include -#include "../config.h" -#include "../mp_msg.h" - #include "af.h" // Local function for copying data @@ -70,7 +67,7 @@ void copy(void* in, void* out, int ins, int inos,int outs, int outos, int len, i break; } default: - mp_msg(MSGT_AFILTER,MSGL_ERR,"[channels] Unsupported number of bytes/sample: %i please report this error on the MPlayer mailing list. \n",bps); + af_msg(AF_MSG_ERROR,"[channels] Unsupported number of bytes/sample: %i please report this error on the MPlayer mailing list. \n",bps); } } @@ -99,12 +96,12 @@ static int control(struct af_instance_s* af, int cmd, void* arg) // Sanity check if(((int*)arg)[0] <= 0 || ((int*)arg)[0] > 6){ - mp_msg(MSGT_AFILTER,MSGL_ERR,"[channels] The number of output channels must be between 1 and 6. Current value is%i \n",((int*)arg)[0]); + af_msg(AF_MSG_ERROR,"[channels] The number of output channels must be between 1 and 6. Current value is%i \n",((int*)arg)[0]); return AF_ERROR; } af->data->nch=((int*)arg)[0]; - mp_msg(MSGT_AFILTER,MSGL_V,"[channels] Changing number of channels to %i\n",af->data->nch); + af_msg(AF_MSG_VERBOSE,"[channels] Changing number of channels to %i\n",af->data->nch); return AF_OK; } return AF_UNKNOWN; diff --git a/libaf/af_delay.c b/libaf/af_delay.c index 08c33499a8..f19dc1934b 100644 --- a/libaf/af_delay.c +++ b/libaf/af_delay.c @@ -7,9 +7,6 @@ #include #include -#include "../config.h" -#include "../mp_msg.h" - #include "af.h" // Data for specific instances of this filter @@ -43,7 +40,7 @@ static int control(struct af_instance_s* af, int cmd, void* arg) int lt = s->len; // Old len if(*((float*)arg) > 30 || *((float*)arg) < 0){ - mp_msg(MSGT_AFILTER,MSGL_ERR,"Error setting delay length in af_delay. Delay must be between 0s and 30s\n"); + af_msg(AF_MSG_ERROR,"Error setting delay length in af_delay. Delay must be between 0s and 30s\n"); s->len=0; s->tlen=0.0; af->delay=0.0; @@ -55,8 +52,8 @@ static int control(struct af_instance_s* af, int cmd, void* arg) af->delay = s->tlen * 1000.0; s->len = af->data->rate*af->data->bps*af->data->nch*(int)s->tlen; s->buf = malloc(s->len); - mp_msg(MSGT_AFILTER,MSGL_DBG2,"[delay] Delaying audio output by %0.2fs\n",s->tlen); - mp_msg(MSGT_AFILTER,MSGL_DBG3,"[delay] Delaying audio output by %i bytes\n",s->len); + af_msg(AF_MSG_DEBUG0,"[delay] Delaying audio output by %0.2fs\n",s->tlen); + af_msg(AF_MSG_DEBUG1,"[delay] Delaying audio output by %i bytes\n",s->len); // Out of memory error if(!s->buf){ diff --git a/libaf/af_dummy.c b/libaf/af_dummy.c index fa4b721028..ca9f56bc55 100644 --- a/libaf/af_dummy.c +++ b/libaf/af_dummy.c @@ -4,9 +4,6 @@ #include #include -#include "../config.h" -#include "../mp_msg.h" - #include "af.h" // Initialization and runtime control @@ -15,7 +12,7 @@ static int control(struct af_instance_s* af, int cmd, void* arg) switch(cmd){ case AF_CONTROL_REINIT: memcpy(af->data,(af_data_t*)arg,sizeof(af_data_t)); - mp_msg(MSGT_AFILTER,MSGL_V,"[dummy] Was reinitialized, rate=%iHz, nch = %i, format = 0x%08X and bps = %i\n",af->data->rate,af->data->nch,af->data->format,af->data->bps); + af_msg(AF_MSG_VERBOSE,"[dummy] Was reinitialized, rate=%iHz, nch = %i, format = 0x%08X and bps = %i\n",af->data->rate,af->data->nch,af->data->format,af->data->bps); return AF_OK; } return AF_UNKNOWN; @@ -33,7 +30,7 @@ static af_data_t* play(struct af_instance_s* af, af_data_t* data) { // Do something necessary to get rid of annoying warning during compile if(!af) - printf("EEEK: Argument af == NULL in af_dummy.c play()."); + af_msg(AF_MSG_ERROR,"EEEK: Argument af == NULL in af_dummy.c play()."); return data; } diff --git a/libaf/af_equalizer.c b/libaf/af_equalizer.c index 8b6129df54..d33e84d47f 100644 --- a/libaf/af_equalizer.c +++ b/libaf/af_equalizer.c @@ -21,16 +21,12 @@ #include #include -#include "../config.h" -#include "../mp_msg.h" -#include "../libao2/afmt.h" - #include "af.h" #include "equalizer.h" -#define NCH 6 // Max number of channels -#define L 2 // Storage for filter taps -#define KM 10 // Max number of bands +#define NCH AF_NCH // Number of channels +#define L 2 // Storage for filter taps +#define KM 10 // Max number of bands #define Q 1.2247449 /* Q value for band-pass filters 1.2247=(3/2)^(1/2) gives 4dB suppression @ Fc*2 and Fc/2 */ @@ -80,13 +76,16 @@ static int control(struct af_instance_s* af, int cmd, void* arg) af->data->rate = ((af_data_t*)arg)->rate; af->data->nch = ((af_data_t*)arg)->nch; - af->data->format = AFMT_S16_LE; + af->data->format = AF_FORMAT_NE | AF_FORMAT_SI; af->data->bps = 2; // Calculate number of active filters s->K=KM; - while(F[s->K-1] > (float)af->data->rate/2.0) + while(F[s->K-1] > (float)af->data->rate/2.2) s->K--; + + if(s->K != KM) + af_msg(AF_MSG_INFO,"Limiting the number of filters to %i due to low sample rate.\n",s->K); // Generate filter taps for(k=0;kK;k++) @@ -95,7 +94,7 @@ static int control(struct af_instance_s* af, int cmd, void* arg) // Calculate how much this plugin adds to the overall time delay af->delay += 2000.0/((float)af->data->rate); - // Only AFMT_S16_LE is supported + // Only signed 16 bit little endian is supported if(af->data->format != ((af_data_t*)arg)->format || af->data->bps != ((af_data_t*)arg)->bps) return AF_FALSE; diff --git a/libaf/af_format.c b/libaf/af_format.c index d9ca5fd7e7..fb6e6d79f5 100644 --- a/libaf/af_format.c +++ b/libaf/af_format.c @@ -10,105 +10,184 @@ #include #include -#include "../config.h" -#include "../mp_msg.h" +#include "af.h" -#include "../libao2/afmt.h" -#include "af.h" +/* Functions used by play to convert the input audio to the correct + format */ + +/* The below includes retrives functions for converting to and from + ulaw and alaw */ +#include "af_format_ulaw.c" +#include "af_format_alaw.c" + +// Switch endianess +static void endian(void* in, void* out, int len, int bps); +// From singed to unsigned +static void si2us(void* in, void* out, int len, int bps); +// From unsinged to signed +static void us2si(void* in, void* out, int len, int bps); +// Change the number of bits per sample +static void change_bps(void* in, void* out, int len, int inbps, int outbps); +// From float to int signed +static void float2int(void* in, void* out, int len, int bps); +// From signed int to float +static void int2float(void* in, void* out, int len, int bps); + +// Convert from string to format +static int str2fmt(char* str) +{ + int format=0; + // Scan for endianess + if(strstr(str,"be") || strstr(str,"BE")) + format |= AF_FORMAT_BE; + else if(strstr(str,"le") || strstr(str,"LE")) + format |= AF_FORMAT_LE; + else + format |= AF_FORMAT_NE; + + // Scan for special formats + if(strstr(str,"mulaw") || strstr(str,"MULAW")){ + format |= AF_FORMAT_MU_LAW; return format; + } + if(strstr(str,"alaw") || strstr(str,"ALAW")){ + format |= AF_FORMAT_A_LAW; return format; + } + if(strstr(str,"ac3") || strstr(str,"AC3")){ + format |= AF_FORMAT_AC3; return format; + } + if(strstr(str,"mpeg2") || strstr(str,"MPEG2")){ + format |= AF_FORMAT_MPEG2; return format; + } + if(strstr(str,"imaadpcm") || strstr(str,"IMAADPCM")){ + format |= AF_FORMAT_IMA_ADPCM; return format; + } + + // Scan for int/float + if(strstr(str,"float") || strstr(str,"FLOAT")){ + format |= AF_FORMAT_F; return format; + } + else + format |= AF_FORMAT_I; + + // Scan for signed/unsigned + if(strstr(str,"unsigned") || strstr(str,"UNSIGNED")) + format |= AF_FORMAT_US; + else + format |= AF_FORMAT_SI; + + return format; +} -// Number of bits -#define B08 (0<<0) -#define B16 (1<<0) -#define B32 (2<<0) -#define NBITS_MASK (3<<0) - -// Endianess -#define BE (0<<2) // Big Endian -#define LE (1<<2) // Little Endian -#define END_MASK (1<<2) - -#if WORDS_BIGENDIAN // native endian of cpu -#define NE BE -#else -#define NE LE -#endif - -// Signed -#define US (0<<3) // Un Signed -#define SI (1<<3) // SIgned -#define SIGN_MASK (1<<3) - -int decode(int format) +/* Convert format to str input str is a buffer for the + converted string, size is the size of the buffer */ +static char* fmt2str(int format, char* str, size_t size) { - // Check input format - switch(format){ - case(AFMT_U8): - return LE|B08|US; - case(AFMT_S8): - return LE|B08|SI; break; - case(AFMT_S16_LE): - return LE|B16|SI; break; - case(AFMT_S16_BE): - return BE|B16|SI; break; - case(AFMT_U16_LE): - return LE|B16|US; break; - case(AFMT_U16_BE): - return BE|B16|US; break; - case(AFMT_S32_LE): - return LE|B32|SI; break; - case(AFMT_S32_BE): - return BE|B32|SI; break; - case(AFMT_IMA_ADPCM): - case(AFMT_MU_LAW): - case(AFMT_A_LAW): - case(AFMT_MPEG): - case(AFMT_AC3): - mp_msg(MSGT_AFILTER,MSGL_ERR,"[af_format] Input audio format not yet supported \n"); - return 0; - default: - //This can not happen .... - mp_msg(MSGT_AFILTER,MSGL_ERR,"Unrecognized input audio format\n"); - return 0; + int i=0; + // Print endinaness + if(AF_FORMAT_LE == (format & AF_FORMAT_END_MASK)) + i+=snprintf(str,size,"little endian "); + else + i+=snprintf(str,size,"big endian "); + + if(format & AF_FORMAT_SPECIAL_MASK){ + switch(format & AF_FORMAT_SPECIAL_MASK){ + case(AF_FORMAT_MU_LAW): + i+=snprintf(&str[i],size-i,"mu law "); break; + case(AF_FORMAT_A_LAW): + i+=snprintf(&str[i],size-i,"A law "); break; + case(AF_FORMAT_MPEG2): + i+=snprintf(&str[i],size-i,"MPEG 2 "); break; + case(AF_FORMAT_AC3): + i+=snprintf(&str[i],size-i,"AC3 "); break; + } } + else{ + // Point + if(AF_FORMAT_F == (format & AF_FORMAT_POINT_MASK)) + i+=snprintf(&str[i],size,"float "); + else{ + // Sign + if(AF_FORMAT_US == (format & AF_FORMAT_SIGN_MASK)) + i+=snprintf(&str[i],size-i,"unsigned "); + else + i+=snprintf(&str[i],size-i,"signed "); + i+=snprintf(&str[i],size,"int "); + } + } + return str; } // Initialization and runtime control static int control(struct af_instance_s* af, int cmd, void* arg) { switch(cmd){ - case AF_CONTROL_REINIT: + case AF_CONTROL_REINIT:{ + char buf1[256]; + char buf2[256]; // Make sure this filter isn't redundant - if(af->data->format == ((af_data_t*)arg)->format && af->data->bps == ((af_data_t*)arg)->bps) + if(af->data->format == ((af_data_t*)arg)->format && + af->data->bps == ((af_data_t*)arg)->bps) return AF_DETACH; + + // Sanity check for bytes per sample + if(((af_data_t*)arg)->bps != 4 && ((af_data_t*)arg)->bps != 2 && + ((af_data_t*)arg)->bps != 1){ + af_msg(AF_MSG_ERROR,"[format] The number of output bytes per sample must be 1, 2 or 4. Current value is %i \n",((af_data_t*)arg)->bps); + return AF_ERROR; + } + + // Check for unsupported formats + switch(((af_data_t*)arg)->format & AF_FORMAT_SPECIAL_MASK){ + case(AF_FORMAT_MPEG2): + case(AF_FORMAT_AC3): + af_msg(AF_MSG_ERROR,"[format] Sample format not yet supported \n"); + return AF_ERROR; + } + + af_msg(AF_MSG_VERBOSE,"[format] Changing sample format from %ibit %sto %ibit %s \n", + ((af_data_t*)arg)->bps*8,fmt2str(((af_data_t*)arg)->format,buf1,256), + af->data->bps*8,fmt2str(af->data->format,buf2,256)); af->data->rate = ((af_data_t*)arg)->rate; af->data->nch = ((af_data_t*)arg)->nch; af->mul.n = af->data->bps; af->mul.d = ((af_data_t*)arg)->bps; return AF_OK; + } case AF_CONTROL_COMMAND_LINE:{ - af_data_t d; - sscanf((char*)arg,"%i:%i",&(d.format),&(d.bps)); + af_data_t d={NULL,0,0,0,0,2}; + char str[256]; + sscanf((char*)arg,"%i:%s",&(d.bps),str); + // Convert string to format + d.format = str2fmt(str); + // Automatic correction of errors + switch(d.format & AF_FORMAT_SPECIAL_MASK){ + case(AF_FORMAT_A_LAW): + case(AF_FORMAT_MU_LAW): + d.bps=1; break; + case(AF_FORMAT_AC3): + d.bps=4; break; // I think + } + if(AF_FORMAT_F == (d.format & AF_FORMAT_POINT_MASK)) + d.bps=4; + return af->control(af,AF_CONTROL_FORMAT,&d); - } + } case AF_CONTROL_FORMAT: // Reinit must be called after this function has been called - // Sanity check for sample format - if(0 == ((int)af->setup=decode(((af_data_t*)arg)->format))) - return AF_ERROR; - af->data->format = ((af_data_t*)arg)->format; - - // Sanity check for bytes per sample - if(((af_data_t*)arg)->bps != 4 && ((af_data_t*)arg)->bps != 2 && ((af_data_t*)arg)->bps != 1){ - mp_msg(MSGT_AFILTER,MSGL_ERR,"[format] The number of output bytes per sample must be 1, 2 or 4. Current value is%i \n",((af_data_t*)arg)->bps); + // Check for unsupported formats + switch(((af_data_t*)arg)->format & AF_FORMAT_SPECIAL_MASK){ + case(AF_FORMAT_MPEG2): + case(AF_FORMAT_AC3): + af_msg(AF_MSG_ERROR,"[format] Sample format not yet supported \n"); return AF_ERROR; } - af->data->bps=((af_data_t*)arg)->bps; - mp_msg(MSGT_AFILTER,MSGL_V,"[format] Changing number sample format to 0x%08X and/or bytes per sample to %i \n",af->data->format,af->data->bps); + af->data->format = ((af_data_t*)arg)->format; + af->data->bps=((af_data_t*)arg)->bps; return AF_OK; } return AF_UNKNOWN; @@ -125,156 +204,86 @@ static void uninit(struct af_instance_s* af) // Filter data through filter static af_data_t* play(struct af_instance_s* af, af_data_t* data) { - af_data_t* l = af->data; // Local data - void* la = NULL; // Local audio - int lf = (int)af->setup; // Local format - af_data_t* c = data; // Current working data - void* ca = c->audio; // Current audio - int cf = decode(c->format); // Current format - register int i = 0; // Counter - int len = c->len>>(cf&NBITS_MASK); // Loop end + af_data_t* l = af->data; // Local data + af_data_t* c = data; // Current working data + int len = c->len/c->bps; // Lenght in samples of current audio block if(AF_OK != RESIZE_LOCAL_BUFFER(af,data)) return NULL; - la = l->audio; + // Change to cpu native endian format + if((c->format&AF_FORMAT_END_MASK)!=AF_FORMAT_NE) + endian(c->audio,c->audio,len,c->bps); - // Change to cpu native endian - if((cf&END_MASK)!=NE){ - switch(cf&NBITS_MASK){ - case(B16):{ - register uint16_t s; - for(i=0;i>8); - } - } + // Conversion table + switch(c->format & ~AF_FORMAT_END_MASK){ + case(AF_FORMAT_MU_LAW): + from_ulaw(c->audio, l->audio, len, l->bps, l->format&AF_FORMAT_POINT_MASK); + if(AF_FORMAT_A_LAW == (l->format&AF_FORMAT_SPECIAL_MASK)) + to_ulaw(l->audio, l->audio, len, 1, AF_FORMAT_SI); + if((l->format&AF_FORMAT_SIGN_MASK) == AF_FORMAT_US) + si2us(l->audio,l->audio,len,l->bps); break; - case(B32):{ - register uint32_t s; - for(i=0;i>8) | ((s&0xFF000000)>>24)); - } - } + case(AF_FORMAT_A_LAW): + from_alaw(c->audio, l->audio, len, l->bps, l->format&AF_FORMAT_POINT_MASK); + if(AF_FORMAT_A_LAW == (l->format&AF_FORMAT_SPECIAL_MASK)) + to_alaw(l->audio, l->audio, len, 1, AF_FORMAT_SI); + if((l->format&AF_FORMAT_SIGN_MASK) == AF_FORMAT_US) + si2us(l->audio,l->audio,len,l->bps); break; - } - } - - // Change signed/unsigned - if((cf&SIGN_MASK) != (lf&SIGN_MASK)){ - switch((cf&NBITS_MASK)){ - case(B08): - switch(cf&SIGN_MASK){ - case(US): - for(i=0;iaudio, l->audio, len, l->bps); + switch(l->format&AF_FORMAT_SPECIAL_MASK){ + case(AF_FORMAT_MU_LAW): + to_ulaw(c->audio, l->audio, len, c->bps, c->format&AF_FORMAT_POINT_MASK); break; - case(B16): - switch(cf&SIGN_MASK){ - case(US): - for(i=0;iaudio, l->audio, len, c->bps, c->format&AF_FORMAT_POINT_MASK); break; - case(B32): - switch(cf&SIGN_MASK){ - case(US): - for(i=0;iformat&AF_FORMAT_SIGN_MASK) == AF_FORMAT_US) + si2us(l->audio,l->audio,len,l->bps); + break; + default: + // Input must be int + + // Change signed/unsigned + if((c->format&AF_FORMAT_SIGN_MASK) != (l->format&AF_FORMAT_SIGN_MASK)){ + if((c->format&AF_FORMAT_SIGN_MASK) == AF_FORMAT_US) + us2si(c->audio,c->audio,len,c->bps); + else + si2us(c->audio,c->audio,len,c->bps); + } + // Convert to special formats + switch(l->format&AF_FORMAT_SPECIAL_MASK){ + case(AF_FORMAT_MU_LAW): + to_ulaw(c->audio, l->audio, len, c->bps, c->format&AF_FORMAT_POINT_MASK); break; - } - } - // Change the number of bits - if((cf&NBITS_MASK) == (lf&NBITS_MASK)){ - memcpy(la,ca,c->len); - } else { - switch(cf&NBITS_MASK){ - case(B08): - switch(lf&NBITS_MASK){ - case(B16): - for(i=0;iaudio, l->audio, len, c->bps, c->format&AF_FORMAT_POINT_MASK); break; - case(B16): - switch(lf&NBITS_MASK){ - case(B08): - for(i=0;i>8); - break; - case(B32): - for(i=0;iformat&AF_FORMAT_POINT_MASK)) + int2float(c->audio, l->audio, len, c->bps); + else{ + // Change the number of bits + if(c->bps != l->bps) + change_bps(c->audio,l->audio,len,c->bps,l->bps); + else + c->audio = l->audio; } break; - case(B32): - switch(lf&NBITS_MASK){ - case(B08): - for(i=0;i>24); - break; - case(B16): - for(i=0;i>16); - break; - } - break; } } // Switch from cpu native endian to the correct endianess - if((lf&END_MASK)!=NE){ - switch(lf&NBITS_MASK){ - case(B16):{ - register uint16_t s; - for(i=0;i>8); - } - } - break; - case(B32):{ - register uint32_t s; - for(i=0;i>8) | ((s&0xFF000000)>>24)); - } - } - break; - } - } + if((l->format&AF_FORMAT_END_MASK)!=AF_FORMAT_NE) + endian(l->audio,l->audio,len,l->bps); // Set output data - - // Make sure no samples are lost - c->len = (c->len*l->bps)/c->bps; c->audio = l->audio; + c->len = len*l->bps; c->bps = l->bps; c->format = l->format; return c; @@ -303,3 +312,149 @@ af_info_t af_info_format = { AF_FLAGS_REENTRANT, open }; + +// Function implementations used by play +static void endian(void* in, void* out, int len, int bps) +{ + register int i; + switch(bps){ + case(2):{ + register uint16_t s; + for(i=0;i>8); + } + break; + } + case(4):{ + register uint32_t s; + for(i=0;i>8) | + ((s&0xFF000000)>>24)); + } + break; + } + } +} + +static void si2us(void* in, void* out, int len, int bps) +{ + register int i; + switch(bps){ + case(1): + for(i=0;i>8); + break; + case(4): + for(i=0;i>24); + break; + case(2): + for(i=0;i>16); + break; + } + break; + } +} + +static void float2int(void* in, void* out, int len, int bps) +{ + register int i; + switch(bps){ + case(1): + for(i=0;i +// +//============================================================================= +*/ + +#ifndef __af_format_alaw_c +#define __af_format_alaw_c + +#include +#include + +#include "af.h" + +// Conversion tables (the function are below) +static short alaw_decode [128] = +{ -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 +} ; /* alaw_decode */ + +static unsigned char alaw_encode [2049] = +{ 0xD5, 0xD4, 0xD7, 0xD6, 0xD1, 0xD0, 0xD3, 0xD2, 0xDD, 0xDC, 0xDF, 0xDE, + 0xD9, 0xD8, 0xDB, 0xDA, 0xC5, 0xC4, 0xC7, 0xC6, 0xC1, 0xC0, 0xC3, 0xC2, + 0xCD, 0xCC, 0xCF, 0xCE, 0xC9, 0xC8, 0xCB, 0xCA, 0xF5, 0xF5, 0xF4, 0xF4, + 0xF7, 0xF7, 0xF6, 0xF6, 0xF1, 0xF1, 0xF0, 0xF0, 0xF3, 0xF3, 0xF2, 0xF2, + 0xFD, 0xFD, 0xFC, 0xFC, 0xFF, 0xFF, 0xFE, 0xFE, 0xF9, 0xF9, 0xF8, 0xF8, + 0xFB, 0xFB, 0xFA, 0xFA, 0xE5, 0xE5, 0xE5, 0xE5, 0xE4, 0xE4, 0xE4, 0xE4, + 0xE7, 0xE7, 0xE7, 0xE7, 0xE6, 0xE6, 0xE6, 0xE6, 0xE1, 0xE1, 0xE1, 0xE1, + 0xE0, 0xE0, 0xE0, 0xE0, 0xE3, 0xE3, 0xE3, 0xE3, 0xE2, 0xE2, 0xE2, 0xE2, + 0xED, 0xED, 0xED, 0xED, 0xEC, 0xEC, 0xEC, 0xEC, 0xEF, 0xEF, 0xEF, 0xEF, + 0xEE, 0xEE, 0xEE, 0xEE, 0xE9, 0xE9, 0xE9, 0xE9, 0xE8, 0xE8, 0xE8, 0xE8, + 0xEB, 0xEB, 0xEB, 0xEB, 0xEA, 0xEA, 0xEA, 0xEA, 0x95, 0x95, 0x95, 0x95, + 0x95, 0x95, 0x95, 0x95, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, + 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x96, 0x96, 0x96, 0x96, + 0x96, 0x96, 0x96, 0x96, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, + 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x93, 0x93, 0x93, 0x93, + 0x93, 0x93, 0x93, 0x93, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, + 0x9D, 0x9D, 0x9D, 0x9D, 0x9D, 0x9D, 0x9D, 0x9D, 0x9C, 0x9C, 0x9C, 0x9C, + 0x9C, 0x9C, 0x9C, 0x9C, 0x9F, 0x9F, 0x9F, 0x9F, 0x9F, 0x9F, 0x9F, 0x9F, + 0x9E, 0x9E, 0x9E, 0x9E, 0x9E, 0x9E, 0x9E, 0x9E, 0x99, 0x99, 0x99, 0x99, + 0x99, 0x99, 0x99, 0x99, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, + 0x9B, 0x9B, 0x9B, 0x9B, 0x9B, 0x9B, 0x9B, 0x9B, 0x9A, 0x9A, 0x9A, 0x9A, + 0x9A, 0x9A, 0x9A, 0x9A, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, + 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x84, 0x84, 0x84, 0x84, + 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, + 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, + 0x87, 0x87, 0x87, 0x87, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, + 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x81, 0x81, 0x81, 0x81, + 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, + 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, + 0x80, 0x80, 0x80, 0x80, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, + 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x82, 0x82, 0x82, 0x82, + 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, + 0x8D, 0x8D, 0x8D, 0x8D, 0x8D, 0x8D, 0x8D, 0x8D, 0x8D, 0x8D, 0x8D, 0x8D, + 0x8D, 0x8D, 0x8D, 0x8D, 0x8C, 0x8C, 0x8C, 0x8C, 0x8C, 0x8C, 0x8C, 0x8C, + 0x8C, 0x8C, 0x8C, 0x8C, 0x8C, 0x8C, 0x8C, 0x8C, 0x8F, 0x8F, 0x8F, 0x8F, + 0x8F, 0x8F, 0x8F, 0x8F, 0x8F, 0x8F, 0x8F, 0x8F, 0x8F, 0x8F, 0x8F, 0x8F, + 0x8E, 0x8E, 0x8E, 0x8E, 0x8E, 0x8E, 0x8E, 0x8E, 0x8E, 0x8E, 0x8E, 0x8E, + 0x8E, 0x8E, 0x8E, 0x8E, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, + 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x88, 0x88, 0x88, 0x88, + 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, + 0x8B, 0x8B, 0x8B, 0x8B, 0x8B, 0x8B, 0x8B, 0x8B, 0x8B, 0x8B, 0x8B, 0x8B, + 0x8B, 0x8B, 0x8B, 0x8B, 0x8A, 0x8A, 0x8A, 0x8A, 0x8A, 0x8A, 0x8A, 0x8A, + 0x8A, 0x8A, 0x8A, 0x8A, 0x8A, 0x8A, 0x8A, 0x8A, 0xB5, 0xB5, 0xB5, 0xB5, + 0xB5, 0xB5, 0xB5, 0xB5, 0xB5, 0xB5, 0xB5, 0xB5, 0xB5, 0xB5, 0xB5, 0xB5, + 0xB5, 0xB5, 0xB5, 0xB5, 0xB5, 0xB5, 0xB5, 0xB5, 0xB5, 0xB5, 0xB5, 0xB5, + 0xB5, 0xB5, 0xB5, 0xB5, 0xB4, 0xB4, 0xB4, 0xB4, 0xB4, 0xB4, 0xB4, 0xB4, + 0xB4, 0xB4, 0xB4, 0xB4, 0xB4, 0xB4, 0xB4, 0xB4, 0xB4, 0xB4, 0xB4, 0xB4, + 0xB4, 0xB4, 0xB4, 0xB4, 0xB4, 0xB4, 0xB4, 0xB4, 0xB4, 0xB4, 0xB4, 0xB4, + 0xB7, 0xB7, 0xB7, 0xB7, 0xB7, 0xB7, 0xB7, 0xB7, 0xB7, 0xB7, 0xB7, 0xB7, + 0xB7, 0xB7, 0xB7, 0xB7, 0xB7, 0xB7, 0xB7, 0xB7, 0xB7, 0xB7, 0xB7, 0xB7, + 0xB7, 0xB7, 0xB7, 0xB7, 0xB7, 0xB7, 0xB7, 0xB7, 0xB6, 0xB6, 0xB6, 0xB6, + 0xB6, 0xB6, 0xB6, 0xB6, 0xB6, 0xB6, 0xB6, 0xB6, 0xB6, 0xB6, 0xB6, 0xB6, + 0xB6, 0xB6, 0xB6, 0xB6, 0xB6, 0xB6, 0xB6, 0xB6, 0xB6, 0xB6, 0xB6, 0xB6, + 0xB6, 0xB6, 0xB6, 0xB6, 0xB1, 0xB1, 0xB1, 0xB1, 0xB1, 0xB1, 0xB1, 0xB1, + 0xB1, 0xB1, 0xB1, 0xB1, 0xB1, 0xB1, 0xB1, 0xB1, 0xB1, 0xB1, 0xB1, 0xB1, + 0xB1, 0xB1, 0xB1, 0xB1, 0xB1, 0xB1, 0xB1, 0xB1, 0xB1, 0xB1, 0xB1, 0xB1, + 0xB0, 0xB0, 0xB0, 0xB0, 0xB0, 0xB0, 0xB0, 0xB0, 0xB0, 0xB0, 0xB0, 0xB0, + 0xB0, 0xB0, 0xB0, 0xB0, 0xB0, 0xB0, 0xB0, 0xB0, 0xB0, 0xB0, 0xB0, 0xB0, + 0xB0, 0xB0, 0xB0, 0xB0, 0xB0, 0xB0, 0xB0, 0xB0, 0xB3, 0xB3, 0xB3, 0xB3, + 0xB3, 0xB3, 0xB3, 0xB3, 0xB3, 0xB3, 0xB3, 0xB3, 0xB3, 0xB3, 0xB3, 0xB3, + 0xB3, 0xB3, 0xB3, 0xB3, 0xB3, 0xB3, 0xB3, 0xB3, 0xB3, 0xB3, 0xB3, 0xB3, + 0xB3, 0xB3, 0xB3, 0xB3, 0xB2, 0xB2, 0xB2, 0xB2, 0xB2, 0xB2, 0xB2, 0xB2, + 0xB2, 0xB2, 0xB2, 0xB2, 0xB2, 0xB2, 0xB2, 0xB2, 0xB2, 0xB2, 0xB2, 0xB2, + 0xB2, 0xB2, 0xB2, 0xB2, 0xB2, 0xB2, 0xB2, 0xB2, 0xB2, 0xB2, 0xB2, 0xB2, + 0xBD, 0xBD, 0xBD, 0xBD, 0xBD, 0xBD, 0xBD, 0xBD, 0xBD, 0xBD, 0xBD, 0xBD, + 0xBD, 0xBD, 0xBD, 0xBD, 0xBD, 0xBD, 0xBD, 0xBD, 0xBD, 0xBD, 0xBD, 0xBD, + 0xBD, 0xBD, 0xBD, 0xBD, 0xBD, 0xBD, 0xBD, 0xBD, 0xBC, 0xBC, 0xBC, 0xBC, + 0xBC, 0xBC, 0xBC, 0xBC, 0xBC, 0xBC, 0xBC, 0xBC, 0xBC, 0xBC, 0xBC, 0xBC, + 0xBC, 0xBC, 0xBC, 0xBC, 0xBC, 0xBC, 0xBC, 0xBC, 0xBC, 0xBC, 0xBC, 0xBC, + 0xBC, 0xBC, 0xBC, 0xBC, 0xBF, 0xBF, 0xBF, 0xBF, 0xBF, 0xBF, 0xBF, 0xBF, + 0xBF, 0xBF, 0xBF, 0xBF, 0xBF, 0xBF, 0xBF, 0xBF, 0xBF, 0xBF, 0xBF, 0xBF, + 0xBF, 0xBF, 0xBF, 0xBF, 0xBF, 0xBF, 0xBF, 0xBF, 0xBF, 0xBF, 0xBF, 0xBF, + 0xBE, 0xBE, 0xBE, 0xBE, 0xBE, 0xBE, 0xBE, 0xBE, 0xBE, 0xBE, 0xBE, 0xBE, + 0xBE, 0xBE, 0xBE, 0xBE, 0xBE, 0xBE, 0xBE, 0xBE, 0xBE, 0xBE, 0xBE, 0xBE, + 0xBE, 0xBE, 0xBE, 0xBE, 0xBE, 0xBE, 0xBE, 0xBE, 0xB9, 0xB9, 0xB9, 0xB9, + 0xB9, 0xB9, 0xB9, 0xB9, 0xB9, 0xB9, 0xB9, 0xB9, 0xB9, 0xB9, 0xB9, 0xB9, + 0xB9, 0xB9, 0xB9, 0xB9, 0xB9, 0xB9, 0xB9, 0xB9, 0xB9, 0xB9, 0xB9, 0xB9, + 0xB9, 0xB9, 0xB9, 0xB9, 0xB8, 0xB8, 0xB8, 0xB8, 0xB8, 0xB8, 0xB8, 0xB8, + 0xB8, 0xB8, 0xB8, 0xB8, 0xB8, 0xB8, 0xB8, 0xB8, 0xB8, 0xB8, 0xB8, 0xB8, + 0xB8, 0xB8, 0xB8, 0xB8, 0xB8, 0xB8, 0xB8, 0xB8, 0xB8, 0xB8, 0xB8, 0xB8, + 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, + 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, + 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBA, 0xBA, 0xBA, 0xBA, + 0xBA, 0xBA, 0xBA, 0xBA, 0xBA, 0xBA, 0xBA, 0xBA, 0xBA, 0xBA, 0xBA, 0xBA, + 0xBA, 0xBA, 0xBA, 0xBA, 0xBA, 0xBA, 0xBA, 0xBA, 0xBA, 0xBA, 0xBA, 0xBA, + 0xBA, 0xBA, 0xBA, 0xBA, 0xA5, 0xA5, 0xA5, 0xA5, 0xA5, 0xA5, 0xA5, 0xA5, + 0xA5, 0xA5, 0xA5, 0xA5, 0xA5, 0xA5, 0xA5, 0xA5, 0xA5, 0xA5, 0xA5, 0xA5, + 0xA5, 0xA5, 0xA5, 0xA5, 0xA5, 0xA5, 0xA5, 0xA5, 0xA5, 0xA5, 0xA5, 0xA5, + 0xA5, 0xA5, 0xA5, 0xA5, 0xA5, 0xA5, 0xA5, 0xA5, 0xA5, 0xA5, 0xA5, 0xA5, + 0xA5, 0xA5, 0xA5, 0xA5, 0xA5, 0xA5, 0xA5, 0xA5, 0xA5, 0xA5, 0xA5, 0xA5, + 0xA5, 0xA5, 0xA5, 0xA5, 0xA5, 0xA5, 0xA5, 0xA5, 0xA4, 0xA4, 0xA4, 0xA4, + 0xA4, 0xA4, 0xA4, 0xA4, 0xA4, 0xA4, 0xA4, 0xA4, 0xA4, 0xA4, 0xA4, 0xA4, + 0xA4, 0xA4, 0xA4, 0xA4, 0xA4, 0xA4, 0xA4, 0xA4, 0xA4, 0xA4, 0xA4, 0xA4, + 0xA4, 0xA4, 0xA4, 0xA4, 0xA4, 0xA4, 0xA4, 0xA4, 0xA4, 0xA4, 0xA4, 0xA4, + 0xA4, 0xA4, 0xA4, 0xA4, 0xA4, 0xA4, 0xA4, 0xA4, 0xA4, 0xA4, 0xA4, 0xA4, + 0xA4, 0xA4, 0xA4, 0xA4, 0xA4, 0xA4, 0xA4, 0xA4, 0xA4, 0xA4, 0xA4, 0xA4, + 0xA7, 0xA7, 0xA7, 0xA7, 0xA7, 0xA7, 0xA7, 0xA7, 0xA7, 0xA7, 0xA7, 0xA7, + 0xA7, 0xA7, 0xA7, 0xA7, 0xA7, 0xA7, 0xA7, 0xA7, 0xA7, 0xA7, 0xA7, 0xA7, + 0xA7, 0xA7, 0xA7, 0xA7, 0xA7, 0xA7, 0xA7, 0xA7, 0xA7, 0xA7, 0xA7, 0xA7, + 0xA7, 0xA7, 0xA7, 0xA7, 0xA7, 0xA7, 0xA7, 0xA7, 0xA7, 0xA7, 0xA7, 0xA7, + 0xA7, 0xA7, 0xA7, 0xA7, 0xA7, 0xA7, 0xA7, 0xA7, 0xA7, 0xA7, 0xA7, 0xA7, + 0xA7, 0xA7, 0xA7, 0xA7, 0xA6, 0xA6, 0xA6, 0xA6, 0xA6, 0xA6, 0xA6, 0xA6, + 0xA6, 0xA6, 0xA6, 0xA6, 0xA6, 0xA6, 0xA6, 0xA6, 0xA6, 0xA6, 0xA6, 0xA6, + 0xA6, 0xA6, 0xA6, 0xA6, 0xA6, 0xA6, 0xA6, 0xA6, 0xA6, 0xA6, 0xA6, 0xA6, + 0xA6, 0xA6, 0xA6, 0xA6, 0xA6, 0xA6, 0xA6, 0xA6, 0xA6, 0xA6, 0xA6, 0xA6, + 0xA6, 0xA6, 0xA6, 0xA6, 0xA6, 0xA6, 0xA6, 0xA6, 0xA6, 0xA6, 0xA6, 0xA6, + 0xA6, 0xA6, 0xA6, 0xA6, 0xA6, 0xA6, 0xA6, 0xA6, 0xA1, 0xA1, 0xA1, 0xA1, + 0xA1, 0xA1, 0xA1, 0xA1, 0xA1, 0xA1, 0xA1, 0xA1, 0xA1, 0xA1, 0xA1, 0xA1, + 0xA1, 0xA1, 0xA1, 0xA1, 0xA1, 0xA1, 0xA1, 0xA1, 0xA1, 0xA1, 0xA1, 0xA1, + 0xA1, 0xA1, 0xA1, 0xA1, 0xA1, 0xA1, 0xA1, 0xA1, 0xA1, 0xA1, 0xA1, 0xA1, + 0xA1, 0xA1, 0xA1, 0xA1, 0xA1, 0xA1, 0xA1, 0xA1, 0xA1, 0xA1, 0xA1, 0xA1, + 0xA1, 0xA1, 0xA1, 0xA1, 0xA1, 0xA1, 0xA1, 0xA1, 0xA1, 0xA1, 0xA1, 0xA1, + 0xA0, 0xA0, 0xA0, 0xA0, 0xA0, 0xA0, 0xA0, 0xA0, 0xA0, 0xA0, 0xA0, 0xA0, + 0xA0, 0xA0, 0xA0, 0xA0, 0xA0, 0xA0, 0xA0, 0xA0, 0xA0, 0xA0, 0xA0, 0xA0, + 0xA0, 0xA0, 0xA0, 0xA0, 0xA0, 0xA0, 0xA0, 0xA0, 0xA0, 0xA0, 0xA0, 0xA0, + 0xA0, 0xA0, 0xA0, 0xA0, 0xA0, 0xA0, 0xA0, 0xA0, 0xA0, 0xA0, 0xA0, 0xA0, + 0xA0, 0xA0, 0xA0, 0xA0, 0xA0, 0xA0, 0xA0, 0xA0, 0xA0, 0xA0, 0xA0, 0xA0, + 0xA0, 0xA0, 0xA0, 0xA0, 0xA3, 0xA3, 0xA3, 0xA3, 0xA3, 0xA3, 0xA3, 0xA3, + 0xA3, 0xA3, 0xA3, 0xA3, 0xA3, 0xA3, 0xA3, 0xA3, 0xA3, 0xA3, 0xA3, 0xA3, + 0xA3, 0xA3, 0xA3, 0xA3, 0xA3, 0xA3, 0xA3, 0xA3, 0xA3, 0xA3, 0xA3, 0xA3, + 0xA3, 0xA3, 0xA3, 0xA3, 0xA3, 0xA3, 0xA3, 0xA3, 0xA3, 0xA3, 0xA3, 0xA3, + 0xA3, 0xA3, 0xA3, 0xA3, 0xA3, 0xA3, 0xA3, 0xA3, 0xA3, 0xA3, 0xA3, 0xA3, + 0xA3, 0xA3, 0xA3, 0xA3, 0xA3, 0xA3, 0xA3, 0xA3, 0xA2, 0xA2, 0xA2, 0xA2, + 0xA2, 0xA2, 0xA2, 0xA2, 0xA2, 0xA2, 0xA2, 0xA2, 0xA2, 0xA2, 0xA2, 0xA2, + 0xA2, 0xA2, 0xA2, 0xA2, 0xA2, 0xA2, 0xA2, 0xA2, 0xA2, 0xA2, 0xA2, 0xA2, + 0xA2, 0xA2, 0xA2, 0xA2, 0xA2, 0xA2, 0xA2, 0xA2, 0xA2, 0xA2, 0xA2, 0xA2, + 0xA2, 0xA2, 0xA2, 0xA2, 0xA2, 0xA2, 0xA2, 0xA2, 0xA2, 0xA2, 0xA2, 0xA2, + 0xA2, 0xA2, 0xA2, 0xA2, 0xA2, 0xA2, 0xA2, 0xA2, 0xA2, 0xA2, 0xA2, 0xA2, + 0xAD, 0xAD, 0xAD, 0xAD, 0xAD, 0xAD, 0xAD, 0xAD, 0xAD, 0xAD, 0xAD, 0xAD, + 0xAD, 0xAD, 0xAD, 0xAD, 0xAD, 0xAD, 0xAD, 0xAD, 0xAD, 0xAD, 0xAD, 0xAD, + 0xAD, 0xAD, 0xAD, 0xAD, 0xAD, 0xAD, 0xAD, 0xAD, 0xAD, 0xAD, 0xAD, 0xAD, + 0xAD, 0xAD, 0xAD, 0xAD, 0xAD, 0xAD, 0xAD, 0xAD, 0xAD, 0xAD, 0xAD, 0xAD, + 0xAD, 0xAD, 0xAD, 0xAD, 0xAD, 0xAD, 0xAD, 0xAD, 0xAD, 0xAD, 0xAD, 0xAD, + 0xAD, 0xAD, 0xAD, 0xAD, 0xAC, 0xAC, 0xAC, 0xAC, 0xAC, 0xAC, 0xAC, 0xAC, + 0xAC, 0xAC, 0xAC, 0xAC, 0xAC, 0xAC, 0xAC, 0xAC, 0xAC, 0xAC, 0xAC, 0xAC, + 0xAC, 0xAC, 0xAC, 0xAC, 0xAC, 0xAC, 0xAC, 0xAC, 0xAC, 0xAC, 0xAC, 0xAC, + 0xAC, 0xAC, 0xAC, 0xAC, 0xAC, 0xAC, 0xAC, 0xAC, 0xAC, 0xAC, 0xAC, 0xAC, + 0xAC, 0xAC, 0xAC, 0xAC, 0xAC, 0xAC, 0xAC, 0xAC, 0xAC, 0xAC, 0xAC, 0xAC, + 0xAC, 0xAC, 0xAC, 0xAC, 0xAC, 0xAC, 0xAC, 0xAC, 0xAF, 0xAF, 0xAF, 0xAF, + 0xAF, 0xAF, 0xAF, 0xAF, 0xAF, 0xAF, 0xAF, 0xAF, 0xAF, 0xAF, 0xAF, 0xAF, + 0xAF, 0xAF, 0xAF, 0xAF, 0xAF, 0xAF, 0xAF, 0xAF, 0xAF, 0xAF, 0xAF, 0xAF, + 0xAF, 0xAF, 0xAF, 0xAF, 0xAF, 0xAF, 0xAF, 0xAF, 0xAF, 0xAF, 0xAF, 0xAF, + 0xAF, 0xAF, 0xAF, 0xAF, 0xAF, 0xAF, 0xAF, 0xAF, 0xAF, 0xAF, 0xAF, 0xAF, + 0xAF, 0xAF, 0xAF, 0xAF, 0xAF, 0xAF, 0xAF, 0xAF, 0xAF, 0xAF, 0xAF, 0xAF, + 0xAE, 0xAE, 0xAE, 0xAE, 0xAE, 0xAE, 0xAE, 0xAE, 0xAE, 0xAE, 0xAE, 0xAE, + 0xAE, 0xAE, 0xAE, 0xAE, 0xAE, 0xAE, 0xAE, 0xAE, 0xAE, 0xAE, 0xAE, 0xAE, + 0xAE, 0xAE, 0xAE, 0xAE, 0xAE, 0xAE, 0xAE, 0xAE, 0xAE, 0xAE, 0xAE, 0xAE, + 0xAE, 0xAE, 0xAE, 0xAE, 0xAE, 0xAE, 0xAE, 0xAE, 0xAE, 0xAE, 0xAE, 0xAE, + 0xAE, 0xAE, 0xAE, 0xAE, 0xAE, 0xAE, 0xAE, 0xAE, 0xAE, 0xAE, 0xAE, 0xAE, + 0xAE, 0xAE, 0xAE, 0xAE, 0xA9, 0xA9, 0xA9, 0xA9, 0xA9, 0xA9, 0xA9, 0xA9, + 0xA9, 0xA9, 0xA9, 0xA9, 0xA9, 0xA9, 0xA9, 0xA9, 0xA9, 0xA9, 0xA9, 0xA9, + 0xA9, 0xA9, 0xA9, 0xA9, 0xA9, 0xA9, 0xA9, 0xA9, 0xA9, 0xA9, 0xA9, 0xA9, + 0xA9, 0xA9, 0xA9, 0xA9, 0xA9, 0xA9, 0xA9, 0xA9, 0xA9, 0xA9, 0xA9, 0xA9, + 0xA9, 0xA9, 0xA9, 0xA9, 0xA9, 0xA9, 0xA9, 0xA9, 0xA9, 0xA9, 0xA9, 0xA9, + 0xA9, 0xA9, 0xA9, 0xA9, 0xA9, 0xA9, 0xA9, 0xA9, 0xA8, 0xA8, 0xA8, 0xA8, + 0xA8, 0xA8, 0xA8, 0xA8, 0xA8, 0xA8, 0xA8, 0xA8, 0xA8, 0xA8, 0xA8, 0xA8, + 0xA8, 0xA8, 0xA8, 0xA8, 0xA8, 0xA8, 0xA8, 0xA8, 0xA8, 0xA8, 0xA8, 0xA8, + 0xA8, 0xA8, 0xA8, 0xA8, 0xA8, 0xA8, 0xA8, 0xA8, 0xA8, 0xA8, 0xA8, 0xA8, + 0xA8, 0xA8, 0xA8, 0xA8, 0xA8, 0xA8, 0xA8, 0xA8, 0xA8, 0xA8, 0xA8, 0xA8, + 0xA8, 0xA8, 0xA8, 0xA8, 0xA8, 0xA8, 0xA8, 0xA8, 0xA8, 0xA8, 0xA8, 0xA8, + 0xAB, 0xAB, 0xAB, 0xAB, 0xAB, 0xAB, 0xAB, 0xAB, 0xAB, 0xAB, 0xAB, 0xAB, + 0xAB, 0xAB, 0xAB, 0xAB, 0xAB, 0xAB, 0xAB, 0xAB, 0xAB, 0xAB, 0xAB, 0xAB, + 0xAB, 0xAB, 0xAB, 0xAB, 0xAB, 0xAB, 0xAB, 0xAB, 0xAB, 0xAB, 0xAB, 0xAB, + 0xAB, 0xAB, 0xAB, 0xAB, 0xAB, 0xAB, 0xAB, 0xAB, 0xAB, 0xAB, 0xAB, 0xAB, + 0xAB, 0xAB, 0xAB, 0xAB, 0xAB, 0xAB, 0xAB, 0xAB, 0xAB, 0xAB, 0xAB, 0xAB, + 0xAB, 0xAB, 0xAB, 0xAB, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, + 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, + 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, + 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, + 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, + 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x2A +} ; /* alaw_encode */ + +/* Convert from alaw to signd int8 to signed int32 or float */ +static int from_alaw(void* in, void* out, int len, int bps, int format) +{ + register int i; + // Make sure the input parametrs are OK + if(format & (AF_FORMAT_SPECIAL_MASK | AF_FORMAT_US)) + return AF_ERROR; + + // Convert to int or to float + if((format & AF_FORMAT_POINT_MASK) == AF_FORMAT_I){ + switch(bps){ + case(1): + for(i=0;i> 8; + else + ((int8_t*)out)[i] = (alaw_decode[(((int8_t*)in)[i]) & 0x7F]) >> 8; + } + break; + case(2): + for(i=0;i= 0) + ((int8_t*)out)[i] = alaw_encode[((int8_t*)in)[i] << 4]; + else + ((int8_t*)out)[i] = 0x7F & alaw_encode[-((int8_t*)in)[i] << 4]; + } + break; + case(2): + for(i=0;i= 0) + ((int8_t*)out)[i] = alaw_encode[((int16_t*)in)[i] / 16]; + else + ((int8_t*)out)[i] = 0x7F & alaw_encode[((int16_t*)in)[i] / -16]; + } + break; + case(4): + for(i=0;i= 0) + ((int8_t*)out)[i] = alaw_encode[((int32_t*)in)[i] >> (16 + 4)]; + else + ((int8_t*)out)[i] = 0x7F & alaw_encode[-((int32_t*)in)[i] >> (16 + 4)]; + } + break; + default: + return AF_ERROR; + } + } + else{ + for(i=0;i= 0) + ((int8_t*)out)[i] = alaw_encode[(int)(32767.0/16.0 * ((float*)in)[i])]; + else + ((int8_t*)out)[i] = 0x7F & alaw_encode[(int)(-32767.0/16.0 * ((float*)in)[i])]; + } + } + return AF_OK; +} +#endif /* __af_format_alaw_c */ diff --git a/libaf/af_format_ulaw.c b/libaf/af_format_ulaw.c new file mode 100644 index 0000000000..2b84eb96b6 --- /dev/null +++ b/libaf/af_format_ulaw.c @@ -0,0 +1,828 @@ +/*============================================================================= +// +// This software has been released under the terms of the GNU Public +// license. See http://www.gnu.org/copyleft/gpl.html for details. +// +// Copyright 2002 Anders Johansson ajh@watri.uwa.edu.au +// +// This file is based on a part of libsndfile, the work of +// Erik de Castro Lopo +// +//============================================================================= +*/ + +#ifndef __af_format_ulaw_c +#define __af_format_ulaw_c + +#include +#include + +#include "af.h" +// Conversion tables (the function are below) +static short ulaw_decode[128] = +{ -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 unsigned char ulaw_encode[8193] = +{ 0xFF, 0xFE, 0xFE, 0xFD, 0xFD, 0xFC, 0xFC, 0xFB, 0xFB, 0xFA, 0xFA, 0xF9, + 0xF9, 0xF8, 0xF8, 0xF7, 0xF7, 0xF6, 0xF6, 0xF5, 0xF5, 0xF4, 0xF4, 0xF3, + 0xF3, 0xF2, 0xF2, 0xF1, 0xF1, 0xF0, 0xF0, 0xEF, 0xEF, 0xEF, 0xEF, 0xEE, + 0xEE, 0xEE, 0xEE, 0xED, 0xED, 0xED, 0xED, 0xEC, 0xEC, 0xEC, 0xEC, 0xEB, + 0xEB, 0xEB, 0xEB, 0xEA, 0xEA, 0xEA, 0xEA, 0xE9, 0xE9, 0xE9, 0xE9, 0xE8, + 0xE8, 0xE8, 0xE8, 0xE7, 0xE7, 0xE7, 0xE7, 0xE6, 0xE6, 0xE6, 0xE6, 0xE5, + 0xE5, 0xE5, 0xE5, 0xE4, 0xE4, 0xE4, 0xE4, 0xE3, 0xE3, 0xE3, 0xE3, 0xE2, + 0xE2, 0xE2, 0xE2, 0xE1, 0xE1, 0xE1, 0xE1, 0xE0, 0xE0, 0xE0, 0xE0, 0xDF, + 0xDF, 0xDF, 0xDF, 0xDF, 0xDF, 0xDF, 0xDF, 0xDE, 0xDE, 0xDE, 0xDE, 0xDE, + 0xDE, 0xDE, 0xDE, 0xDD, 0xDD, 0xDD, 0xDD, 0xDD, 0xDD, 0xDD, 0xDD, 0xDC, + 0xDC, 0xDC, 0xDC, 0xDC, 0xDC, 0xDC, 0xDC, 0xDB, 0xDB, 0xDB, 0xDB, 0xDB, + 0xDB, 0xDB, 0xDB, 0xDA, 0xDA, 0xDA, 0xDA, 0xDA, 0xDA, 0xDA, 0xDA, 0xD9, + 0xD9, 0xD9, 0xD9, 0xD9, 0xD9, 0xD9, 0xD9, 0xD8, 0xD8, 0xD8, 0xD8, 0xD8, + 0xD8, 0xD8, 0xD8, 0xD7, 0xD7, 0xD7, 0xD7, 0xD7, 0xD7, 0xD7, 0xD7, 0xD6, + 0xD6, 0xD6, 0xD6, 0xD6, 0xD6, 0xD6, 0xD6, 0xD5, 0xD5, 0xD5, 0xD5, 0xD5, + 0xD5, 0xD5, 0xD5, 0xD4, 0xD4, 0xD4, 0xD4, 0xD4, 0xD4, 0xD4, 0xD4, 0xD3, + 0xD3, 0xD3, 0xD3, 0xD3, 0xD3, 0xD3, 0xD3, 0xD2, 0xD2, 0xD2, 0xD2, 0xD2, + 0xD2, 0xD2, 0xD2, 0xD1, 0xD1, 0xD1, 0xD1, 0xD1, 0xD1, 0xD1, 0xD1, 0xD0, + 0xD0, 0xD0, 0xD0, 0xD0, 0xD0, 0xD0, 0xD0, 0xCF, 0xCF, 0xCF, 0xCF, 0xCF, + 0xCF, 0xCF, 0xCF, 0xCF, 0xCF, 0xCF, 0xCF, 0xCF, 0xCF, 0xCF, 0xCF, 0xCE, + 0xCE, 0xCE, 0xCE, 0xCE, 0xCE, 0xCE, 0xCE, 0xCE, 0xCE, 0xCE, 0xCE, 0xCE, + 0xCE, 0xCE, 0xCE, 0xCD, 0xCD, 0xCD, 0xCD, 0xCD, 0xCD, 0xCD, 0xCD, 0xCD, + 0xCD, 0xCD, 0xCD, 0xCD, 0xCD, 0xCD, 0xCD, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, + 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCB, + 0xCB, 0xCB, 0xCB, 0xCB, 0xCB, 0xCB, 0xCB, 0xCB, 0xCB, 0xCB, 0xCB, 0xCB, + 0xCB, 0xCB, 0xCB, 0xCA, 0xCA, 0xCA, 0xCA, 0xCA, 0xCA, 0xCA, 0xCA, 0xCA, + 0xCA, 0xCA, 0xCA, 0xCA, 0xCA, 0xCA, 0xCA, 0xC9, 0xC9, 0xC9, 0xC9, 0xC9, + 0xC9, 0xC9, 0xC9, 0xC9, 0xC9, 0xC9, 0xC9, 0xC9, 0xC9, 0xC9, 0xC9, 0xC8, + 0xC8, 0xC8, 0xC8, 0xC8, 0xC8, 0xC8, 0xC8, 0xC8, 0xC8, 0xC8, 0xC8, 0xC8, + 0xC8, 0xC8, 0xC8, 0xC7, 0xC7, 0xC7, 0xC7, 0xC7, 0xC7, 0xC7, 0xC7, 0xC7, + 0xC7, 0xC7, 0xC7, 0xC7, 0xC7, 0xC7, 0xC7, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, + 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0xC5, + 0xC5, 0xC5, 0xC5, 0xC5, 0xC5, 0xC5, 0xC5, 0xC5, 0xC5, 0xC5, 0xC5, 0xC5, + 0xC5, 0xC5, 0xC5, 0xC4, 0xC4, 0xC4, 0xC4, 0xC4, 0xC4, 0xC4, 0xC4, 0xC4, + 0xC4, 0xC4, 0xC4, 0xC4, 0xC4, 0xC4, 0xC4, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, + 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC2, + 0xC2, 0xC2, 0xC2, 0xC2, 0xC2, 0xC2, 0xC2, 0xC2, 0xC2, 0xC2, 0xC2, 0xC2, + 0xC2, 0xC2, 0xC2, 0xC1, 0xC1, 0xC1, 0xC1, 0xC1, 0xC1, 0xC1, 0xC1, 0xC1, + 0xC1, 0xC1, 0xC1, 0xC1, 0xC1, 0xC1, 0xC1, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, + 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xBF, + 0xBF, 0xBF, 0xBF, 0xBF, 0xBF, 0xBF, 0xBF, 0xBF, 0xBF, 0xBF, 0xBF, 0xBF, + 0xBF, 0xBF, 0xBF, 0xBF, 0xBF, 0xBF, 0xBF, 0xBF, 0xBF, 0xBF, 0xBF, 0xBF, + 0xBF, 0xBF, 0xBF, 0xBF, 0xBF, 0xBF, 0xBF, 0xBE, 0xBE, 0xBE, 0xBE, 0xBE, + 0xBE, 0xBE, 0xBE, 0xBE, 0xBE, 0xBE, 0xBE, 0xBE, 0xBE, 0xBE, 0xBE, 0xBE, + 0xBE, 0xBE, 0xBE, 0xBE, 0xBE, 0xBE, 0xBE, 0xBE, 0xBE, 0xBE, 0xBE, 0xBE, + 0xBE, 0xBE, 0xBE, 0xBD, 0xBD, 0xBD, 0xBD, 0xBD, 0xBD, 0xBD, 0xBD, 0xBD, + 0xBD, 0xBD, 0xBD, 0xBD, 0xBD, 0xBD, 0xBD, 0xBD, 0xBD, 0xBD, 0xBD, 0xBD, + 0xBD, 0xBD, 0xBD, 0xBD, 0xBD, 0xBD, 0xBD, 0xBD, 0xBD, 0xBD, 0xBD, 0xBC, + 0xBC, 0xBC, 0xBC, 0xBC, 0xBC, 0xBC, 0xBC, 0xBC, 0xBC, 0xBC, 0xBC, 0xBC, + 0xBC, 0xBC, 0xBC, 0xBC, 0xBC, 0xBC, 0xBC, 0xBC, 0xBC, 0xBC, 0xBC, 0xBC, + 0xBC, 0xBC, 0xBC, 0xBC, 0xBC, 0xBC, 0xBC, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, + 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, + 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, + 0xBB, 0xBB, 0xBB, 0xBA, 0xBA, 0xBA, 0xBA, 0xBA, 0xBA, 0xBA, 0xBA, 0xBA, + 0xBA, 0xBA, 0xBA, 0xBA, 0xBA, 0xBA, 0xBA, 0xBA, 0xBA, 0xBA, 0xBA, 0xBA, + 0xBA, 0xBA, 0xBA, 0xBA, 0xBA, 0xBA, 0xBA, 0xBA, 0xBA, 0xBA, 0xBA, 0xB9, + 0xB9, 0xB9, 0xB9, 0xB9, 0xB9, 0xB9, 0xB9, 0xB9, 0xB9, 0xB9, 0xB9, 0xB9, + 0xB9, 0xB9, 0xB9, 0xB9, 0xB9, 0xB9, 0xB9, 0xB9, 0xB9, 0xB9, 0xB9, 0xB9, + 0xB9, 0xB9, 0xB9, 0xB9, 0xB9, 0xB9, 0xB9, 0xB8, 0xB8, 0xB8, 0xB8, 0xB8, + 0xB8, 0xB8, 0xB8, 0xB8, 0xB8, 0xB8, 0xB8, 0xB8, 0xB8, 0xB8, 0xB8, 0xB8, + 0xB8, 0xB8, 0xB8, 0xB8, 0xB8, 0xB8, 0xB8, 0xB8, 0xB8, 0xB8, 0xB8, 0xB8, + 0xB8, 0xB8, 0xB8, 0xB7, 0xB7, 0xB7, 0xB7, 0xB7, 0xB7, 0xB7, 0xB7, 0xB7, + 0xB7, 0xB7, 0xB7, 0xB7, 0xB7, 0xB7, 0xB7, 0xB7, 0xB7, 0xB7, 0xB7, 0xB7, + 0xB7, 0xB7, 0xB7, 0xB7, 0xB7, 0xB7, 0xB7, 0xB7, 0xB7, 0xB7, 0xB7, 0xB6, + 0xB6, 0xB6, 0xB6, 0xB6, 0xB6, 0xB6, 0xB6, 0xB6, 0xB6, 0xB6, 0xB6, 0xB6, + 0xB6, 0xB6, 0xB6, 0xB6, 0xB6, 0xB6, 0xB6, 0xB6, 0xB6, 0xB6, 0xB6, 0xB6, + 0xB6, 0xB6, 0xB6, 0xB6, 0xB6, 0xB6, 0xB6, 0xB5, 0xB5, 0xB5, 0xB5, 0xB5, + 0xB5, 0xB5, 0xB5, 0xB5, 0xB5, 0xB5, 0xB5, 0xB5, 0xB5, 0xB5, 0xB5, 0xB5, + 0xB5, 0xB5, 0xB5, 0xB5, 0xB5, 0xB5, 0xB5, 0xB5, 0xB5, 0xB5, 0xB5, 0xB5, + 0xB5, 0xB5, 0xB5, 0xB4, 0xB4, 0xB4, 0xB4, 0xB4, 0xB4, 0xB4, 0xB4, 0xB4, + 0xB4, 0xB4, 0xB4, 0xB4, 0xB4, 0xB4, 0xB4, 0xB4, 0xB4, 0xB4, 0xB4, 0xB4, + 0xB4, 0xB4, 0xB4, 0xB4, 0xB4, 0xB4, 0xB4, 0xB4, 0xB4, 0xB4, 0xB4, 0xB3, + 0xB3, 0xB3, 0xB3, 0xB3, 0xB3, 0xB3, 0xB3, 0xB3, 0xB3, 0xB3, 0xB3, 0xB3, + 0xB3, 0xB3, 0xB3, 0xB3, 0xB3, 0xB3, 0xB3, 0xB3, 0xB3, 0xB3, 0xB3, 0xB3, + 0xB3, 0xB3, 0xB3, 0xB3, 0xB3, 0xB3, 0xB3, 0xB2, 0xB2, 0xB2, 0xB2, 0xB2, + 0xB2, 0xB2, 0xB2, 0xB2, 0xB2, 0xB2, 0xB2, 0xB2, 0xB2, 0xB2, 0xB2, 0xB2, + 0xB2, 0xB2, 0xB2, 0xB2, 0xB2, 0xB2, 0xB2, 0xB2, 0xB2, 0xB2, 0xB2, 0xB2, + 0xB2, 0xB2, 0xB2, 0xB1, 0xB1, 0xB1, 0xB1, 0xB1, 0xB1, 0xB1, 0xB1, 0xB1, + 0xB1, 0xB1, 0xB1, 0xB1, 0xB1, 0xB1, 0xB1, 0xB1, 0xB1, 0xB1, 0xB1, 0xB1, + 0xB1, 0xB1, 0xB1, 0xB1, 0xB1, 0xB1, 0xB1, 0xB1, 0xB1, 0xB1, 0xB1, 0xB0, + 0xB0, 0xB0, 0xB0, 0xB0, 0xB0, 0xB0, 0xB0, 0xB0, 0xB0, 0xB0, 0xB0, 0xB0, + 0xB0, 0xB0, 0xB0, 0xB0, 0xB0, 0xB0, 0xB0, 0xB0, 0xB0, 0xB0, 0xB0, 0xB0, + 0xB0, 0xB0, 0xB0, 0xB0, 0xB0, 0xB0, 0xB0, 0xAF, 0xAF, 0xAF, 0xAF, 0xAF, + 0xAF,