void NoSpacesProcessor::processText()
{
QFile file(m_filename);
if(!file.open(QIODevice::ReadOnly)) {
emit error(tr("Could not open file %1").arg(m_filename));
return;
}
const int totalLineCount = detectLineCount();
int lineNumber(1);
while(!file.atEnd()) {
emit progress(lineNumber,totalLineCount,tr("Parsing text with no spaces"));
QByteArray line = file.readLine();
emit lineFound(line, lineNumber);
line = line.simplified();
if(line.isEmpty()) {
++lineNumber;
continue;
}
for(int pos=0;pos<line.count();++pos) {
emit progress(pos,line.count(),tr("Line %1 of %2").arg(lineNumber).arg(totalLineCount));
for(int len=1;len<14;++len) {
emit combinationFound(processorName(),line.mid(pos,len),lineNumber);
}
}
//emit combinationFound(processorName(), word,lineNumber);
++lineNumber;
}
file.close();
}
void BatchProcessing::ThreadHandler(void *args)
{
SetThreadName("orka:batch");
CStdString debug;
CStdString logMsg;
CStdString processorName("BatchProcessing");
TapeProcessorRef batchProcessing = TapeProcessorRegistry::instance()->GetNewTapeProcessor(processorName);
if(batchProcessing.get() == NULL)
{
LOG4CXX_ERROR(LOG.batchProcessingLog, "Could not instanciate BatchProcessing");
return;
}
BatchProcessing* pBatchProcessing = (BatchProcessing*)(batchProcessing->Instanciate().get());
pBatchProcessing->SetQueueSize(CONFIG.m_batchProcessingQueueSize);
int threadId = 0;
{
MutexSentinel sentinel(pBatchProcessing->m_mutex);
threadId = pBatchProcessing->m_threadCount++;
}
CStdString threadIdString = IntToString(threadId);
debug.Format("thread Th%s starting - queue size:%d", threadIdString, CONFIG.m_batchProcessingQueueSize);
LOG4CXX_INFO(LOG.batchProcessingLog, debug);
bool stop = false;
for(;stop == false;)
{
AudioFileRef fileRef;
AudioFileRef outFileRef, outFileSecondaryRef;
AudioTapeRef audioTapeRef;
CStdString trackingId = "[no-trk]";
try
{
audioTapeRef = pBatchProcessing->m_audioTapeQueue.pop();
if(audioTapeRef.get() == NULL)
{
if(Daemon::Singleton()->IsStopping())
{
stop = true;
}
if(Daemon::Singleton()->GetShortLived())
{
Daemon::Singleton()->Stop();
}
}
else
{
fileRef = audioTapeRef->GetAudioFileRef();
trackingId = audioTapeRef->m_trackingId;
audioTapeRef->m_audioOutputPath = CONFIG.m_audioOutputPath;
// Let's work on the tape we have pulled
//CStdString threadIdString = IntToString(threadId);
LOG4CXX_INFO(LOG.batchProcessingLog, "[" + trackingId + "] Th" + threadIdString + " processing " + audioTapeRef->GetIdentifier() + " localside:" + CaptureEvent::LocalSideToString(audioTapeRef->m_localSide) + " audiokeepdirection:" + CaptureEvent::AudioKeepDirectionToString(audioTapeRef->m_audioKeepDirectionEnum));
if(audioTapeRef->m_audioKeepDirectionEnum == CaptureEvent::AudioKeepDirectionInvalid)
{
LOG4CXX_WARN(LOG.batchProcessingLog, "[" + trackingId +
"] Th" + threadIdString +
" invalid audiokeepdirection:" +
IntToString(audioTapeRef->m_audioKeepDirectionEnum));
}
//fileRef->MoveOrig(); // #### could do this only when original and output file have the same extension. Irrelevant for now as everything is captured as mcf file
fileRef->Open(AudioFile::READ);
AudioChunkRef chunkRef;
AudioChunkRef tmpChunkRef, tmpChunkSecondaryRef;
unsigned int frameSleepCounter;
frameSleepCounter = 0;
switch(CONFIG.m_storageAudioFormat)
{
case FfUlaw:
outFileRef.reset(new LibSndFileFile(SF_FORMAT_ULAW | SF_FORMAT_WAV));
break;
case FfAlaw:
outFileRef.reset(new LibSndFileFile(SF_FORMAT_ALAW | SF_FORMAT_WAV));
break;
case FfGsm:
outFileRef.reset(new LibSndFileFile(SF_FORMAT_GSM610 | SF_FORMAT_WAV));
break;
case FfPcmWav:
default:
outFileRef.reset(new LibSndFileFile(SF_FORMAT_PCM_16 | SF_FORMAT_WAV));
}
if(CONFIG.m_stereoRecording == true)
{
outFileRef->SetNumOutputChannels(2);
}
FilterRef rtpMixer, rtpMixerSecondary;
FilterRef decoder1;
FilterRef decoder2;
FilterRef decoder;
FilterRef audiogain;
std::bitset<RTP_PAYLOAD_TYPE_MAX> seenRtpPayloadTypes;
std::vector<FilterRef> decoders1;
std::vector<FilterRef> decoders2;
for(int pt=0; pt<RTP_PAYLOAD_TYPE_MAX; pt++)
{
decoder1 = FilterRegistry::instance()->GetNewFilter(pt);
decoders1.push_back(decoder1);
decoder2 = FilterRegistry::instance()->GetNewFilter(pt);
decoders2.push_back(decoder2);
}
bool firstChunk = true;
bool voIpSession = false;
size_t numSamplesS1 = 0;
size_t numSamplesS2 = 0;
size_t numSamplesOut = 0;
CStdString filterName("AudioGain");
audiogain = FilterRegistry::instance()->GetNewFilter(filterName);
if(audiogain.get() == NULL)
{
debug = "Could not instanciate AudioGain rtpMixer";
throw(debug);
}
bool forceChannel1 = false;
while(fileRef->ReadChunkMono(chunkRef))
{
// ############ HACK
//ACE_Time_Value yield;
//yield.set(0,1);
//ACE_OS::sleep(yield);
// ############ HACK
AudioChunkDetails details = *chunkRef->GetDetails();
int channelToSkip = 0;
if(CONFIG.m_directionLookBack == true) //if DirectionLookBack is not enable, DirectionSelector Tape should have taken care everything
{
if(BatchProcessing::SkipChunk(audioTapeRef, chunkRef, channelToSkip) == true)
{
LOG4CXX_DEBUG(LOG.batchProcessingLog, "[" + trackingId +
"] Th" + threadIdString +
" skipping chunk of channel:" +
IntToString(details.m_channel));
if(forceChannel1 == false)
{
if(channelToSkip == 1)
{
forceChannel1 = true;
}
}
continue;
}
}
if(forceChannel1 == true)
{
details.m_channel = 1;
chunkRef->SetDetails(&details);
}
decoder.reset();
if(details.m_rtpPayloadType < -1 || details.m_rtpPayloadType >= RTP_PAYLOAD_TYPE_MAX)
{
logMsg.Format("RTP payload type out of bound:%d", details.m_rtpPayloadType);
LOG4CXX_DEBUG(LOG.batchProcessingLog, "[" + trackingId + "] Th" + threadIdString + " " + logMsg);
continue;
}
// Instanciate any decoder we might need during a VoIP session
if(details.m_rtpPayloadType != -1)
{
voIpSession = true;
if(details.m_channel == 2)
{
decoder2 = decoders2.at(details.m_rtpPayloadType);
decoder = decoder2;
}
else
{
decoder1 = decoders1.at(details.m_rtpPayloadType);
decoder = decoder1;
}
bool ptAlreadySeen = seenRtpPayloadTypes.test(details.m_rtpPayloadType);
seenRtpPayloadTypes.set(details.m_rtpPayloadType);
if(decoder.get() == NULL)
{
if(ptAlreadySeen == false)
{
// First time we see a particular unsupported payload type in this session, log it
CStdString rtpPayloadType = IntToString(details.m_rtpPayloadType);
LOG4CXX_ERROR(LOG.batchProcessingLog, "[" + trackingId + "] Th" + threadIdString + " unsupported RTP payload type:" + rtpPayloadType);
}
// We cannot decode this chunk due to unknown codec, go to next chunk
continue;
}
else if(ptAlreadySeen == false)
{
// First time we see a particular supported payload type in this session, log it
CStdString rtpPayloadType = IntToString(details.m_rtpPayloadType);
LOG4CXX_INFO(LOG.batchProcessingLog, "[" + trackingId + "] Th" + threadIdString + " RTP payload type:" + rtpPayloadType);
}
}
if(!voIpSession || (firstChunk && decoder.get()))
{
firstChunk = false;
// At this point, we know we have a working codec, create an RTP mixer and open the output file
if(voIpSession)
{
CStdString filterName("RtpMixer");
rtpMixer = FilterRegistry::instance()->GetNewFilter(filterName);
if(rtpMixer.get() == NULL)
{
debug = "Could not instanciate RTP mixer";
throw(debug);
}
if(CONFIG.m_stereoRecording == true)
{
rtpMixer->SetNumOutputChannels(2);
}
rtpMixer->SetSessionInfo(trackingId);
//create another rtpmixer to store stereo audio
if(CONFIG.m_audioOutputPathSecondary.length() > 3)
{
outFileSecondaryRef.reset(new LibSndFileFile(SF_FORMAT_PCM_16 | SF_FORMAT_WAV));
outFileSecondaryRef->SetNumOutputChannels(2);
rtpMixerSecondary = FilterRegistry::instance()->GetNewFilter(filterName);
if(rtpMixerSecondary.get() == NULL)
{
debug = "Could not instanciate RTP mixer";
throw(debug);
}
rtpMixerSecondary->SetNumOutputChannels(2);
rtpMixerSecondary->SetSessionInfo(trackingId);
}
}
CStdString path = audioTapeRef->m_audioOutputPath + "/" + audioTapeRef->GetPath();
FileRecursiveMkdir(path, CONFIG.m_audioFilePermissions, CONFIG.m_audioFileOwner, CONFIG.m_audioFileGroup, audioTapeRef->m_audioOutputPath);
CStdString file = path + "/" + audioTapeRef->GetIdentifier();
outFileRef->Open(file, AudioFile::WRITE, false, fileRef->GetSampleRate());
if(CONFIG.m_audioOutputPathSecondary.length() > 3)
{
path = CONFIG.m_audioOutputPathSecondary + "/" + audioTapeRef->GetPath();
FileRecursiveMkdir(path, CONFIG.m_audioFilePermissions, CONFIG.m_audioFileOwner, CONFIG.m_audioFileGroup, CONFIG.m_audioOutputPathSecondary);
CStdString storageFile = path + "/" + audioTapeRef->GetIdentifier();
outFileSecondaryRef->Open(storageFile, AudioFile::WRITE, false, fileRef->GetSampleRate());
}
}
if(voIpSession)
{
if(details.m_channel == 2)
{
decoder2->AudioChunkIn(chunkRef);
decoder2->AudioChunkOut(tmpChunkRef);
if(tmpChunkRef.get())
{
numSamplesS2 += tmpChunkRef->GetNumSamples();
}
if(rtpMixerSecondary.get() != NULL)
{
decoder2->AudioChunkOut(tmpChunkSecondaryRef);
}
}
else
{
decoder1->AudioChunkIn(chunkRef);
decoder1->AudioChunkOut(tmpChunkRef);
if(tmpChunkRef.get())
{
numSamplesS1 += tmpChunkRef->GetNumSamples();
}
if(rtpMixerSecondary.get() != NULL)
{
decoder1->AudioChunkOut(tmpChunkSecondaryRef);
}
}
audiogain->AudioChunkIn(tmpChunkRef);
audiogain->AudioChunkOut(tmpChunkRef);
rtpMixer->AudioChunkIn(tmpChunkRef);
rtpMixer->AudioChunkOut(tmpChunkRef);
if(rtpMixerSecondary.get() != NULL)
{
rtpMixerSecondary->AudioChunkIn(tmpChunkSecondaryRef);
rtpMixerSecondary->AudioChunkOut(tmpChunkSecondaryRef);
}
} else {
audiogain->AudioChunkIn(tmpChunkRef);
audiogain->AudioChunkOut(tmpChunkRef);
}
outFileRef->WriteChunk(tmpChunkRef);
if(rtpMixerSecondary.get() != NULL)
{
outFileSecondaryRef->WriteChunk(tmpChunkSecondaryRef);
}
if(tmpChunkRef.get())
{
numSamplesOut += tmpChunkRef->GetNumSamples();
}
if(CONFIG.m_batchProcessingEnhancePriority == false)
{
// Give up CPU between every audio buffer to make sure the actual recording always has priority
//ACE_Time_Value yield;
//yield.set(0,1); // 1 us
//ACE_OS::sleep(yield);
// Use this instead, even if it still seems this holds the whole process under Linux instead of this thread only.
struct timespec ts;
ts.tv_sec = 0;
ts.tv_nsec = 1;
ACE_OS::nanosleep (&ts, NULL);
}
if(CONFIG.m_transcodingSleepEveryNumFrames > 0 && CONFIG.m_transcodingSleepUs > 0)
{
if(frameSleepCounter >= (unsigned int)CONFIG.m_transcodingSleepEveryNumFrames)
{
frameSleepCounter = 0;
struct timespec ts;
ts.tv_sec = 0;
ts.tv_nsec = CONFIG.m_transcodingSleepUs*1000;
ACE_OS::nanosleep (&ts, NULL);
}
else
{
frameSleepCounter += 1;
}
}
}
if(voIpSession && !firstChunk)
{
// Flush the RTP mixer
AudioChunkRef stopChunk(new AudioChunk());
stopChunk->GetDetails()->m_marker = MEDIA_CHUNK_EOS_MARKER;
rtpMixer->AudioChunkIn(stopChunk);
rtpMixer->AudioChunkOut(tmpChunkRef);
if(rtpMixerSecondary.get() != NULL)
{
rtpMixerSecondary->AudioChunkOut(tmpChunkSecondaryRef);
}
while(tmpChunkRef.get())
{
outFileRef->WriteChunk(tmpChunkRef);
numSamplesOut += tmpChunkRef->GetNumSamples();
rtpMixer->AudioChunkOut(tmpChunkRef);
}
while(tmpChunkSecondaryRef.get())
{
outFileSecondaryRef->WriteChunk(tmpChunkSecondaryRef);
rtpMixerSecondary->AudioChunkOut(tmpChunkSecondaryRef);
}
}
fileRef->Close();
outFileRef->Close();
if(rtpMixerSecondary.get() != NULL)
{
outFileSecondaryRef->Close();
}
logMsg.Format("[%s] Th%s stop: num samples: s1:%u s2:%u out:%u queueSize:%d", trackingId, threadIdString, numSamplesS1, numSamplesS2, numSamplesOut, pBatchProcessing->m_audioTapeQueue.numElements());
LOG4CXX_INFO(LOG.batchProcessingLog, logMsg);
CStdString audioFilePath = audioTapeRef->m_audioOutputPath + "/" + audioTapeRef->GetPath();
CStdString audioFileName;
CStdString storageFilePath, storageFileName;
if(CONFIG.m_audioOutputPathSecondary.length() > 3)
{
storageFilePath = CONFIG.m_audioOutputPathSecondary + "/" + audioTapeRef->GetPath();
storageFileName = storageFilePath + "/" + audioTapeRef->GetIdentifier() + outFileRef->GetExtension();
}
audioFileName = audioFilePath + "/" + audioTapeRef->GetIdentifier() + outFileRef->GetExtension();
if(CONFIG.m_audioFilePermissions) {
if(FileSetPermissions(audioFileName, CONFIG.m_audioFilePermissions))
{
CStdString logMsg;
logMsg.Format("Error setting permissions of %s to %o: %s", audioFileName.c_str(), CONFIG.m_audioFilePermissions, strerror(errno));
LOG4CXX_ERROR(LOG.batchProcessingLog, "[" + trackingId + "] Th" + threadIdString + " " + logMsg);
}
if(storageFileName.length() > 5)
{
if(FileSetPermissions(storageFileName, CONFIG.m_audioFilePermissions))
{
CStdString logMsg;
logMsg.Format("Error setting permissions of %s to %o: %s", storageFileName.c_str(), CONFIG.m_audioFilePermissions, strerror(errno));
LOG4CXX_ERROR(LOG.batchProcessingLog, "[" + trackingId + "] Th" + threadIdString + " " + logMsg);
}
}
}
if(CONFIG.m_audioFileGroup.size() && CONFIG.m_audioFileOwner.size()) {
if(FileSetOwnership(audioFileName, CONFIG.m_audioFileOwner, CONFIG.m_audioFileGroup))
{
logMsg.Format("Error setting ownership and group of %s to %s:%s: %s", audioFileName.c_str(), CONFIG.m_audioFileOwner, CONFIG.m_audioFileGroup, strerror(errno));
LOG4CXX_ERROR(LOG.batchProcessingLog, "[" + trackingId + "] Th" + threadIdString + " " + logMsg);
}
if(storageFileName.length() > 5)
{
if(FileSetOwnership(storageFileName, CONFIG.m_audioFileOwner, CONFIG.m_audioFileGroup))
{
logMsg.Format("Error setting ownership and group of %s to %s:%s: %s", storageFileName.c_str(), CONFIG.m_audioFileOwner, CONFIG.m_audioFileGroup, strerror(errno));
LOG4CXX_ERROR(LOG.batchProcessingLog, "[" + trackingId + "] Th" + threadIdString + " " + logMsg);
}
}
}
if(CONFIG.m_deleteNativeFile && numSamplesOut)
{
fileRef->Delete();
LOG4CXX_INFO(LOG.batchProcessingLog, "[" + trackingId + "] Th" + threadIdString + " deleting native: " + audioTapeRef->GetIdentifier());
}
else if(CONFIG.m_deleteFailedCaptureFile)
{
fileRef->Delete();
if(outFileRef.get())
{
outFileRef->Close();
outFileRef->Delete();
}
LOG4CXX_INFO(LOG.batchProcessingLog, "[" + trackingId + "] Th" + threadIdString + " deleting native that could not be transcoded: " + audioTapeRef->GetIdentifier());
}
// Finished processing the tape, pass on to next processor
if(numSamplesOut)
{
pBatchProcessing->RunNextProcessor(audioTapeRef);
}
}
}
catch (CStdString& e)
{
LOG4CXX_ERROR(LOG.batchProcessingLog, "[" + trackingId + "] Th" + threadIdString + " " + e);
if(fileRef.get()) {fileRef->Close();}
if(outFileRef.get()) {outFileRef->Close();}
if(CONFIG.m_deleteFailedCaptureFile && fileRef.get() != NULL)
{
LOG4CXX_INFO(LOG.batchProcessingLog, "[" + trackingId + "] Th" + threadIdString + " deleting native and transcoded");
if(fileRef.get()) {fileRef->Delete();}
if(outFileRef.get()) {outFileRef->Delete();}
}
}
//catch(...)
//{
// LOG4CXX_ERROR(LOG.batchProcessingLog, CStdString("unknown exception"));
//}
}
LOG4CXX_INFO(LOG.batchProcessingLog, CStdString("Exiting thread Th" + threadIdString));
}
// the exposed libscalpel API
// NOTE: This function is deprecated and will be removed. Use the
// libscalpel_* functions instead.
// TODO make the driver in scalpel_exec.c use this (minor refactoring needed)
// TODO add support for the remaining options avail from cmd-line
// returns SCALPEL_OK on no error, can throw runtime_error exception on errors
int scalpel_carveSingleInput(ScalpelInputReader * const reader, const char * const confFilePath,
const char * const outDir, const unsigned char generateFooterDb,
const unsigned char handleEmbedded, const unsigned char organizeSubdirs,
const unsigned char previewMode,
const unsigned char carveWithMissingFooters,
const unsigned char noSearchOverlap) throw (std::runtime_error) {
if (!reader || ! confFilePath || ! outDir) {
//invalid args
throw std::runtime_error("Invalid empty arguments");
}
if (!reader->dataSource || !reader->id) {
throw std::runtime_error("Invalid empty input reader arguments");
}
//check fns
if (!reader->open || !reader->read || !reader->seeko || !reader->tello
|| !reader->close || !reader->getError || !reader->getSize) {
throw std::runtime_error("Reader callbacks not setup");
}
struct scalpelState state;
std::string processorName ("scalpel_carveSingleInput()");
char * args[5];
args[0] = const_cast<char*> ( processorName.c_str());
args[1] = reader->id;
args[2] = const_cast<char*> (confFilePath);
args[3] = const_cast<char*> (outDir);
args[4] = 0;
initializeState(args, &state);
//setup input
state.inReader = reader;
//setup options
const size_t outDirLen = strlen(outDir);
strncpy(state.outputdirectory, outDir, outDirLen);
state.outputdirectory[outDirLen] = 0;
const size_t confFilePathLen = strlen(confFilePath);
strncpy(state.conffile, confFilePath, confFilePathLen);
state.conffile[confFilePathLen] = 0;
state.generateHeaderFooterDatabase = generateFooterDb;
state.handleEmbedded = handleEmbedded;
state.organizeSubdirectories = organizeSubdirs;
state.previewMode = previewMode;
state.carveWithMissingFooters = carveWithMissingFooters;
state.noSearchOverlap = noSearchOverlap;
convertFileNames(&state);
// read configuration file
int err;
if ((err = readSearchSpecFile(&state))) {
// problem with config file
handleError(&state, err); //can throw
freeState(&state);
std::stringstream ss;
ss << "Error reading spec file, error code: " << err;
throw std::runtime_error(ss.str());
}
// prepare audit file and make sure output directory is empty.
if ((err = openAuditFile(&state))) {
handleError(&state, err); //can throw
freeState(&state);
std::stringstream ss;
ss << "Error opening audit file, error code: " << err;
throw std::runtime_error(ss.str());
}
// Initialize the backing store of buffer to read-in, process image data.
init_store();
// Initialize threading model for cpu or gpu search.
init_threading_model(&state);
if ((err = digImageFile(&state))) {
handleError(&state, err); //can throw
closeAuditFile(state.auditFile);
destroyStore();
freeState(&state);
std::stringstream ss;
ss << "Error digging file, error code: " << err;
throw std::runtime_error(ss.str());
}
if ((err = carveImageFile(&state))) {
handleError(&state, err); //can throw
closeAuditFile(state.auditFile);
destroy_threading_model(&state);
destroyStore();
freeState(&state);
std::stringstream ss;
ss << "Error carving file, error code: " << err;
throw std::runtime_error(ss.str());
}
closeAuditFile(state.auditFile);
destroy_threading_model(&state);
destroyStore();
freeState(&state);
return SCALPEL_OK;
}
void DirectionSelector::ThreadHandler(void *args)
{
SetThreadName("orka:ds");
CStdString debug;
CStdString logMsg;
CStdString processorName("DirectionSelector");
TapeProcessorRef directionSelector = TapeProcessorRegistry::instance()->GetNewTapeProcessor(processorName);
if(directionSelector.get() == NULL)
{
LOG4CXX_ERROR(LOG.directionSelectorLog, "Could not instanciate DirectionSelector");
return;
}
DirectionSelector* pDirectionSelector = (DirectionSelector*)(directionSelector->Instanciate().get());
pDirectionSelector->SetQueueSize(CONFIG.m_directionSelectorQueueSize);
int threadId = 0;
{
MutexSentinel sentinel(pDirectionSelector->m_mutex);
threadId = pDirectionSelector->m_threadCount++;
}
CStdString threadIdString = IntToString(threadId);
debug.Format("thread Th%s starting - queue size:%d", threadIdString, CONFIG.m_directionSelectorQueueSize);
LOG4CXX_INFO(LOG.directionSelectorLog, debug);
pDirectionSelector->LoadAreaCodesMap();
bool stop = false;
for(;stop == false;)
{
AudioFileRef fileRef;
oreka::shared_ptr<MediaChunkFile> outFile (new MediaChunkFile());
AudioTapeRef audioTapeRef;
CStdString trackingId = "[no-trk]";
int numSamplesOutv = 0;
AudioChunkRef chunkRef;
try
{
audioTapeRef = pDirectionSelector->m_audioTapeQueue.pop();
if(audioTapeRef.get() == NULL)
{
if(Daemon::Singleton()->IsStopping())
{
stop = true;
}
if(Daemon::Singleton()->GetShortLived())
{
Daemon::Singleton()->Stop();
}
}
else
{
//Iterating through area codes map to check which side will be retain
bool found = false;
int foundPos = -1;
CStdString side;
std::map<CStdString, CStdString>::iterator it;
for(it = pDirectionSelector->m_areaCodesMap.begin(); it!= pDirectionSelector->m_areaCodesMap.end() && found == false; it++)
{
//For now, we dont consider local party which has nothing to do with area codes
// foundPos = audioTapeRef->m_localParty.find(it->first);
// if(foundPos == 0)
// {
// side = it->second;
// found = true;
// break;
// }
foundPos = audioTapeRef->m_remoteParty.find(it->first);
if(foundPos == 0)
{
side = it->second;
found = true;
break;
}
}
if(found == true)
{
AudioDirectionMarksRef defaultKeptSide(new AudioDirectionMarks());
defaultKeptSide->m_timestamp = 1; //make sure it the first event in the chain of event in term of timestamp
if(audioTapeRef->m_audioDirectionMarks.size() > 0)
{
std::vector<AudioDirectionMarksRef>::iterator it;
it = audioTapeRef->m_audioDirectionMarks.begin();
defaultKeptSide->m_nextTimestampMark = (*it)->m_timestamp; //next mark, will be the first api called, if any
}
defaultKeptSide->m_audioKeepDirectionEnum = (CaptureEvent::AudioKeepDirectionEnum)CaptureEvent::AudioKeepDirectionToEnum(side);
audioTapeRef->m_audioDirectionMarks.insert(audioTapeRef->m_audioDirectionMarks.begin(),defaultKeptSide);
}
CStdString mcfExt, tmpExt, tmpFileName, origFileName, origFileNameWoExt;
mcfExt = ".mcf";
tmpExt = ".tmp";
audioTapeRef->SetExtension(mcfExt); //the real extension at this point
origFileName = audioTapeRef->m_audioOutputPath + "/"+ audioTapeRef->GetFilename();
origFileNameWoExt = audioTapeRef->m_audioOutputPath + "/" + audioTapeRef->GetPath() + audioTapeRef->GetIdentifier();
//copy a temporary file for processing
audioTapeRef->SetExtension(tmpExt);
tmpFileName = audioTapeRef->m_audioOutputPath + "/"+ audioTapeRef->GetFilename();
if(ACE_OS::rename((PCSTR)origFileName, (PCSTR)tmpFileName) != 0){
LOG4CXX_ERROR(LOG.directionSelectorLog, "Can not rename audio file for processing");
}
fileRef = audioTapeRef->GetAudioFileRef();
trackingId = audioTapeRef->m_trackingId;
fileRef->SetFilename(tmpFileName); //audioTapeRef->SetExtension(fullfilename) does not take affect on audiofileRef,
fileRef->Open(AudioFile::READ);
outFile->Open(origFileNameWoExt, AudioFile::WRITE);
while(fileRef->ReadChunkMono(chunkRef))
{
AudioChunkDetails details = *chunkRef->GetDetails();
std::vector<AudioDirectionMarksRef>::iterator it;
for(it = audioTapeRef->m_audioDirectionMarks.begin(); it != audioTapeRef->m_audioDirectionMarks.end(); it++)
{
if(((*it)->m_timestamp == 0))
{
continue;
}
if((details.m_arrivalTimestamp >= (*it)->m_timestamp) && ((details.m_arrivalTimestamp < (*it)->m_nextTimestampMark) || ((*it)->m_nextTimestampMark == 0))) //this audio chunk is in between 2 kept-direction reports marks
{
if(audioTapeRef->m_localSide == CaptureEvent::LocalSideSide1)
{
if(((*it)->m_audioKeepDirectionEnum == CaptureEvent::AudioKeepDirectionLocal) && (details.m_channel == 2))
{
memset(chunkRef->m_pBuffer, 0, details.m_numBytes); //blank side 2
}
else if(((*it)->m_audioKeepDirectionEnum == CaptureEvent::AudioKeepDirectionRemote) && (details.m_channel == 1))
{
memset(chunkRef->m_pBuffer, 0, details.m_numBytes); //blank side 1
}
}
else if(audioTapeRef->m_localSide == CaptureEvent::LocalSideSide2)
{
if(((*it)->m_audioKeepDirectionEnum == CaptureEvent::AudioKeepDirectionLocal) && (details.m_channel == 1))
{
memset(chunkRef->m_pBuffer, 0, details.m_numBytes);
}
else if(((*it)->m_audioKeepDirectionEnum == CaptureEvent::AudioKeepDirectionRemote) && (details.m_channel == 2))
{
memset(chunkRef->m_pBuffer, 0, details.m_numBytes);
}
}
}
}
outFile->WriteChunk(chunkRef);
}
outFile->Close();
ACE_OS::unlink((PCSTR)tmpFileName);
fileRef->Close();
audioTapeRef->SetExtension(mcfExt); //return back to mcf ext
fileRef->SetFilename(origFileName); // weird here, but it needs to be done, otherwise audioTapeRef will associate with tmp File
pDirectionSelector->RunNextProcessor(audioTapeRef);
}
}
catch (CStdString& e)
{
LOG4CXX_ERROR(LOG.directionSelectorLog, "[" + trackingId + "] Th" + threadIdString + " " + e);
if(fileRef.get()) {fileRef->Close();}
}
}
LOG4CXX_INFO(LOG.directionSelectorLog, CStdString("Exiting thread Th" + threadIdString));
}