friends.cpp

GNU ccAudio2 is a stand-alone portable C++ class framework for manipulating audio data. It has exist

		if(info.format == snd)
		{
			count *= 2;
			s1 = (unsigned char *)buffer;
			s2 = s1 + 1;
			while(samples--)
			{
				uv[0] = *s2;
				uv[1] = *s1;
				s2 += 2;
				s1 += 2;
				ub /= 2;
				if((Level)ub > max)
					max = ub;
			}
			return max;
		}
		if(__BYTE_ORDER == info.order || !info.order)
		{
			sp = (Linear)buffer;
			while(samples--)
			{
				value = *(sp++);
				if(value < 0)
					value = -value;
				if(value > max)
					max = value;
			}	
			return max;
		}
	
		s1 = (unsigned char *)buffer;
		s2 = s1 + 1;
		while(samples--)
		{
			sv[0] = *s2;
			sv[1] = *s1;
			s1 += 2;
			s2 += 2;
			if(mb < 0)
				mb = -mb;
			if(mb > max)
				max = mb;
		}
		return max;
	default:
		return -1;
	}
}

void Audio::swapEncoded(Info &info, Encoded buffer, size_t bytes)
{
	char buf;

	if(!isLinear(info.encoding))
		return;

	if(!info.order || info.order == __BYTE_ORDER)
		return;

	// options for machine optimized should be inserted here

	bytes /= 2;
	while(bytes--)
	{
		buf = buffer[1];
		buffer[1] = *buffer;
		*buffer = buf;
		buffer += 2;		
	}
}

bool Audio::swapEndian(Encoding encoding, void *buffer, unsigned samples)
{
	unsigned char buf;
	unsigned char *s1, *s2, *s3, *s4;
	if(isStereo(encoding))
		samples *= 2;

	switch(encoding)
	{
	case pcm16Mono:
	case pcm16Stereo:
	case cdaMono:
	case cdaStereo:
		if(__BYTE_ORDER == __LITTLE_ENDIAN)
			return true;

		s1 = (unsigned char *)buffer;
		s2 = s1 + 1;
		while(samples--)
		{
			buf = *s1;
			*s1 = *s2;
			*s2 = buf;
			s1 += 2;
			s2 += 2;
		}
		return false;
	case pcm32Mono:
	case pcm32Stereo:
		if(__BYTE_ORDER == __LITTLE_ENDIAN)
			return true;

		s1 = (unsigned char *)buffer;
		s2 = s1 + 1;
		s3 = s2 + 1;
		s4 = s3 + 1;
		while(samples--)
		{
			buf = *s1;
			*s1 = *s4;
			*s4 = buf;
			buf = *s2;
			*s2 = *s3;
			*s3 = buf;
			s1 += 4;
			s2 += 4;
			s3 += 4;
			s4 += 4;
		}
		return false;
	default:
		return true;
	}
}

bool Audio::swapEndian(Info &info, void *buffer, unsigned samples)
{
	unsigned char buf;
	unsigned char *s1, *s2, *s3, *s4;
	if(isStereo(info.encoding))
		samples *= 2;

	switch(info.encoding)
	{
	case pcm16Mono:
	case pcm16Stereo:
	case cdaMono:
	case cdaStereo:
		if(__BYTE_ORDER == info.order || !info.order)
			return true;

		s1 = (unsigned char *)buffer;
		s2 = s1 + 1;
		while(samples--)
		{
			buf = *s1;
			*s1 = *s2;
			*s2 = buf;
			s1 += 2;
			s2 += 2;
		}
		return false;
	case pcm32Mono:
	case pcm32Stereo:
		if(__BYTE_ORDER == info.order || !info.order)
			return true;

		s1 = (unsigned char *)buffer;
		s2 = s1 + 1;
		s3 = s2 + 1;
		s4 = s3 + 1;
		while(samples--)
		{
			buf = *s1;
			*s1 = *s4;
			*s4 = buf;
			buf = *s2;
			*s2 = *s3;
			*s3 = buf;
			s1 += 4;
			s2 += 4;
			s3 += 4;
			s4 += 4;
		}
		return false;
	default:
		return true;
	}
}


bool Audio::isEndian(Encoding encoding)
{
	switch(encoding)
	{
	case cdaMono:
	case cdaStereo:
	case pcm32Mono:
	case pcm32Stereo:
	case pcm16Stereo:
	case pcm16Mono:
		if(__BYTE_ORDER != __LITTLE_ENDIAN)
			return false;
	default:
		return true;
	}
}

