| /* |
| * Copyright (c) 2012 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. |
| */ |
| |
| // SwitchingSampRate.cpp : Defines the entry point for the console |
| // application. |
| // |
| |
| #include <iostream> |
| #include "isac.h" |
| #include "utility.h" |
| #include "signal_processing_library.h" |
| |
| #define MAX_FILE_NAME 500 |
| #define MAX_NUM_CLIENTS 2 |
| |
| |
| #define NUM_CLIENTS 2 |
| |
| using namespace std; |
| |
| int main(int argc, char* argv[]) |
| { |
| char fileNameWB[MAX_FILE_NAME]; |
| char fileNameSWB[MAX_FILE_NAME]; |
| |
| char outFileName[MAX_NUM_CLIENTS][MAX_FILE_NAME]; |
| |
| FILE* inFile[MAX_NUM_CLIENTS]; |
| FILE* outFile[MAX_NUM_CLIENTS]; |
| |
| ISACStruct* codecInstance[MAX_NUM_CLIENTS]; |
| int32_t resamplerState[MAX_NUM_CLIENTS][8]; |
| |
| int encoderSampRate[MAX_NUM_CLIENTS]; |
| |
| int minBn = 16000; |
| int maxBn = 56000; |
| |
| int bnWB = 32000; |
| int bnSWB = 56000; |
| |
| strcpy(outFileName[0], "switchSampRate_out1.pcm"); |
| strcpy(outFileName[1], "switchSampRate_out2.pcm"); |
| |
| short clientCntr; |
| |
| size_t lenEncodedInBytes[MAX_NUM_CLIENTS]; |
| unsigned int lenAudioIn10ms[MAX_NUM_CLIENTS]; |
| size_t lenEncodedInBytesTmp[MAX_NUM_CLIENTS]; |
| unsigned int lenAudioIn10msTmp[MAX_NUM_CLIENTS]; |
| BottleNeckModel* packetData[MAX_NUM_CLIENTS]; |
| |
| char versionNumber[100]; |
| short samplesIn10ms[MAX_NUM_CLIENTS]; |
| int bottleneck[MAX_NUM_CLIENTS]; |
| |
| printf("\n\n"); |
| printf("____________________________________________\n\n"); |
| WebRtcIsac_version(versionNumber); |
| printf(" iSAC-swb version %s\n", versionNumber); |
| printf("____________________________________________\n"); |
| |
| |
| fileNameWB[0] = '\0'; |
| fileNameSWB[0] = '\0'; |
| |
| char myFlag[20]; |
| strcpy(myFlag, "-wb"); |
| // READ THE WIDEBAND AND SUPER-WIDEBAND FILE NAMES |
| if(readParamString(argc, argv, myFlag, fileNameWB, MAX_FILE_NAME) <= 0) |
| { |
| printf("No wideband file is specified"); |
| } |
| |
| strcpy(myFlag, "-swb"); |
| if(readParamString(argc, argv, myFlag, fileNameSWB, MAX_FILE_NAME) <= 0) |
| { |
| printf("No super-wideband file is specified"); |
| } |
| |
| // THE FIRST CLIENT STARTS IN WIDEBAND |
| encoderSampRate[0] = 16000; |
| OPEN_FILE_RB(inFile[0], fileNameWB); |
| |
| // THE SECOND CLIENT STARTS IN SUPER-WIDEBAND |
| encoderSampRate[1] = 32000; |
| OPEN_FILE_RB(inFile[1], fileNameSWB); |
| |
| strcpy(myFlag, "-I"); |
| short codingMode = readSwitch(argc, argv, myFlag); |
| |
| for(clientCntr = 0; clientCntr < NUM_CLIENTS; clientCntr++) |
| { |
| codecInstance[clientCntr] = NULL; |
| |
| printf("\n"); |
| printf("Client %d\n", clientCntr + 1); |
| printf("---------\n"); |
| printf("Starting %s", |
| (encoderSampRate[clientCntr] == 16000) |
| ? "wideband":"super-wideband"); |
| |
| // Open output File Name |
| OPEN_FILE_WB(outFile[clientCntr], outFileName[clientCntr]); |
| printf("Output File...................... %s\n", outFileName[clientCntr]); |
| |
| samplesIn10ms[clientCntr] = encoderSampRate[clientCntr] * 10; |
| |
| if(codingMode == 1) |
| { |
| bottleneck[clientCntr] = (clientCntr)? bnSWB:bnWB; |
| } |
| else |
| { |
| bottleneck[clientCntr] = (clientCntr)? minBn:maxBn; |
| } |
| |
| printf("Bottleneck....................... %0.3f kbits/sec \n", |
| bottleneck[clientCntr] / 1000.0); |
| |
| // coding-mode |
| printf("Encoding Mode.................... %s\n", |
| (codingMode == 1)? "Channel-Independent (Instantaneous)":"Adaptive"); |
| |
| lenEncodedInBytes[clientCntr] = 0; |
| lenAudioIn10ms[clientCntr] = 0; |
| lenEncodedInBytesTmp[clientCntr] = 0; |
| lenAudioIn10msTmp[clientCntr] = 0; |
| |
| packetData[clientCntr] = (BottleNeckModel*)new(BottleNeckModel); |
| if(packetData[clientCntr] == NULL) |
| { |
| printf("Could not allocate memory for packetData \n"); |
| return -1; |
| } |
| memset(packetData[clientCntr], 0, sizeof(BottleNeckModel)); |
| memset(resamplerState[clientCntr], 0, sizeof(int32_t) * 8); |
| } |
| |
| for(clientCntr = 0; clientCntr < NUM_CLIENTS; clientCntr++) |
| { |
| // Create |
| if(WebRtcIsac_Create(&codecInstance[clientCntr])) |
| { |
| printf("Could not creat client %d\n", clientCntr + 1); |
| return -1; |
| } |
| |
| WebRtcIsac_SetEncSampRate(codecInstance[clientCntr], encoderSampRate[clientCntr]); |
| |
| WebRtcIsac_SetDecSampRate(codecInstance[clientCntr], |
| encoderSampRate[clientCntr + (1 - ((clientCntr & 1)<<1))]); |
| |
| // Initialize Encoder |
| if(WebRtcIsac_EncoderInit(codecInstance[clientCntr], |
| codingMode) < 0) |
| { |
| printf("Could not initialize client, %d\n", clientCntr + 1); |
| return -1; |
| } |
| |
| WebRtcIsac_DecoderInit(codecInstance[clientCntr]); |
| |
| // setup Rate if in Instantaneous mode |
| if(codingMode != 0) |
| { |
| // ONLY Clients who are not in Adaptive mode |
| if(WebRtcIsac_Control(codecInstance[clientCntr], |
| bottleneck[clientCntr], 30) < 0) |
| { |
| printf("Could not setup bottleneck and frame-size for client %d\n", |
| clientCntr + 1); |
| return -1; |
| } |
| } |
| } |
| |
| |
| size_t streamLen; |
| short numSamplesRead; |
| size_t lenDecodedAudio; |
| short senderIdx; |
| short receiverIdx; |
| |
| printf("\n"); |
| short num10ms[MAX_NUM_CLIENTS]; |
| memset(num10ms, 0, sizeof(short)*MAX_NUM_CLIENTS); |
| FILE* arrivalTimeFile1 = fopen("arrivalTime1.dat", "wb"); |
| FILE* arrivalTimeFile2 = fopen("arrivalTime2.dat", "wb"); |
| short numPrint[MAX_NUM_CLIENTS]; |
| memset(numPrint, 0, sizeof(short) * MAX_NUM_CLIENTS); |
| |
| // Audio Buffers |
| short silence10ms[10 * 32]; |
| memset(silence10ms, 0, 320 * sizeof(short)); |
| short audioBuff10ms[10 * 32]; |
| short audioBuff60ms[60 * 32]; |
| short resampledAudio60ms[60 * 32]; |
| |
| unsigned short bitStream[600+600]; |
| short speechType[1]; |
| |
| short numSampFreqChanged = 0; |
| while(numSampFreqChanged < 10) |
| { |
| for(clientCntr = 0; clientCntr < NUM_CLIENTS; clientCntr++) |
| { |
| // Encoding/decoding for this pair of clients, if there is |
| // audio for any of them |
| //if(audioLeft[clientCntr] || audioLeft[clientCntr + 1]) |
| //{ |
| //for(pairCntr = 0; pairCntr < 2; pairCntr++) |
| //{ |
| senderIdx = clientCntr; // + pairCntr; |
| receiverIdx = 1 - clientCntr;// + (1 - pairCntr); |
| |
| //if(num10ms[senderIdx] > 6) |
| //{ |
| // printf("Too many frames read for client %d", |
| // senderIdx + 1); |
| // return -1; |
| //} |
| |
| numSamplesRead = (short)fread(audioBuff10ms, sizeof(short), |
| samplesIn10ms[senderIdx], inFile[senderIdx]); |
| if(numSamplesRead != samplesIn10ms[senderIdx]) |
| { |
| // file finished switch encoder sampling frequency. |
| printf("Changing Encoder Sampling frequency in client %d to ", senderIdx+1); |
| fclose(inFile[senderIdx]); |
| numSampFreqChanged++; |
| if(encoderSampRate[senderIdx] == 16000) |
| { |
| printf("super-wideband.\n"); |
| OPEN_FILE_RB(inFile[senderIdx], fileNameSWB); |
| encoderSampRate[senderIdx] = 32000; |
| } |
| else |
| { |
| printf("wideband.\n"); |
| OPEN_FILE_RB(inFile[senderIdx], fileNameWB); |
| encoderSampRate[senderIdx] = 16000; |
| } |
| WebRtcIsac_SetEncSampRate(codecInstance[senderIdx], encoderSampRate[senderIdx]); |
| WebRtcIsac_SetDecSampRate(codecInstance[receiverIdx], encoderSampRate[senderIdx]); |
| |
| samplesIn10ms[clientCntr] = encoderSampRate[clientCntr] * 10; |
| |
| numSamplesRead = (short)fread(audioBuff10ms, sizeof(short), |
| samplesIn10ms[senderIdx], inFile[senderIdx]); |
| if(numSamplesRead != samplesIn10ms[senderIdx]) |
| { |
| printf(" File %s for client %d has not enough audio\n", |
| (encoderSampRate[senderIdx]==16000)? "wideband":"super-wideband", |
| senderIdx + 1); |
| return -1; |
| } |
| } |
| num10ms[senderIdx]++; |
| |
| // sanity check |
| //if(num10ms[senderIdx] > 6) |
| //{ |
| // printf("Client %d has got more than 60 ms audio and encoded no packet.\n", |
| // senderIdx); |
| // return -1; |
| //} |
| |
| // Encode |
| |
| |
| int streamLen_int = WebRtcIsac_Encode(codecInstance[senderIdx], |
| audioBuff10ms, |
| (uint8_t*)bitStream); |
| int16_t ggg; |
| if (streamLen_int > 0) { |
| if ((WebRtcIsac_ReadFrameLen( |
| codecInstance[receiverIdx], |
| reinterpret_cast<const uint8_t*>(bitStream), |
| &ggg)) < 0) |
| printf("ERROR\n"); |
| } |
| |
| // Sanity check |
| if(streamLen_int < 0) |
| { |
| printf(" Encoder error in client %d \n", senderIdx + 1); |
| return -1; |
| } |
| streamLen = static_cast<size_t>(streamLen_int); |
| |
| |
| if(streamLen > 0) |
| { |
| // Packet generated; model sending through a channel, do bandwidth |
| // estimation at the receiver and decode. |
| lenEncodedInBytes[senderIdx] += streamLen; |
| lenAudioIn10ms[senderIdx] += (unsigned int)num10ms[senderIdx]; |
| lenEncodedInBytesTmp[senderIdx] += streamLen; |
| lenAudioIn10msTmp[senderIdx] += (unsigned int)num10ms[senderIdx]; |
| |
| // Print after ~5 sec. |
| if(lenAudioIn10msTmp[senderIdx] >= 100) |
| { |
| numPrint[senderIdx]++; |
| printf(" %d, %6.3f => %6.3f ", senderIdx+1, |
| bottleneck[senderIdx] / 1000.0, |
| lenEncodedInBytesTmp[senderIdx] * 0.8 / |
| lenAudioIn10msTmp[senderIdx]); |
| |
| if(codingMode == 0) |
| { |
| int32_t bn; |
| WebRtcIsac_GetUplinkBw(codecInstance[senderIdx], &bn); |
| printf("[%d] ", bn); |
| } |
| //int16_t rateIndexLB; |
| //int16_t rateIndexUB; |
| //WebRtcIsac_GetDownLinkBwIndex(codecInstance[receiverIdx], |
| // &rateIndexLB, &rateIndexUB); |
| //printf(" (%2d, %2d) ", rateIndexLB, rateIndexUB); |
| |
| cout << flush; |
| lenEncodedInBytesTmp[senderIdx] = 0; |
| lenAudioIn10msTmp[senderIdx] = 0; |
| //if(senderIdx == (NUM_CLIENTS - 1)) |
| //{ |
| printf(" %0.1f \n", lenAudioIn10ms[senderIdx] * 10. /1000); |
| //} |
| |
| // After ~20 sec change the bottleneck. |
| // if((numPrint[senderIdx] == 4) && (codingMode == 0)) |
| // { |
| // numPrint[senderIdx] = 0; |
| // if(codingMode == 0) |
| // { |
| // int newBottleneck = bottleneck[senderIdx] + |
| // (bottleneckChange[senderIdx] * 1000); |
| |
| // if(bottleneckChange[senderIdx] > 0) |
| // { |
| // if(newBottleneck >maxBn) |
| // { |
| // bottleneckChange[senderIdx] = -1; |
| // newBottleneck = bottleneck[senderIdx] + |
| // (bottleneckChange[senderIdx] * 1000); |
| // if(newBottleneck > minBn) |
| // { |
| // bottleneck[senderIdx] = newBottleneck; |
| // } |
| // } |
| // else |
| // { |
| // bottleneck[senderIdx] = newBottleneck; |
| // } |
| // } |
| // else |
| // { |
| // if(newBottleneck < minBn) |
| // { |
| // bottleneckChange[senderIdx] = 1; |
| // newBottleneck = bottleneck[senderIdx] + |
| // (bottleneckChange[senderIdx] * 1000); |
| // if(newBottleneck < maxBn) |
| // { |
| // bottleneck[senderIdx] = newBottleneck; |
| // } |
| // } |
| // else |
| // { |
| // bottleneck[senderIdx] = newBottleneck; |
| // } |
| // } |
| // } |
| // } |
| } |
| |
| // model a channel of given bottleneck, to get the receive timestamp |
| get_arrival_time(num10ms[senderIdx] * samplesIn10ms[senderIdx], |
| streamLen, bottleneck[senderIdx], packetData[senderIdx], |
| encoderSampRate[senderIdx]*1000, encoderSampRate[senderIdx]*1000); |
| |
| // Write the arrival time. |
| if(senderIdx == 0) |
| { |
| if (fwrite(&(packetData[senderIdx]->arrival_time), |
| sizeof(unsigned int), |
| 1, arrivalTimeFile1) != 1) { |
| return -1; |
| } |
| } |
| else |
| { |
| if (fwrite(&(packetData[senderIdx]->arrival_time), |
| sizeof(unsigned int), |
| 1, arrivalTimeFile2) != 1) { |
| return -1; |
| } |
| } |
| |
| // BWE |
| if (WebRtcIsac_UpdateBwEstimate( |
| codecInstance[receiverIdx], |
| reinterpret_cast<const uint8_t*>(bitStream), |
| streamLen, |
| packetData[senderIdx]->rtp_number, |
| packetData[senderIdx]->sample_count, |
| packetData[senderIdx]->arrival_time) < 0) { |
| printf(" BWE Error at client %d \n", receiverIdx + 1); |
| return -1; |
| } |
| /**/ |
| // Decode |
| int lenDecodedAudio_int = WebRtcIsac_Decode( |
| codecInstance[receiverIdx], |
| reinterpret_cast<const uint8_t*>(bitStream), |
| streamLen, |
| audioBuff60ms, |
| speechType); |
| if(lenDecodedAudio_int < 0) |
| { |
| printf(" Decoder error in client %d \n", receiverIdx + 1); |
| return -1; |
| } |
| lenDecodedAudio = static_cast<size_t>(lenDecodedAudio_int); |
| |
| if(encoderSampRate[senderIdx] == 16000) |
| { |
| WebRtcSpl_UpsampleBy2(audioBuff60ms, lenDecodedAudio, resampledAudio60ms, |
| resamplerState[receiverIdx]); |
| if (fwrite(resampledAudio60ms, sizeof(short), lenDecodedAudio << 1, |
| outFile[receiverIdx]) != |
| lenDecodedAudio << 1) { |
| return -1; |
| } |
| } |
| else |
| { |
| if (fwrite(audioBuff60ms, sizeof(short), lenDecodedAudio, |
| outFile[receiverIdx]) != |
| lenDecodedAudio) { |
| return -1; |
| } |
| } |
| num10ms[senderIdx] = 0; |
| } |
| //} |
| //} |
| } |
| } |
| } |
