MediaStreamItf.cpp

//
// libtgvoip is free and unencumbered public domain software.
// For more information, see http://unlicense.org or the UNLICENSE file
// you should have received with this source code distribution.
//

#include "logging.h"
#include "MediaStreamItf.h"
#include "EchoCanceller.h"
#include <stdint.h>
#include <algorithm>
#include <math.h>
#include <assert.h>

using namespace tgvoip;

void MediaStreamItf::SetCallback(size_t (*f)(unsigned char *, size_t, void*), void* param){
	callback=f;
	callbackParam=param;
}

size_t MediaStreamItf::InvokeCallback(unsigned char *data, size_t length){
	if(callback)
		return (*callback)(data, length, callbackParam);
	return 0;
}

AudioMixer::AudioMixer() : bufferPool(960*2, 16), processedQueue(16), semaphore(16, 0){
	running=false;
}

AudioMixer::~AudioMixer(){
}

void AudioMixer::SetOutput(MediaStreamItf* output){
	output->SetCallback(OutputCallback, this);
}

void AudioMixer::Start(){
	assert(!running);
	running=true;
	thread=new Thread(std::bind(&AudioMixer::RunThread, this));
	thread->SetName("AudioMixer");
	thread->Start();
}

void AudioMixer::Stop(){
	if(!running){
		LOGE("Tried to stop AudioMixer that wasn't started");
		return;
	}
	running=false;
	semaphore.Release();
	thread->Join();
	delete thread;
	thread=NULL;
}

void AudioMixer::DoCallback(unsigned char *data, size_t length){
	//memset(data, 0, 960*2);
	//LOGD("audio mixer callback, %d inputs", inputs.size());
	if(processedQueue.Size()==0)
		semaphore.Release(2);
	else
		semaphore.Release();
	unsigned char* buf=processedQueue.GetBlocking();
	memcpy(data, buf, 960*2);
	bufferPool.Reuse(buf);
}

size_t AudioMixer::OutputCallback(unsigned char *data, size_t length, void *arg){
	((AudioMixer*)arg)->DoCallback(data, length);
	return 960*2;
}

void AudioMixer::AddInput(std::shared_ptr<MediaStreamItf> input){
	MutexGuard m(inputsMutex);
	MixerInput in;
	in.multiplier=1;
	in.source=input;
	inputs.push_back(in);
}

void AudioMixer::RemoveInput(std::shared_ptr<MediaStreamItf> input){
	MutexGuard m(inputsMutex);
	for(std::vector<MixerInput>::iterator i=inputs.begin();i!=inputs.end();++i){
		if(i->source==input){
			inputs.erase(i);
			return;
		}
	}
}

void AudioMixer::SetInputVolume(std::shared_ptr<MediaStreamItf> input, float volumeDB){
	MutexGuard m(inputsMutex);
	for(std::vector<MixerInput>::iterator i=inputs.begin();i!=inputs.end();++i){
		if(i->source==input){
			if(volumeDB==-INFINITY)
				i->multiplier=0;
			else
				i->multiplier=expf(volumeDB/20.0f * logf(10.0f));
			return;
		}
	}
}

void AudioMixer::RunThread(){
	LOGV("AudioMixer thread started");
	while(running){
		semaphore.Acquire();
		if(!running)
			break;

		unsigned char* data=bufferPool.Get();
		//LOGV("Audio mixer processing a frame");
		if(!data){
			LOGE("AudioMixer: no buffers left");
			continue;
		}
		MutexGuard m(inputsMutex);
		int16_t* buf=reinterpret_cast<int16_t*>(data);
		int16_t input[960];
		float out[960];
		memset(out, 0, 960*4);
		int usedInputs=0;
		for(std::vector<MixerInput>::iterator in=inputs.begin();in!=inputs.end();++in){
			size_t res=in->source->InvokeCallback(reinterpret_cast<unsigned char*>(input), 960*2);
			if(!res || in->multiplier==0){
				//LOGV("AudioMixer: skipping silent packet");
				continue;
			}
			usedInputs++;
			float k=in->multiplier;
			if(k!=1){
				for(size_t i=0; i<960; i++){
					out[i]+=(float)input[i]*k;
				}
			}else{
				for(size_t i=0;i<960;i++){
					out[i]+=(float)input[i];
				}
			}
		}
		if(usedInputs>0){
			for(size_t i=0; i<960; i++){
				if(out[i]>32767.0f)
					buf[i]=INT16_MAX;
				else if(out[i]<-32768.0f)
					buf[i]=INT16_MIN;
				else
					buf[i]=(int16_t)out[i];
			}
		}else{
			memset(data, 0, 960*2);
		}
		if(echoCanceller)
			echoCanceller->SpeakerOutCallback(data, 960*2);
		processedQueue.Put(data);
	}
	LOGI("======== audio mixer thread exiting =========");
}

void AudioMixer::SetEchoCanceller(EchoCanceller *aec){
	echoCanceller=aec;
}

AudioLevelMeter::AudioLevelMeter(){
	absMax=0;
	count=0;
	currentLevel=0;
	currentLevelFullRange=0;
}

float AudioLevelMeter::GetLevel(){
	return currentLevel/9.0f;
}

void AudioLevelMeter::Update(int16_t *samples, size_t count){
	// Number of bars on the indicator.
	// Note that the number of elements is specified because we are indexing it
	// in the range of 0-32
	const int8_t permutation[33]={0,1,2,3,4,4,5,5,5,5,6,6,6,6,6,7,7,7,7,8,8,8,9,9,9,9,9,9,9,9,9,9,9};
	int16_t absValue=0;
	for(unsigned int k=0;k<count;k++){
		int16_t absolute=(int16_t)abs(samples[k]);
		if (absolute>absValue)
			absValue=absolute;
	}

	if(absValue>absMax)
		absMax = absValue;
	// Update level approximately 10 times per second
	if (this->count++==10){
		currentLevelFullRange=absMax;
		this->count=0;
		// Highest value for a int16_t is 0x7fff = 32767
		// Divide with 1000 to get in the range of 0-32 which is the range of
		// the permutation vector
		int32_t position=absMax/1000;
		// Make it less likely that the bar stays at position 0. I.e. only if
		// its in the range 0-250 (instead of 0-1000)
		/*if ((position==0) && (absMax>250)){
			position=1;
		}*/
		currentLevel=permutation[position];
		// Decay the absolute maximum (divide by 4)
		absMax >>= 2;
	}
}