bool Audio::isEndian(Info &info)
{
	switch(info.encoding)
	{
	case cdaStereo:
	case cdaMono:
	case pcm16Stereo:
	case pcm16Mono:
	case pcm32Stereo:
	case pcm32Mono:
		if(info.order && __BYTE_ORDER != info.order)
			return false;
	default:
		return true;
	}
}

Audio::timeout_t Audio::getFraming(Info &info, timeout_t timeout)
{
	timeout_t fa = info.framing;
	unsigned long frames;

	if(!timeout)
		return fa;

	if(!fa)
		return timeout;

	frames = timeout / fa;
	return frames * fa;
}

Audio::timeout_t Audio::getFraming(Encoding encoding, timeout_t timeout)
{
	timeout_t fa = 0;
	unsigned long frames;
	
	switch(encoding)
	{
	case mp1Audio:
		fa = 8;
		break;
	case mp2Audio:
	case mp3Audio:
		fa = 26;
		break;
	case msgsmVoice:
		fa = 40;
		break;
	case gsmVoice:
	case speexVoice:
	case speexAudio:
		fa = 20;
		break;
	case sx96Voice:
	case sx73Voice:
		fa = 15;
	default:
		break;
	}
	if(!timeout)
		return fa;

	if(!fa)
		return timeout;

	frames = timeout / fa;
	return frames * fa;
}	

int Audio::getCount(Encoding encoding)
{
	switch(encoding)
	{
	case mp1Audio:
		return 384;
	case mp2Audio:
	case mp3Audio:
		return 1152;	
	case msgsmVoice:
		return 320;
	case gsmVoice:
		return 160;
	case sx73Voice:
	case sx96Voice:
		return 120;
	case speexVoice:
		return 160;
	case speexAudio:
		return 320;
	case unknownEncoding:
		return 0;
	case g723_2bit:
		return 4;
	case g723_3bit:
	case g723_5bit:
		return 8;
	case g721ADPCM:
	case okiADPCM:
	case voxADPCM:
		return 2;
	default:
		return 1;
	}
}

int Audio::getFrame(Encoding encoding, int samples)
{
	int framing = 0;
	switch(encoding)
	{
	case sx73Voice:
		framing = 14;
		break;
	case sx96Voice:
		framing = 18;
		break;
	case msgsmVoice:
		framing = 65;
		break;
	case speexVoice:
		framing = 20;
		break;
	case speexAudio:
		framing = 40;
		break;
	case gsmVoice:
		framing = 33;
		break;
	case g723_2bit:
		framing = 1;
		break;
	case g723_3bit:
		framing = 3;
		break;
	case g723_5bit:
		framing = 5;
		break;
	case unknownEncoding:
		return 0;
	case pcm32Stereo:
		return 8;
	case pcm32Mono:
	case pcm16Stereo:
	case cdaStereo:
		framing = 4;
		break;
	case pcm8Stereo:
	case pcm16Mono:
	case cdaMono:
		framing = 2;
		break;
	default:
		framing = 1;
	}
	if(!samples)
		return framing;

	return (samples / framing) * framing;
}

void Audio::fill(unsigned char *addr, int samples, Encoding encoding)
{
	int frame = getFrame(encoding);
	int count = getCount(encoding);

	if(!frame || !count)
		return;

	while(samples >= count)
	{
		switch(encoding)
		{
		case mulawAudio:
			*addr = 0xff;
			break;
		case alawAudio:
			*addr = 0x55;
			break;
		default:
			memset(addr, 0, frame);
			break;
		}
		addr += frame;
		samples -= count;
	}
}

Audio::Rate Audio::getRate(Encoding encoding)
{
	switch(encoding)
	{
	case pcm8Stereo:
	case pcm8Mono:
	case pcm16Stereo:
	case pcm16Mono:
	case pcm32Stereo:
	case pcm32Mono:
	case unknownEncoding:
		return rateUnknown;
	case voxADPCM:
		return rate6khz;
	case cdaStereo:
	case cdaMono:
		return rate44khz;
	case speexAudio:
		return rate16khz;
	default:
		return rate8khz;
	}
}

unsigned long Audio::toSamples(Encoding encoding, size_t bytes)
{
	unsigned long sf = getFrame(encoding);
	if(!bytes || !sf)
		return 0;
	unsigned long frames = (unsigned long)(bytes / sf);
	return frames * getCount(encoding);
}

unsigned long Audio::toSamples(Info &info, size_t bytes)
{
	if(!bytes)
		return 0;

	unsigned long frames = (unsigned long)(bytes / info.framesize);
	return frames * info.framecount;
}

size_t Audio::toBytes(Encoding encoding, unsigned long samples)
{
	unsigned long sc = getCount(encoding);
	if(!samples || !sc)
		return 0;
	unsigned long frames = samples / sc;
	return frames * getFrame(encoding);
}

