bool cAudioCapture::initialize(const char* deviceName, unsigned int frequency, AudioFormats format, unsigned int internalBufferSize)
{
cAudioMutexBasicLock lock(Mutex);
DeviceName = fromUTF8(deviceName);
Frequency = frequency;
InternalBufferSize = internalBufferSize;
Format = format;
if(Format == EAF_8BIT_MONO)
SampleSize = 1;
else if(Format == EAF_8BIT_STEREO)
SampleSize = 2;
else if(Format == EAF_16BIT_MONO)
SampleSize = 2;
else
SampleSize = 4;
shutdownOpenALDevice();
signalEvent(ON_INIT);
bool isInit = initOpenALDevice();
#ifdef CAUDIO_USE_INTERNAL_THREAD
if (!AudioThread)
{
AudioThread = new cAudioThread(this);
}
AudioThread->start();
#endif
return isInit;
}
void cAudioCapture::updateCaptureBuffer(bool force)
{
cAudioMutexBasicLock lock(Mutex);
if(Capturing && CaptureDevice && Ready)
{
int AvailableSamples = 0;
alcGetIntegerv(CaptureDevice, ALC_CAPTURE_SAMPLES, 1, &AvailableSamples);
const unsigned int availbuffersize = AvailableSamples * SampleSize;
//If the samples in the OpenAL buffer are more than half of its max size, grab them
if(availbuffersize > InternalBufferSize / 2 || force)
{
//Fixes a bug with the capture being forced, but no data being available
if(availbuffersize > 0)
{
const unsigned int oldBufferSize = CaptureBuffer.size();
CaptureBuffer.resize(oldBufferSize + availbuffersize, 0);
alcCaptureSamples(CaptureDevice, &CaptureBuffer[oldBufferSize], AvailableSamples);
checkError();
getLogger()->logDebug("AudioCapture", "Captured %i bytes of audio data.", availbuffersize);
signalEvent(ON_UPDATE);
}
}
}
}
void cAudioCapture::stopCapture()
{
cAudioMutexBasicLock lock(Mutex);
if(CaptureDevice && Ready)
{
alcCaptureStop(CaptureDevice);
updateCaptureBuffer(true);
checkError();
getLogger()->logDebug("AudioCapture", "OpenAL Capture Stopped.");
signalEvent(ON_ENDCAPTURE);
}
Capturing = false;
}
void cAudioCapture::shutdown()
{
cAudioMutexBasicLock lock(Mutex);
if (AudioThread)
{
AudioThread->join();
delete AudioThread;
AudioThread = NULL;
}
shutdownOpenALDevice();
signalEvent(ON_RELEASE);
}
unsigned int cAudioCapture::getCapturedAudio(void* outputBuffer, unsigned int outputBufferSize)
{
cAudioMutexBasicLock lock(Mutex);
unsigned int internalBufferSize = CaptureBuffer.size();
if(outputBuffer && outputBufferSize > 0 && internalBufferSize > 0)
{
int sizeToCopy = (outputBufferSize >= internalBufferSize) ? internalBufferSize : outputBufferSize;
memcpy(outputBuffer, &CaptureBuffer[0], sizeToCopy);
CaptureBuffer.erase(CaptureBuffer.begin(), CaptureBuffer.begin()+sizeToCopy);
getLogger()->logDebug("AudioCapture", "Copied out %i bytes of data out of %i bytes in the buffer at user request.", sizeToCopy, internalBufferSize);
signalEvent(ON_USERREQUESTEDBUFFER);
return sizeToCopy;
}
return 0;
}
void cAudioCapture::shutdownOpenALDevice()
{
cAudioMutexBasicLock lock(Mutex);
if(Capturing)
stopCapture();
if(CaptureDevice)
{
alcCaptureCloseDevice(CaptureDevice);
CaptureDevice = NULL;
Ready = false;
getLogger()->logDebug("AudioCapture", "OpenAL Capture Device Closed.");
signalEvent(ON_RELEASE);
}
checkError();
CaptureBuffer.clear();
}
void ReplicationExecutor::run() {
_networkInterface->startup();
_dblockWorkers.startThreads();
std::pair<WorkItem, CallbackHandle> work;
while ((work = getWork()).first.callback) {
{
boost::lock_guard<boost::mutex> lk(_terribleExLockSyncMutex);
const Status inStatus = work.first.isCanceled ?
Status(ErrorCodes::CallbackCanceled, "Callback canceled") :
Status::OK();
makeNoExcept(stdx::bind(work.first.callback,
CallbackData(this, work.second, inStatus)))();
}
signalEvent(work.first.finishedEvent);
}
finishShutdown();
_networkInterface->shutdown();
}
bool cAudioCapture::beginCapture()
{
cAudioMutexBasicLock lock(Mutex);
if(!Capturing)
{
CaptureBuffer.clear();
if(CaptureDevice && Ready)
{
alcCaptureStart(CaptureDevice);
Capturing = true;
getLogger()->logDebug("AudioCapture", "OpenAL Capture Started.");
signalEvent(ON_BEGINCAPTURE);
}
checkError();
return Capturing;
}
checkError();
return false;
}
void QWidgetExtended::mouseMoveEvent(QMouseEvent *event) {
signalEvent(event, MOVED);
}
void QWidgetExtended::mouseReleaseEvent(QMouseEvent *event) {
signalEvent(event, RELEASED);
}
void QWidgetExtended::mousePressEvent(QMouseEvent *event) {
signalEvent(event, PRESSED);
}
//*************************************************************************************************
//Main part of the macro
//*************************************************************************************************
void HWWDistributions(const string signalInputFilename, const string bkgInputFilename,
int OnlyThisFinalState = -1,
const string SignalName = "", const string cutValuesFile = "") {
TTree* signalTree = getTreeFromFile(signalInputFilename.c_str(),"all");
TTree* bkgTree = getTreeFromFile(bkgInputFilename.c_str(),"all");
assert(signalTree);
assert(bkgTree);
CheckInitialCutValueConsistency();
//Load cut values from a root file;
if (cutValuesFile != "" && SignalName != "")
LoadCutValues(cutValuesFile, SignalName);
//Summarize Cuts
cout << "*********************************************************************\n";
cout << "** Load Cut Values from file " << cutValuesFile << endl;
cout << "*********************************************************************\n";
cout << "Final Cuts" << endl;
cout << "*************************************************************************" << endl;
for (int f=0; f<=2;f++) {
cout << "Final State : " << finalstatestring[f] << endl;
for (int v = 0; v < NVARIABLES;v++) {
cout << fVariableNames[v] << " : ";
if (fCutBelow[v])
cout << fCutBelowInitialValue[f][v];
else
cout << "-Infinity ";
cout << " -> ";
if (fCutAbove[v])
cout << fCutAboveInitialValue[f][v];
else
cout << " Infinity ";
cout << endl;
}
cout << "----------------------------------------------------------------------" << endl;
}
MitNtupleEvent signalEvent(signalTree);
MitNtupleEvent bkgEvent(bkgTree);
cout << "*************************************************************************" << endl;
cout << "Make Distribution Plots" << endl;
cout << "*************************************************************************" << endl;
if (OnlyThisFinalState == -1) {
for (int f=10; f<=12;f++) {
MakeStackedDistributionPlots(&signalEvent , &bkgEvent , signalTree->GetEntries(),
bkgTree->GetEntries(), f);
}
} else {
MakeStackedDistributionPlots(&signalEvent , &bkgEvent , signalTree->GetEntries(),
bkgTree->GetEntries(), OnlyThisFinalState);
}
cout << "*************************************************************************" << endl;
cout << "Print Final Results" << endl;
cout << "*************************************************************************" << endl;
if (OnlyThisFinalState == -1) {
for (int f=10; f<=12;f++) {
PrintFinalResults(&signalEvent , &bkgEvent , signalTree->GetEntries(),
bkgTree->GetEntries(), f);
}
} else {
PrintFinalResults(&signalEvent , &bkgEvent , signalTree->GetEntries(),
bkgTree->GetEntries(), OnlyThisFinalState);
}
}
