| /* |
| * Copyright (c) 2011 The WebRTC project authors. All Rights Reserved. |
| * |
| * Use of this source code is governed by a BSD-style license |
| * that can be found in the LICENSE file in the root of the source |
| * tree. An additional intellectual property rights grant can be found |
| * in the file PATENTS. All contributing project authors may |
| * be found in the AUTHORS file in the root of the source tree. |
| */ |
| |
| #include <assert.h> |
| #include <iostream> |
| #include <time.h> |
| |
| #include "functionTest.h" |
| #include "event_wrapper.h" |
| #include "trace.h" |
| #include "thread_wrapper.h" |
| #include "webrtc_vad.h" |
| |
| #if (defined(WEBRTC_LINUX) || defined(WEBRTC_MAC)) |
| #include <sys/stat.h> |
| #define MY_PERMISSION_MASK S_IRWXU | S_IRWXG | S_IRWXO |
| #define MKDIR(directory) mkdir(directory,MY_PERMISSION_MASK) |
| #else // defined(WINDOWS) |
| #include <direct.h> |
| #define MKDIR(directory) mkdir(directory) |
| #endif |
| |
| int main(int /*argc*/, char* /*argv[]*/) |
| { |
| // Initialize random number generator |
| //unsigned int seed = 1220716312; // just a seed that can be used |
| unsigned int seed = (unsigned)time( NULL ); |
| srand(seed); |
| std::cout << "Starting function test. Seed = " << seed << std::endl; |
| std::cout << "Press enter to continue" << std::endl; |
| getchar(); |
| MixerWrapper* testInstance1 = MixerWrapper::CreateMixerWrapper(); |
| MixerWrapper* testInstance2 = MixerWrapper::CreateMixerWrapper(); |
| if((testInstance1 == NULL) || |
| (testInstance2 == NULL)) |
| { |
| assert(false); |
| return 0; |
| } |
| |
| char versionString[256] = ""; |
| WebRtc_UWord32 remainingBufferInBytes = 256; |
| WebRtc_UWord32 position = 0; |
| AudioConferenceMixer::GetVersion(versionString,remainingBufferInBytes,position); |
| |
| int read = 1; |
| while(read != 0) |
| { |
| std::cout << versionString << std::endl; |
| std::cout << "--------Menu-----------" << std::endl; |
| std::cout << std::endl; |
| std::cout << "0. Quit" << std::endl; |
| std::cout << "2. StartMixing" << std::endl; |
| std::cout << "3. StopMixing" << std::endl; |
| std::cout << "4. Create participant(s)" << std::endl; |
| std::cout << "5. Delete participant(s)" << std::endl; |
| std::cout << "6. List participants " << std::endl; |
| std::cout << "7. Print mix status " << std::endl; |
| std::cout << "8. Run identical scenario:" << std::endl; |
| std::cout << " a. 1 VIP, 3 regular, amount of mixed = 3" << std::endl; |
| std::cout << " b. 1 anonymous, 3 regular, amount of mixed = 2" << std::endl; |
| scanf("%i",&read); |
| getchar(); |
| MixerParticipant::ParticipantType participantType; |
| int option = 0; |
| WebRtc_UWord32 id = 0; |
| ListItem* item = NULL; |
| ListWrapper participants; |
| if(read == 0) |
| { |
| // donothing |
| } |
| else if(read == 1) |
| { |
| } |
| else if(read == 2) |
| { |
| testInstance1->StartMixing(); |
| } |
| else if(read == 3) |
| { |
| testInstance1->StopMixing(); |
| } |
| else if(read == 4) |
| { |
| while(true) |
| { |
| std::cout << "VIP(music) = " << MixerParticipant::VIP << std::endl; |
| std::cout << "Regular(speech) = " << MixerParticipant::REGULAR << std::endl; |
| std::cout << "Anonymous(music) = " << MixerParticipant::MIXED_ANONYMOUS << std::endl; |
| std::cout << "Select type of participant: "; |
| scanf("%i",&option); |
| if(option == MixerParticipant::VIP || |
| option == MixerParticipant::REGULAR || |
| option == MixerParticipant::MIXED_ANONYMOUS) |
| { |
| break; |
| } |
| } |
| participantType = (MixerParticipant::ParticipantType)option; |
| testInstance1->CreateParticipant(participantType); |
| } |
| else if(read == 5) |
| { |
| std::cout << "Select participant to delete: "; |
| scanf("%i",&option); |
| id = option; |
| testInstance1->DeleteParticipant(id); |
| break; |
| } |
| else if(read == 6) |
| { |
| testInstance1->GetParticipantList(participants); |
| item = participants.First(); |
| std::cout << "The following participants have been created: " << std::endl; |
| while(item) |
| { |
| WebRtc_UWord32 id = item->GetUnsignedItem(); |
| std::cout << id; |
| item = participants.Next(item); |
| if(item != NULL) |
| { |
| std::cout << ", "; |
| } |
| else |
| { |
| std::cout << std::endl; |
| } |
| } |
| } |
| else if(read == 7) |
| { |
| std::cout << "-------------Mixer Status-------------" << std::endl; |
| testInstance1->PrintStatus(); |
| testInstance2->PrintStatus(); |
| std::cout << "Press enter to continue"; |
| getchar(); |
| std::cout << std::endl; |
| std::cout << std::endl; |
| } |
| else if(read == 8) |
| { |
| const WebRtc_Word32 amountOfParticipants = 4; |
| MixerParticipant::ParticipantType instance1Participants[] = |
| {MixerParticipant::VIP, |
| MixerParticipant::REGULAR, |
| MixerParticipant::REGULAR, |
| MixerParticipant::REGULAR}; |
| MixerParticipant::ParticipantType instance2Participants[] = |
| {MixerParticipant::MIXED_ANONYMOUS, |
| MixerParticipant::REGULAR, |
| MixerParticipant::REGULAR, |
| MixerParticipant::REGULAR}; |
| for(WebRtc_Word32 i = 0; i < amountOfParticipants; i++) |
| { |
| WebRtc_Word32 startPosition = 0; |
| GenerateRandomPosition(startPosition); |
| testInstance1->CreateParticipant(instance1Participants[i],startPosition); |
| testInstance2->CreateParticipant(instance2Participants[i],startPosition); |
| } |
| bool success = true; |
| success = testInstance1->StartMixing(); |
| assert(success); |
| success = testInstance2->StartMixing(2); |
| assert(success); |
| } |
| } |
| |
| std::cout << "Press enter to stop" << std::endl; |
| getchar(); |
| delete testInstance1; |
| delete testInstance2; |
| return 0; |
| } |
| |
| FileWriter::FileWriter() |
| : |
| _file(NULL) |
| { |
| } |
| |
| FileWriter::~FileWriter() |
| { |
| if(_file) |
| { |
| fclose(_file); |
| } |
| } |
| |
| bool |
| FileWriter::SetFileName( |
| const char* fileName) |
| { |
| if(_file) |
| { |
| fclose(_file); |
| } |
| _file = fopen(fileName,"wb"); |
| return _file != NULL; |
| } |
| |
| bool |
| FileWriter::WriteToFile( |
| const AudioFrame& audioFrame) |
| { |
| WebRtc_Word32 written = (WebRtc_Word32)fwrite(audioFrame._payloadData,sizeof(WebRtc_Word16),audioFrame._payloadDataLengthInSamples,_file); |
| // Do not flush buffers since that will add (a lot of) delay |
| return written == audioFrame._payloadDataLengthInSamples; |
| } |
| |
| FileReader::FileReader() |
| : |
| _frequency(kDefaultFrequency), |
| _sampleSize((_frequency*kProcessPeriodicityInMs)/1000), |
| _timeStamp(0), |
| _file(NULL), |
| _vadInstr(NULL), |
| _automaticVad(false), |
| _vad(false) |
| { |
| if(WebRtcVad_Create(&_vadInstr) == 0) |
| { |
| if(WebRtcVad_Init(_vadInstr) != 0) |
| { |
| assert(false); |
| WebRtcVad_Free(_vadInstr); |
| _vadInstr = NULL; |
| } |
| } |
| else |
| { |
| assert(false); |
| } |
| } |
| |
| FileReader::~FileReader() |
| { |
| if(_file) |
| { |
| fclose(_file); |
| } |
| if(_vadInstr) |
| { |
| WebRtcVad_Free(_vadInstr); |
| } |
| } |
| |
| bool |
| FileReader::SetFileName( |
| const char* fileName) |
| { |
| if(_file) |
| { |
| fclose(_file); |
| } |
| _file = fopen(fileName,"rb"); |
| return _file != NULL; |
| } |
| |
| bool |
| FileReader::ReadFromFile( |
| AudioFrame& audioFrame) |
| { |
| |
| WebRtc_Word16 buffer[AudioFrame::kMaxAudioFrameSizeSamples]; |
| LoopedFileRead(buffer,AudioFrame::kMaxAudioFrameSizeSamples,_sampleSize,_file); |
| |
| bool vad = false; |
| GetVAD(buffer,_sampleSize,vad); |
| AudioFrame::VADActivity activity = vad ? AudioFrame::kVadActive : |
| AudioFrame::kVadPassive; |
| |
| _volumeCalculator.ComputeLevel(buffer,_sampleSize); |
| const WebRtc_Word32 level = _volumeCalculator.GetLevel(); |
| return audioFrame.UpdateFrame( -1, |
| _timeStamp, |
| buffer, |
| _sampleSize, |
| _frequency, |
| AudioFrame::kNormalSpeech, |
| activity, |
| 0, |
| level) == 0; |
| |
| } |
| |
| bool |
| FileReader::FastForwardFile( |
| const WebRtc_Word32 samples) |
| { |
| WebRtc_Word16* tempBuffer = new WebRtc_Word16[samples]; |
| bool success = LoopedFileRead(tempBuffer,samples,samples,_file); |
| delete[] tempBuffer; |
| return success; |
| } |
| |
| bool |
| FileReader::EnableAutomaticVAD( |
| bool enable, |
| int mode) |
| { |
| if(!_automaticVad && |
| enable) |
| { |
| if(WebRtcVad_Init(_vadInstr) == -1) |
| { |
| return false; |
| } |
| } |
| WebRtcVad_set_mode(_vadInstr,mode); |
| _automaticVad = enable; |
| return true; |
| } |
| |
| bool |
| FileReader::SetVAD( |
| bool vad) |
| { |
| if(_automaticVad) |
| { |
| return false; |
| } |
| _vad = vad; |
| return true; |
| } |
| |
| bool |
| FileReader::GetVAD( |
| WebRtc_Word16* buffer, |
| WebRtc_UWord8 bufferLengthInSamples, |
| bool& vad) |
| { |
| if(_automaticVad) |
| { |
| WebRtc_Word16 result = WebRtcVad_Process(_vadInstr,_frequency,buffer,bufferLengthInSamples); |
| if(result == -1) |
| { |
| assert(false); |
| return false; |
| } |
| _vad = vad = (result == 1); |
| } |
| vad = _vad; |
| return true; |
| } |
| |
| MixerParticipant* |
| MixerParticipant::CreateParticipant( |
| const WebRtc_UWord32 id, |
| ParticipantType participantType, |
| const WebRtc_Word32 startPosition, |
| char* outputPath) |
| { |
| if(participantType == RANDOM) |
| { |
| participantType = (ParticipantType)(rand() % 3); |
| } |
| MixerParticipant* participant = new MixerParticipant(id,participantType); |
| // Randomize the start position so we only need one input file |
| // assume file is smaller than 1 minute wideband = 60 * 16000 |
| // Always start at a multiple of 10ms wideband |
| if(!participant->InitializeFileReader(startPosition) || |
| !participant->InitializeFileWriter(outputPath)) |
| { |
| delete participant; |
| return NULL; |
| } |
| return participant; |
| } |
| |
| MixerParticipant::MixerParticipant( |
| const WebRtc_UWord32 id, |
| ParticipantType participantType) |
| : |
| _id(id), |
| _participantType(participantType), |
| _fileReader(), |
| _fileWriter() |
| { |
| } |
| |
| MixerParticipant::~MixerParticipant() |
| { |
| } |
| |
| WebRtc_Word32 |
| MixerParticipant::GetAudioFrame( |
| const WebRtc_Word32 /*id*/, |
| AudioFrame& audioFrame) |
| { |
| if(!_fileReader.ReadFromFile(audioFrame)) |
| { |
| return -1; |
| } |
| audioFrame._id = _id; |
| return 0; |
| } |
| |
| WebRtc_Word32 |
| MixerParticipant::MixedAudioFrame( |
| const AudioFrame& audioFrame) |
| { |
| return _fileWriter.WriteToFile(audioFrame); |
| } |
| |
| WebRtc_Word32 |
| MixerParticipant::GetParticipantType( |
| ParticipantType& participantType) |
| { |
| participantType = _participantType; |
| return 0; |
| } |
| |
| bool |
| MixerParticipant::InitializeFileReader( |
| const WebRtc_Word32 startPositionInSamples) |
| { |
| char fileName[128] = ""; |
| if(_participantType == REGULAR) |
| { |
| sprintf(fileName,"convFile.pcm"); |
| } |
| else |
| { |
| sprintf(fileName,"musicFile.pcm"); |
| } |
| if(!_fileReader.SetFileName(fileName)) |
| { |
| return false; |
| } |
| if(!_fileReader.EnableAutomaticVAD(true,2)) |
| { |
| assert(false); |
| } |
| return _fileReader.FastForwardFile(startPositionInSamples); |
| } |
| |
| bool |
| MixerParticipant::InitializeFileWriter( |
| char* outputPath) |
| { |
| const WebRtc_Word32 stringsize = 128; |
| char fileName[stringsize] = ""; |
| strncpy(fileName,outputPath,stringsize); |
| fileName[stringsize-1] = '\0'; |
| |
| char tempName[stringsize]; |
| tempName[0] = '\0'; |
| sprintf(tempName,"outputFile%d.pcm",(int)_id); |
| strncat(fileName,tempName,(stringsize - strlen(fileName))); |
| fileName[stringsize-1] = '\0'; |
| |
| return _fileWriter.SetFileName(fileName); |
| } |
| |
| StatusReceiver::StatusReceiver( |
| const WebRtc_Word32 id) |
| : |
| _id(id), |
| _mixedParticipants(NULL), |
| _mixedParticipantsAmount(0), |
| _mixedParticipantsSize(0), |
| _vadPositiveParticipants(NULL), |
| _vadPositiveParticipantsAmount(0), |
| _vadPositiveParticipantsSize(0), |
| _mixedAudioLevel(0) |
| { |
| } |
| |
| StatusReceiver::~StatusReceiver() |
| { |
| delete[] _mixedParticipants; |
| delete[] _vadPositiveParticipants; |
| } |
| |
| void |
| StatusReceiver::MixedParticipants( |
| const WebRtc_Word32 id, |
| const ParticipantStatistics* participantStatistics, |
| const WebRtc_UWord32 size) |
| { |
| if(id != _id) |
| { |
| assert(false); |
| } |
| if(_mixedParticipantsSize < size) |
| { |
| delete[] _mixedParticipants; |
| _mixedParticipantsSize = size; |
| _mixedParticipants = new ParticipantStatistics[size]; |
| } |
| _mixedParticipantsAmount = size; |
| memcpy(_mixedParticipants,participantStatistics,sizeof(ParticipantStatistics)*size); |
| } |
| |
| void |
| StatusReceiver::VADPositiveParticipants( |
| const WebRtc_Word32 id, |
| const ParticipantStatistics* participantStatistics, |
| const WebRtc_UWord32 size) |
| { |
| if(id != _id) |
| { |
| assert(false); |
| } |
| |
| if(_vadPositiveParticipantsSize < size) |
| { |
| delete[] _vadPositiveParticipants; |
| _vadPositiveParticipantsSize = size; |
| _vadPositiveParticipants = new ParticipantStatistics[size]; |
| } |
| _vadPositiveParticipantsAmount = size; |
| memcpy(_vadPositiveParticipants,participantStatistics,sizeof(ParticipantStatistics)*size); |
| } |
| |
| void |
| StatusReceiver::MixedAudioLevel( |
| const WebRtc_Word32 id, |
| const WebRtc_UWord32 level) |
| { |
| if(id != _id) |
| { |
| assert(false); |
| } |
| _mixedAudioLevel = level; |
| } |
| |
| void |
| StatusReceiver::PrintMixedParticipants() |
| { |
| std::cout << "Mixed participants" << std::endl; |
| if(_mixedParticipantsAmount == 0) |
| { |
| std::cout << "N/A" << std::endl; |
| } |
| for(WebRtc_UWord16 i = 0; i < _mixedParticipantsAmount; i++) |
| { |
| std::cout << i + 1 << ". Participant " << _mixedParticipants[i].participant << ": level = " << _mixedParticipants[i].level << std::endl; |
| } |
| } |
| |
| void |
| StatusReceiver::PrintVadPositiveParticipants() |
| { |
| std::cout << "VAD positive participants" << std::endl; |
| if(_mixedParticipantsAmount == 0) |
| { |
| std::cout << "N/A" << std::endl; |
| } |
| for(WebRtc_UWord16 i = 0; i < _mixedParticipantsAmount; i++) |
| { |
| std::cout << i + 1 << ". Participant " << _mixedParticipants[i].participant << ": level = " << _mixedParticipants[i].level << std::endl; |
| } |
| } |
| |
| void |
| StatusReceiver::PrintMixedAudioLevel() |
| { |
| std::cout << "Mixed audio level = " << _mixedAudioLevel << std::endl; |
| } |
| |
| WebRtc_Word32 MixerWrapper::_mixerWrapperIdCounter = 0; |
| |
| MixerWrapper::MixerWrapper() |
| : |
| _processThread(NULL), |
| _threadId(0), |
| _firstProcessCall(true), |
| _previousTime(), |
| _periodicityInTicks(TickTime::MillisecondsToTicks(FileReader::kProcessPeriodicityInMs)), |
| _synchronizationEvent(EventWrapper::Create()), |
| _freeItemIds(), |
| _itemIdCounter(0), |
| _mixerParticipants(), |
| _mixerWrappererId(_mixerWrapperIdCounter++), |
| _instanceOutputPath(), |
| _trace(NULL), |
| _statusReceiver(_mixerWrappererId), |
| _generalAudioWriter() |
| { |
| sprintf(_instanceOutputPath,"instance%d/",(int)_mixerWrappererId); |
| MKDIR(_instanceOutputPath); |
| _mixer = AudioConferenceMixer::CreateAudioConferenceMixer( |
| _mixerWrappererId); |
| if(_mixer != NULL) |
| { |
| bool success = true; |
| |
| success = _mixer->RegisterMixedStreamCallback(*this) == 0; |
| assert(success); |
| success = _mixer->RegisterMixedStreamCallback(*this) == -1; |
| assert(success); |
| success = _mixer->UnRegisterMixedStreamCallback() == 0; |
| assert(success); |
| success = _mixer->UnRegisterMixedStreamCallback() == -1; |
| assert(success); |
| success = _mixer->RegisterMixedStreamCallback(*this) == 0; |
| assert(success); |
| |
| success = _mixer->RegisterMixerStatusCallback(_statusReceiver,2) == 0; |
| assert(success); |
| success = _mixer->RegisterMixerStatusCallback(_statusReceiver,1) == -1; |
| assert(success); |
| success = _mixer->UnRegisterMixerStatusCallback() == 0; |
| assert(success); |
| success = _mixer->UnRegisterMixerStatusCallback() == -1; |
| assert(success); |
| success = _mixer->RegisterMixerStatusCallback(_statusReceiver,1) == 0; |
| assert(success); |
| } |
| else |
| { |
| assert(false); |
| std::cout << "Failed to create mixer instance"; |
| } |
| } |
| |
| MixerWrapper* |
| MixerWrapper::CreateMixerWrapper() |
| { |
| MixerWrapper* mixerWrapper = new MixerWrapper(); |
| if(!mixerWrapper->InitializeFileWriter()) |
| { |
| delete mixerWrapper; |
| return NULL; |
| } |
| return mixerWrapper; |
| } |
| |
| MixerWrapper::~MixerWrapper() |
| { |
| StopMixing(); |
| ClearAllItemIds(); |
| _synchronizationEvent->StopTimer(); |
| delete _synchronizationEvent; |
| delete _mixer; |
| } |
| |
| bool |
| MixerWrapper::CreateParticipant( |
| MixerParticipant::ParticipantType participantType) |
| { |
| WebRtc_Word32 startPosition = 0; |
| GenerateRandomPosition(startPosition); |
| return CreateParticipant(participantType,startPosition); |
| } |
| |
| bool |
| MixerWrapper::CreateParticipant( |
| MixerParticipant::ParticipantType participantType, |
| const WebRtc_Word32 startPosition) |
| { |
| WebRtc_UWord32 id; |
| if(!GetFreeItemIds(id)) |
| { |
| return false; |
| } |
| |
| MixerParticipant* participant = MixerParticipant::CreateParticipant(id,participantType,startPosition,_instanceOutputPath); |
| if(!participant) |
| { |
| return false; |
| } |
| if(_mixerParticipants.Insert(id,static_cast<void*>(participant)) != 0) |
| { |
| delete participant; |
| return false; |
| } |
| if(!StartMixingParticipant(id)) |
| { |
| DeleteParticipant(id); |
| return false; |
| } |
| return true; |
| } |
| |
| bool |
| MixerWrapper::DeleteParticipant( |
| const WebRtc_UWord32 id) |
| { |
| bool success = StopMixingParticipant(id); |
| if(!success) |
| { |
| assert(false); |
| return false; |
| } |
| MapItem* item = _mixerParticipants.Find(id); |
| if(item == NULL) |
| { |
| return false; |
| } |
| MixerParticipant* participant = static_cast<MixerParticipant*>(item->GetItem()); |
| delete participant; |
| _mixerParticipants.Erase(item); |
| AddFreeItemIds(id); |
| return true; |
| } |
| |
| bool |
| MixerWrapper::StartMixing( |
| const WebRtc_UWord32 mixedParticipants) |
| { |
| if(_processThread) |
| { |
| return false; |
| } |
| if(_mixer->SetAmountOfMixedParticipants(mixedParticipants) != 0) |
| { |
| assert(false); |
| } |
| WebRtc_UWord32 mixedParticipantsTest = 0; |
| _mixer->AmountOfMixedParticipants(mixedParticipantsTest); |
| assert(mixedParticipantsTest == mixedParticipants); |
| |
| if(!_synchronizationEvent->StartTimer(true,10)) |
| { |
| assert(false); |
| return false; |
| } |
| _processThread = ThreadWrapper::CreateThread(Process, this, kLowPriority); |
| if(!_processThread->Start(_threadId)) |
| { |
| delete _processThread; |
| _processThread = NULL; |
| assert(false); |
| return false; |
| } |
| |
| return true; |
| } |
| |
| bool |
| MixerWrapper::StopMixing() |
| { |
| while(_processThread && |
| !_processThread->Stop()) |
| {} |
| _synchronizationEvent->StopTimer(); |
| |
| delete _processThread; |
| _processThread = NULL; |
| return true; |
| } |
| |
| void |
| MixerWrapper::NewMixedAudio( |
| const WebRtc_Word32 id, |
| const AudioFrame& generalAudioFrame, |
| const AudioFrame** uniqueAudioFrames, |
| const WebRtc_UWord32 size) |
| { |
| if(id < 0) |
| { |
| assert(false); |
| } |
| // Store the general audio |
| _generalAudioWriter.WriteToFile(generalAudioFrame); |
| |
| // Send the unique audio frames to its corresponding participants |
| ListWrapper uniqueAudioFrameList; |
| for(WebRtc_UWord32 i = 0; i < size; i++) |
| { |
| WebRtc_UWord32 id = (uniqueAudioFrames[i])->_id; |
| MapItem* resultItem = _mixerParticipants.Find(id); |
| if(resultItem == NULL) |
| { |
| assert(false); |
| continue; |
| } |
| MixerParticipant* participant = static_cast<MixerParticipant*>(resultItem->GetItem()); |
| participant->MixedAudioFrame(*(uniqueAudioFrames[i])); |
| uniqueAudioFrameList.PushBack(resultItem->GetItem()); |
| } |
| |
| // Send the general audio frames to the remaining participants |
| MapItem* item = _mixerParticipants.First(); |
| while(item) |
| { |
| bool isUnique = false; |
| ListItem* compareItem = uniqueAudioFrameList.First(); |
| while(compareItem) |
| { |
| if(compareItem->GetItem() == item->GetItem()) |
| { |
| isUnique = true; |
| break; |
| } |
| compareItem = uniqueAudioFrameList.Next(compareItem); |
| } |
| if(!isUnique) |
| { |
| MixerParticipant* participant = static_cast<MixerParticipant*>(item->GetItem()); |
| participant->MixedAudioFrame(generalAudioFrame); |
| } |
| item = _mixerParticipants.Next(item); |
| } |
| } |
| |
| bool |
| MixerWrapper::GetParticipantList( |
| ListWrapper& participants) |
| { |
| MapItem* item = _mixerParticipants.First(); |
| while(item) |
| { |
| participants.PushBack(item->GetId()); |
| item = _mixerParticipants.Next(item); |
| } |
| return true; |
| } |
| |
| void |
| MixerWrapper::PrintStatus() |
| { |
| std::cout << "instance " << _mixerWrappererId << std::endl; |
| std::cout << std::endl; |
| _statusReceiver.PrintMixedParticipants(); |
| std::cout << std::endl; |
| _statusReceiver.PrintVadPositiveParticipants(); |
| std::cout << std::endl; |
| _statusReceiver.PrintMixedAudioLevel(); |
| std::cout << "---------------------------------------" << std::endl; |
| } |
| |
| bool |
| MixerWrapper::InitializeFileWriter() |
| { |
| const WebRtc_Word32 stringsize = 128; |
| char fileName[stringsize] = ""; |
| strncpy(fileName,_instanceOutputPath,stringsize); |
| fileName[stringsize-1] = '\0'; |
| |
| strncat(fileName,"generalOutputFile.pcm",(stringsize - strlen(fileName))); |
| fileName[stringsize-1] = '\0'; |
| return _generalAudioWriter.SetFileName(fileName); |
| } |
| |
| bool |
| MixerWrapper::Process( |
| void* instance) |
| { |
| MixerWrapper* mixerWrapper = static_cast<MixerWrapper*>(instance); |
| return mixerWrapper->Process(); |
| } |
| |
| bool |
| MixerWrapper::Process() |
| { |
| switch(_synchronizationEvent->Wait(1000)) |
| { |
| case kEventSignaled: |
| // Normal operation, ~10 ms has passed |
| break; |
| case kEventError: |
| // Error occured end the thread and throw an assertion |
| assert(false); |
| return false; |
| case kEventTimeout: |
| // One second has passed without a timeout something is wrong |
| // end the thread and throw an assertion |
| assert(false); |
| return false; |
| } |
| WebRtc_Word32 processOfset = 0; |
| const TickTime currentTime = TickTime::Now(); |
| if(_firstProcessCall) |
| { |
| _previousTime = TickTime::Now(); |
| _firstProcessCall = false; |
| } |
| else |
| { |
| TickInterval deltaTime = (currentTime - _previousTime); |
| _previousTime += _periodicityInTicks; |
| processOfset = (WebRtc_Word32) deltaTime.Milliseconds(); |
| processOfset -= FileReader::kProcessPeriodicityInMs; |
| } |
| |
| _mixer->Process(); |
| WebRtc_Word32 timeUntilNextProcess = _mixer->TimeUntilNextProcess(); |
| if(processOfset > FileReader::kProcessPeriodicityInMs) |
| { |
| std::cout << "Performance Warning: Process running " << processOfset << " too slow" << std::endl; |
| _previousTime = currentTime; |
| if(timeUntilNextProcess > 0) |
| { |
| std::cout << "Performance Warning: test performance and module performance missmatch" << std::endl; |
| } |
| } |
| else if(processOfset < -FileReader::kProcessPeriodicityInMs) |
| { |
| std::cout << "Performance Warning: Process running " << -processOfset << " too fast" << std::endl; |
| _previousTime = currentTime; |
| if(timeUntilNextProcess < FileReader::kProcessPeriodicityInMs) |
| { |
| std::cout << "Performance Warning: test performance and module performance missmatch" << std::endl; |
| } |
| } |
| return true; |
| } |
| |
| |
| bool |
| MixerWrapper::StartMixingParticipant( |
| const WebRtc_UWord32 id) |
| { |
| MapItem* item = _mixerParticipants.Find(id); |
| if(item == NULL) |
| { |
| return false; |
| } |
| MixerParticipant* participant = static_cast<MixerParticipant*>(item->GetItem()); |
| MixerParticipant::ParticipantType participantType = MixerParticipant::REGULAR; |
| participant->GetParticipantType(participantType); |
| if(participantType == MixerParticipant::MIXED_ANONYMOUS) |
| { |
| bool anonymouslyMixed = false; |
| bool success = _mixer->SetAnonymousMixabilityStatus(*participant,true) == 0; |
| assert(success); |
| success = _mixer->AnonymousMixabilityStatus(*participant,anonymouslyMixed) == 0; |
| assert(success); |
| assert(anonymouslyMixed); |
| success = _mixer->SetAnonymousMixabilityStatus(*participant,true) == -1; |
| assert(success); |
| success = _mixer->SetAnonymousMixabilityStatus(*participant,false) == 0; |
| assert(success); |
| success = _mixer->AnonymousMixabilityStatus(*participant,anonymouslyMixed) == 0; |
| assert(success); |
| assert(!anonymouslyMixed); |
| success = _mixer->SetAnonymousMixabilityStatus(*participant,false) == -1; |
| assert(success); |
| success = _mixer->SetAnonymousMixabilityStatus(*participant,true) == 0; |
| assert(success); |
| success = _mixer->AnonymousMixabilityStatus(*participant,anonymouslyMixed) == 0; |
| assert(success); |
| assert(anonymouslyMixed); |
| return success; |
| } |
| WebRtc_UWord32 previousAmountOfMixableParticipants = 0; |
| bool success = _mixer->AmountOfMixables(previousAmountOfMixableParticipants) == 0; |
| assert(success); |
| |
| success = _mixer->SetMixabilityStatus(*participant,true) == 0; |
| assert(success); |
| success = _mixer->SetMixabilityStatus(*participant,true) == -1; |
| assert(success); |
| success = _mixer->SetMixabilityStatus(*participant,false) == 0; |
| assert(success); |
| success = _mixer->SetMixabilityStatus(*participant,false) == -1; |
| assert(success); |
| success = _mixer->SetMixabilityStatus(*participant,true) == 0; |
| assert(success); |
| if(!success) |
| { |
| return false; |
| } |
| |
| WebRtc_UWord32 currentAmountOfMixableParticipants = 0; |
| success = _mixer->AmountOfMixables(currentAmountOfMixableParticipants) == 0; |
| assert(currentAmountOfMixableParticipants == previousAmountOfMixableParticipants + 1); |
| |
| bool mixable = true; |
| success = _mixer->MixabilityStatus(*participant,mixable) == 0; |
| assert(success); |
| assert(mixable); |
| if(participantType == MixerParticipant::REGULAR) |
| { |
| return true; |
| } |
| bool IsVIP = false; |
| success = _mixer->SetVIPStatus(*participant,true) == 0; |
| assert(success); |
| success = _mixer->VIPStatus(*participant,IsVIP) == 0; |
| assert(success); |
| assert(IsVIP); |
| success = _mixer->SetVIPStatus(*participant,true) == -1; |
| assert(success); |
| success = _mixer->SetVIPStatus(*participant,false) == 0; |
| assert(success); |
| success = _mixer->VIPStatus(*participant,IsVIP) == 0; |
| assert(success); |
| assert(!IsVIP); |
| success = _mixer->SetVIPStatus(*participant,false) == -1; |
| assert(success); |
| success = _mixer->SetVIPStatus(*participant,true) == 0; |
| assert(success); |
| success = _mixer->VIPStatus(*participant,IsVIP) == 0; |
| assert(success); |
| assert(IsVIP); |
| assert(success); |
| return success; |
| } |
| |
| bool |
| MixerWrapper::StopMixingParticipant( |
| const WebRtc_UWord32 id) |
| { |
| MapItem* item = _mixerParticipants.Find(id); |
| if(item == NULL) |
| { |
| return false; |
| } |
| MixerParticipant* participant = static_cast<MixerParticipant*>(item->GetItem()); |
| bool success = false; |
| WebRtc_UWord32 previousAmountOfMixableParticipants = 0; |
| success = _mixer->AmountOfMixables(previousAmountOfMixableParticipants) == 0; |
| assert(success); |
| success = _mixer->SetMixabilityStatus(*participant,false) == 0; |
| assert(success); |
| WebRtc_UWord32 currentAmountOfMixableParticipants = 0; |
| success = _mixer->AmountOfMixables(currentAmountOfMixableParticipants) == 0; |
| assert(success); |
| assert(success ? currentAmountOfMixableParticipants == previousAmountOfMixableParticipants -1 : |
| currentAmountOfMixableParticipants == previousAmountOfMixableParticipants); |
| return success; |
| } |
| |
| bool |
| MixerWrapper::GetFreeItemIds( |
| WebRtc_UWord32& itemId) |
| { |
| if(!_freeItemIds.Empty()) |
| { |
| ListItem* item = _freeItemIds.First(); |
| WebRtc_UWord32* id = static_cast<WebRtc_UWord32*>(item->GetItem()); |
| itemId = *id; |
| delete id; |
| return true; |
| } |
| if(_itemIdCounter == (WebRtc_UWord32) -1) |
| { |
| return false; |
| } |
| itemId = _itemIdCounter++; |
| return true; |
| } |
| |
| void |
| MixerWrapper::AddFreeItemIds( |
| const WebRtc_UWord32 itemId) |
| { |
| WebRtc_UWord32* id = new WebRtc_UWord32; |
| *id = itemId; |
| _freeItemIds.PushBack(static_cast<void*>(id)); |
| } |
| |
| void |
| MixerWrapper::ClearAllItemIds() |
| { |
| ListItem* item = _freeItemIds.First(); |
| while(item != NULL) |
| { |
| WebRtc_UWord32* id = static_cast<WebRtc_UWord32*>(item->GetItem()); |
| delete id; |
| _freeItemIds.Erase(item); |
| item = _freeItemIds.First(); |
| } |
| } |
| |
| bool |
| LoopedFileRead( |
| WebRtc_Word16* buffer, |
| WebRtc_UWord32 bufferSizeInSamples, |
| WebRtc_UWord32 samplesToRead, |
| FILE* file) |
| { |
| if(bufferSizeInSamples < samplesToRead) |
| { |
| return false; |
| } |
| WebRtc_UWord32 gottenSamples = (WebRtc_UWord32)fread(buffer,sizeof(WebRtc_Word16),samplesToRead,file); |
| if(gottenSamples != samplesToRead) |
| { |
| WebRtc_UWord32 missingSamples = samplesToRead - gottenSamples; |
| fseek(file,0,0); |
| gottenSamples += (WebRtc_UWord32)fread(&buffer[gottenSamples],sizeof(WebRtc_Word16),missingSamples,file); |
| } |
| if(gottenSamples != samplesToRead) |
| { |
| return false; |
| } |
| return true; |
| } |
| |
| void |
| GenerateRandomPosition( |
| WebRtc_Word32& startPosition) |
| { |
| startPosition = (rand() % (60*16000/160)) * 160; |
| } |