size_t Audio::maxFramesize(Info &info)
{
	switch(info.encoding)
	{
	case mp1Audio:
		return 682;
	case mp2Audio:
	case mp3Audio:
		return 1735;
	default:
		return info.framesize;
	}
}

size_t Audio::toBytes(Info &info, unsigned long samples)
{
	if(!samples)
		return 0;
	unsigned long frames = samples / info.framecount;
	return frames * info.framesize;
}

bool Audio::isMono(Encoding encoding)
{
	switch(encoding)
	{
	case pcm8Stereo:
	case pcm16Stereo:
	case pcm32Stereo:
	case cdaStereo:
		return false;
	default:
		return true;
	}
}

bool Audio::isStereo(Encoding encoding)
{
	return !isMono(encoding);
}

#ifdef	WIN32
#define	snprintf _snprintf
#endif

void Audio::toTimestamp(timeout_t duration, char *buf, size_t len)
{
	timeout_t msec = duration % 1000;
	timeout_t secs = (duration / 1000) % 60;
	timeout_t mins = (duration / 60000) % 60;
	timeout_t hours = (duration /3600000);

	snprintf(buf, len, "%ld:%02ld:%02ld.%03ld", hours, mins, secs, msec);
}

Audio::timeout_t Audio::toTimeout(const char *buf)
{
	const char *cp, *sp;
	timeout_t msec = 0;
	timeout_t sec = 0;

	cp = strchr(buf, '.');
	if(cp)
	{
		msec = atol(cp + 1);
		sp = --cp;
	}
	else
		sp = strrchr(buf, ':');
	
	if(!sp)
	{
		sp = buf;
		while(*sp && isdigit(*sp))
			++sp;
		if(*sp && tolower(*sp) == 'm' && tolower(sp[1] == 's'))
			return atol(buf);
		if(tolower(*sp) == 'h')
			return atol(buf) * 3600000;
		if(tolower(*sp) == 'm')
			return atol(buf) * 60000;
		return atol(buf) * 1000l;
	}
	while(*sp != ':' && sp > buf)
		--sp;

	if(sp == buf)
		return atol(buf) * 1000 + msec;
	
	sec = atol(sp + 1) * 1000;
	--sp;
	while(*sp != ':' && sp > buf)
		--sp;
	
	if(sp == buf)
		return atol(buf) * 60000 + sec + msec;
	
	return atol(buf) * 3600000 + atol(++sp) * 60000 + sec + msec;
}	

bool Audio::loadPlugin(const char *filename)
{
#if defined(HAVE_MACH_DYLD)
	NSModule oModule;
        NSObjectFileImage oImage;
        NSSymbol sym = NULL;
        void (*init)(void);
#elif defined(HAVE_SHL_LOAD)
	shl_t image;
#elif defined(W32)
	HINSTANCE hImage;
#else
	void *image;
#endif

#if defined(WIN32)
	hImage = LoadLibrary(filename);
	if(hImage)
		return true;
#ifdef	_DEBUG
	const char *cp = strrchr(filename, '\\');
	if(!cp)
		cp = strrchr(filename, '/');
	if(!cp)
		return false;
	hImage = LoadLibrary(++cp);
	if(hImage)
		return true;
#endif

#elif defined(HAVE_MACH_DYLD)
        oModule = NULL;

        switch(NSCreateObjectFileImageFromFile(filename, &oImage))
        {
        case NSObjectFileImageSuccess:
                break;
        default:
		return false;
        }

        oModule = NSLinkModule(oImage, filename, NSLINKMODULE_OPTION_BINDNOW | NSLINKMODULE_OPTION_RETURN_ON_ERROR);
        NSDestroyObjectFileImage(oImage);
        if(oModule != NULL)
                sym = NSLookupSymbolInModule(oModule, "__init");
        if(sym)
        {
                init = (void (*)(void))NSAddressOfSymbol(sym);
                init();
        }

	if(oModule)
		return true;
#elif defined(HAVE_SHL_LOAD)
	image = shl_load(filename, BIND_IMMEDIATE, 0l);
	if(image)
		return true;
#elif defined(HAVE_MODULES)
	image = dlopen(filename, RTLD_NOW | RTLD_GLOBAL);
	if(image)
		return true;
#endif
	return false;
}

// if no soundcard hardware, we don't bind soundcard fetch

#if	!defined(HAVE_SYS_SOUNDCARD_H) && !defined(W32) && !defined(OSX_AUDIO)

bool Audio::hasDevice(unsigned index)
{
	return false;
}

AudioDevice *Audio::getDevice(unsigned index, DeviceMode mode)
{
	return NULL;
}

#endif