| /* |
| * 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. |
| */ |
| |
| #include "modules/media_file/media_file_utility.h" |
| |
| #include <assert.h> |
| #include <sys/stat.h> |
| #include <sys/types.h> |
| #include <limits> |
| |
| #include "common_audio/wav_header.h" |
| #include "common_types.h" // NOLINT(build/include) |
| #include "modules/include/module_common_types.h" |
| #include "rtc_base/format_macros.h" |
| #include "rtc_base/logging.h" |
| #include "typedefs.h" // NOLINT(build/include) |
| |
| namespace { |
| |
| // First 16 bytes the WAVE header. ckID should be "RIFF", wave_ckID should be |
| // "WAVE" and ckSize is the chunk size (4 + n) |
| struct WAVE_RIFF_header { |
| int8_t ckID[4]; |
| int32_t ckSize; |
| int8_t wave_ckID[4]; |
| }; |
| |
| // First 8 byte of the format chunk. fmt_ckID should be "fmt ". fmt_ckSize is |
| // the chunk size (16, 18 or 40 byte) |
| struct WAVE_CHUNK_header { |
| int8_t fmt_ckID[4]; |
| uint32_t fmt_ckSize; |
| }; |
| } // unnamed namespace |
| |
| namespace webrtc { |
| ModuleFileUtility::ModuleFileUtility() |
| : _wavFormatObj(), |
| _dataSize(0), |
| _readSizeBytes(0), |
| _stopPointInMs(0), |
| _startPointInMs(0), |
| _playoutPositionMs(0), |
| codec_info_(), |
| _codecId(kCodecNoCodec), |
| _bytesPerSample(0), |
| _readPos(0), |
| _reading(false), |
| _tempData() { |
| RTC_LOG(LS_INFO) << "ModuleFileUtility::ModuleFileUtility()"; |
| memset(&codec_info_, 0, sizeof(CodecInst)); |
| codec_info_.pltype = -1; |
| } |
| |
| ModuleFileUtility::~ModuleFileUtility() { |
| RTC_LOG(LS_INFO) << "ModuleFileUtility::~ModuleFileUtility()"; |
| } |
| |
| int32_t ModuleFileUtility::ReadWavHeader(InStream& wav) { |
| WAVE_RIFF_header RIFFheaderObj; |
| WAVE_CHUNK_header CHUNKheaderObj; |
| // TODO (hellner): tmpStr and tmpStr2 seems unnecessary here. |
| char tmpStr[6] = "FOUR"; |
| unsigned char tmpStr2[4]; |
| size_t i; |
| bool dataFound = false; |
| bool fmtFound = false; |
| int8_t dummyRead; |
| |
| _dataSize = 0; |
| int len = wav.Read(&RIFFheaderObj, sizeof(WAVE_RIFF_header)); |
| if (len != static_cast<int>(sizeof(WAVE_RIFF_header))) { |
| RTC_LOG(LS_ERROR) << "Not a wave file (too short)"; |
| return -1; |
| } |
| |
| for (i = 0; i < 4; i++) { |
| tmpStr[i] = RIFFheaderObj.ckID[i]; |
| } |
| if (strcmp(tmpStr, "RIFF") != 0) { |
| RTC_LOG(LS_ERROR) << "Not a wave file (does not have RIFF)"; |
| return -1; |
| } |
| for (i = 0; i < 4; i++) { |
| tmpStr[i] = RIFFheaderObj.wave_ckID[i]; |
| } |
| if (strcmp(tmpStr, "WAVE") != 0) { |
| RTC_LOG(LS_ERROR) << "Not a wave file (does not have WAVE)"; |
| return -1; |
| } |
| |
| len = wav.Read(&CHUNKheaderObj, sizeof(WAVE_CHUNK_header)); |
| |
| // WAVE files are stored in little endian byte order. Make sure that the |
| // data can be read on big endian as well. |
| // TODO (hellner): little endian to system byte order should be done in |
| // in a subroutine. |
| memcpy(tmpStr2, &CHUNKheaderObj.fmt_ckSize, 4); |
| CHUNKheaderObj.fmt_ckSize = |
| (uint32_t)tmpStr2[0] + (((uint32_t)tmpStr2[1]) << 8) + |
| (((uint32_t)tmpStr2[2]) << 16) + (((uint32_t)tmpStr2[3]) << 24); |
| |
| memcpy(tmpStr, CHUNKheaderObj.fmt_ckID, 4); |
| |
| while ((len == static_cast<int>(sizeof(WAVE_CHUNK_header))) && |
| (!fmtFound || !dataFound)) { |
| if (strcmp(tmpStr, "fmt ") == 0) { |
| len = wav.Read(&_wavFormatObj, sizeof(WAVE_FMTINFO_header)); |
| |
| memcpy(tmpStr2, &_wavFormatObj.formatTag, 2); |
| _wavFormatObj.formatTag = |
| (uint32_t)tmpStr2[0] + (((uint32_t)tmpStr2[1]) << 8); |
| memcpy(tmpStr2, &_wavFormatObj.nChannels, 2); |
| _wavFormatObj.nChannels = |
| (int16_t)((uint32_t)tmpStr2[0] + (((uint32_t)tmpStr2[1]) << 8)); |
| memcpy(tmpStr2, &_wavFormatObj.nSamplesPerSec, 4); |
| _wavFormatObj.nSamplesPerSec = (int32_t)( |
| (uint32_t)tmpStr2[0] + (((uint32_t)tmpStr2[1]) << 8) + |
| (((uint32_t)tmpStr2[2]) << 16) + (((uint32_t)tmpStr2[3]) << 24)); |
| memcpy(tmpStr2, &_wavFormatObj.nAvgBytesPerSec, 4); |
| _wavFormatObj.nAvgBytesPerSec = (int32_t)( |
| (uint32_t)tmpStr2[0] + (((uint32_t)tmpStr2[1]) << 8) + |
| (((uint32_t)tmpStr2[2]) << 16) + (((uint32_t)tmpStr2[3]) << 24)); |
| memcpy(tmpStr2, &_wavFormatObj.nBlockAlign, 2); |
| _wavFormatObj.nBlockAlign = |
| (int16_t)((uint32_t)tmpStr2[0] + (((uint32_t)tmpStr2[1]) << 8)); |
| memcpy(tmpStr2, &_wavFormatObj.nBitsPerSample, 2); |
| _wavFormatObj.nBitsPerSample = |
| (int16_t)((uint32_t)tmpStr2[0] + (((uint32_t)tmpStr2[1]) << 8)); |
| |
| if (CHUNKheaderObj.fmt_ckSize < sizeof(WAVE_FMTINFO_header)) { |
| RTC_LOG(LS_ERROR) << "Chunk size is too small"; |
| return -1; |
| } |
| for (i = 0; i < CHUNKheaderObj.fmt_ckSize - sizeof(WAVE_FMTINFO_header); |
| i++) { |
| len = wav.Read(&dummyRead, 1); |
| if (len != 1) { |
| RTC_LOG(LS_ERROR) << "File corrupted, reached EOF (reading fmt)"; |
| return -1; |
| } |
| } |
| fmtFound = true; |
| } else if (strcmp(tmpStr, "data") == 0) { |
| _dataSize = CHUNKheaderObj.fmt_ckSize; |
| dataFound = true; |
| break; |
| } else { |
| for (i = 0; i < CHUNKheaderObj.fmt_ckSize; i++) { |
| len = wav.Read(&dummyRead, 1); |
| if (len != 1) { |
| RTC_LOG(LS_ERROR) << "File corrupted, reached EOF (reading other)"; |
| return -1; |
| } |
| } |
| } |
| |
| len = wav.Read(&CHUNKheaderObj, sizeof(WAVE_CHUNK_header)); |
| |
| memcpy(tmpStr2, &CHUNKheaderObj.fmt_ckSize, 4); |
| CHUNKheaderObj.fmt_ckSize = |
| (uint32_t)tmpStr2[0] + (((uint32_t)tmpStr2[1]) << 8) + |
| (((uint32_t)tmpStr2[2]) << 16) + (((uint32_t)tmpStr2[3]) << 24); |
| |
| memcpy(tmpStr, CHUNKheaderObj.fmt_ckID, 4); |
| } |
| |
| // Either a proper format chunk has been read or a data chunk was come |
| // across. |
| if ((_wavFormatObj.formatTag != kWavFormatPcm) && |
| (_wavFormatObj.formatTag != kWavFormatALaw) && |
| (_wavFormatObj.formatTag != kWavFormatMuLaw)) { |
| RTC_LOG(LS_ERROR) << "Coding formatTag value=" << _wavFormatObj.formatTag |
| << " not supported!"; |
| return -1; |
| } |
| if ((_wavFormatObj.nChannels < 1) || (_wavFormatObj.nChannels > 2)) { |
| RTC_LOG(LS_ERROR) << "nChannels value=" << _wavFormatObj.nChannels |
| << " not supported!"; |
| return -1; |
| } |
| |
| if ((_wavFormatObj.nBitsPerSample != 8) && |
| (_wavFormatObj.nBitsPerSample != 16)) { |
| RTC_LOG(LS_ERROR) << "nBitsPerSample value=" << _wavFormatObj.nBitsPerSample |
| << " not supported!"; |
| return -1; |
| } |
| |
| // Calculate the number of bytes that 10 ms of audio data correspond to. |
| size_t samples_per_10ms = |
| ((_wavFormatObj.formatTag == kWavFormatPcm) && |
| (_wavFormatObj.nSamplesPerSec == 44100)) |
| ? 440 |
| : static_cast<size_t>(_wavFormatObj.nSamplesPerSec / 100); |
| _readSizeBytes = samples_per_10ms * _wavFormatObj.nChannels * |
| (_wavFormatObj.nBitsPerSample / 8); |
| return 0; |
| } |
| |
| int32_t ModuleFileUtility::InitWavCodec(uint32_t samplesPerSec, |
| size_t channels, |
| uint32_t bitsPerSample, |
| uint32_t formatTag) { |
| codec_info_.pltype = -1; |
| codec_info_.plfreq = samplesPerSec; |
| codec_info_.channels = channels; |
| codec_info_.rate = bitsPerSample * samplesPerSec; |
| |
| // Calculate the packet size for 10ms frames |
| switch (formatTag) { |
| case kWavFormatALaw: |
| strcpy(codec_info_.plname, "PCMA"); |
| _codecId = kCodecPcma; |
| codec_info_.pltype = 8; |
| codec_info_.pacsize = codec_info_.plfreq / 100; |
| break; |
| case kWavFormatMuLaw: |
| strcpy(codec_info_.plname, "PCMU"); |
| _codecId = kCodecPcmu; |
| codec_info_.pltype = 0; |
| codec_info_.pacsize = codec_info_.plfreq / 100; |
| break; |
| case kWavFormatPcm: |
| codec_info_.pacsize = (bitsPerSample * (codec_info_.plfreq / 100)) / 8; |
| if (samplesPerSec == 8000) { |
| strcpy(codec_info_.plname, "L16"); |
| _codecId = kCodecL16_8Khz; |
| } else if (samplesPerSec == 16000) { |
| strcpy(codec_info_.plname, "L16"); |
| _codecId = kCodecL16_16kHz; |
| } else if (samplesPerSec == 32000) { |
| strcpy(codec_info_.plname, "L16"); |
| _codecId = kCodecL16_32Khz; |
| } |
| // Set the packet size for "odd" sampling frequencies so that it |
| // properly corresponds to _readSizeBytes. |
| else if (samplesPerSec == 11025) { |
| strcpy(codec_info_.plname, "L16"); |
| _codecId = kCodecL16_16kHz; |
| codec_info_.pacsize = 110; |
| codec_info_.plfreq = 11000; |
| } else if (samplesPerSec == 22050) { |
| strcpy(codec_info_.plname, "L16"); |
| _codecId = kCodecL16_16kHz; |
| codec_info_.pacsize = 220; |
| codec_info_.plfreq = 22000; |
| } else if (samplesPerSec == 44100) { |
| strcpy(codec_info_.plname, "L16"); |
| _codecId = kCodecL16_16kHz; |
| codec_info_.pacsize = 440; |
| codec_info_.plfreq = 44000; |
| } else if (samplesPerSec == 48000) { |
| strcpy(codec_info_.plname, "L16"); |
| _codecId = kCodecL16_16kHz; |
| codec_info_.pacsize = 480; |
| codec_info_.plfreq = 48000; |
| } else { |
| RTC_LOG(LS_ERROR) << "Unsupported PCM frequency!"; |
| return -1; |
| } |
| break; |
| default: |
| RTC_LOG(LS_ERROR) << "unknown WAV format TAG!"; |
| return -1; |
| break; |
| } |
| return 0; |
| } |
| |
| int32_t ModuleFileUtility::InitWavReading(InStream& wav, |
| const uint32_t start, |
| const uint32_t stop) { |
| _reading = false; |
| |
| if (ReadWavHeader(wav) == -1) { |
| RTC_LOG(LS_ERROR) << "failed to read WAV header!"; |
| return -1; |
| } |
| |
| _playoutPositionMs = 0; |
| _readPos = 0; |
| |
| if (start > 0) { |
| uint8_t dummy[WAV_MAX_BUFFER_SIZE]; |
| int readLength; |
| if (_readSizeBytes <= WAV_MAX_BUFFER_SIZE) { |
| while (_playoutPositionMs < start) { |
| readLength = wav.Read(dummy, _readSizeBytes); |
| if (readLength == static_cast<int>(_readSizeBytes)) { |
| _readPos += _readSizeBytes; |
| _playoutPositionMs += 10; |
| } else // Must have reached EOF before start position! |
| { |
| RTC_LOG(LS_ERROR) << "InitWavReading(), EOF before start position"; |
| return -1; |
| } |
| } |
| } else { |
| return -1; |
| } |
| } |
| if (InitWavCodec(_wavFormatObj.nSamplesPerSec, _wavFormatObj.nChannels, |
| _wavFormatObj.nBitsPerSample, |
| _wavFormatObj.formatTag) != 0) { |
| return -1; |
| } |
| _bytesPerSample = static_cast<size_t>(_wavFormatObj.nBitsPerSample / 8); |
| |
| _startPointInMs = start; |
| _stopPointInMs = stop; |
| _reading = true; |
| return 0; |
| } |
| |
| int32_t ModuleFileUtility::ReadWavDataAsMono(InStream& wav, |
| int8_t* outData, |
| const size_t bufferSize) { |
| RTC_LOG(LS_VERBOSE) << "ModuleFileUtility::ReadWavDataAsMono(wav= " << &wav |
| << ", outData= " << static_cast<void*>(outData) |
| << ", bufSize= " << bufferSize << ")"; |
| |
| // The number of bytes that should be read from file. |
| const size_t totalBytesNeeded = _readSizeBytes; |
| // The number of bytes that will be written to outData. |
| const size_t bytesRequested = |
| (codec_info_.channels == 2) ? totalBytesNeeded >> 1 : totalBytesNeeded; |
| if (bufferSize < bytesRequested) { |
| RTC_LOG(LS_ERROR) << "ReadWavDataAsMono: output buffer is too short!"; |
| return -1; |
| } |
| if (outData == NULL) { |
| RTC_LOG(LS_ERROR) << "ReadWavDataAsMono: output buffer NULL!"; |
| return -1; |
| } |
| |
| if (!_reading) { |
| RTC_LOG(LS_ERROR) << "ReadWavDataAsMono: no longer reading file."; |
| return -1; |
| } |
| |
| int32_t bytesRead = ReadWavData( |
| wav, (codec_info_.channels == 2) ? _tempData : (uint8_t*)outData, |
| totalBytesNeeded); |
| if (bytesRead == 0) { |
| return 0; |
| } |
| if (bytesRead < 0) { |
| RTC_LOG(LS_ERROR) |
| << "ReadWavDataAsMono: failed to read data from WAV file."; |
| return -1; |
| } |
| // Output data is should be mono. |
| if (codec_info_.channels == 2) { |
| for (size_t i = 0; i < bytesRequested / _bytesPerSample; i++) { |
| // Sample value is the average of left and right buffer rounded to |
| // closest integer value. Note samples can be either 1 or 2 byte. |
| if (_bytesPerSample == 1) { |
| _tempData[i] = ((_tempData[2 * i] + _tempData[(2 * i) + 1] + 1) >> 1); |
| } else { |
| int16_t* sampleData = (int16_t*)_tempData; |
| sampleData[i] = |
| ((sampleData[2 * i] + sampleData[(2 * i) + 1] + 1) >> 1); |
| } |
| } |
| memcpy(outData, _tempData, bytesRequested); |
| } |
| return static_cast<int32_t>(bytesRequested); |
| } |
| |
| int32_t ModuleFileUtility::ReadWavData(InStream& wav, |
| uint8_t* buffer, |
| size_t dataLengthInBytes) { |
| RTC_LOG(LS_VERBOSE) << "ModuleFileUtility::ReadWavData(wav= " << &wav |
| << ", buffer= " << static_cast<void*>(buffer) |
| << ", dataLen= " << dataLengthInBytes << ")"; |
| |
| if (buffer == NULL) { |
| RTC_LOG(LS_ERROR) << "ReadWavDataAsMono: output buffer NULL!"; |
| return -1; |
| } |
| |
| // Make sure that a read won't return too few samples. |
| // TODO (hellner): why not read the remaining bytes needed from the start |
| // of the file? |
| if (_dataSize < (_readPos + dataLengthInBytes)) { |
| // Rewind() being -1 may be due to the file not supposed to be looped. |
| if (wav.Rewind() == -1) { |
| _reading = false; |
| return 0; |
| } |
| if (InitWavReading(wav, _startPointInMs, _stopPointInMs) == -1) { |
| _reading = false; |
| return -1; |
| } |
| } |
| |
| int32_t bytesRead = wav.Read(buffer, dataLengthInBytes); |
| if (bytesRead < 0) { |
| _reading = false; |
| return -1; |
| } |
| |
| // This should never happen due to earlier sanity checks. |
| // TODO (hellner): change to an assert and fail here since this should |
| // never happen... |
| if (bytesRead < (int32_t)dataLengthInBytes) { |
| if ((wav.Rewind() == -1) || |
| (InitWavReading(wav, _startPointInMs, _stopPointInMs) == -1)) { |
| _reading = false; |
| return -1; |
| } else { |
| bytesRead = wav.Read(buffer, dataLengthInBytes); |
| if (bytesRead < (int32_t)dataLengthInBytes) { |
| _reading = false; |
| return -1; |
| } |
| } |
| } |
| |
| _readPos += bytesRead; |
| |
| // TODO (hellner): Why is dataLengthInBytes let dictate the number of bytes |
| // to read when exactly 10ms should be read?! |
| _playoutPositionMs += 10; |
| if ((_stopPointInMs > 0) && (_playoutPositionMs >= _stopPointInMs)) { |
| if ((wav.Rewind() == -1) || |
| (InitWavReading(wav, _startPointInMs, _stopPointInMs) == -1)) { |
| _reading = false; |
| } |
| } |
| return bytesRead; |
| } |
| |
| int32_t ModuleFileUtility::InitPCMReading(InStream& pcm, |
| const uint32_t start, |
| const uint32_t stop, |
| uint32_t freq) { |
| RTC_LOG(LS_VERBOSE) << "ModuleFileUtility::InitPCMReading(pcm= " << &pcm |
| << ", start=" << start << ", stop=" << stop |
| << ", freq=" << freq << ")"; |
| |
| int8_t dummy[320]; |
| int read_len; |
| |
| _playoutPositionMs = 0; |
| _startPointInMs = start; |
| _stopPointInMs = stop; |
| _reading = false; |
| |
| if (freq == 8000) { |
| strcpy(codec_info_.plname, "L16"); |
| codec_info_.pltype = -1; |
| codec_info_.plfreq = 8000; |
| codec_info_.pacsize = 160; |
| codec_info_.channels = 1; |
| codec_info_.rate = 128000; |
| _codecId = kCodecL16_8Khz; |
| } else if (freq == 16000) { |
| strcpy(codec_info_.plname, "L16"); |
| codec_info_.pltype = -1; |
| codec_info_.plfreq = 16000; |
| codec_info_.pacsize = 320; |
| codec_info_.channels = 1; |
| codec_info_.rate = 256000; |
| _codecId = kCodecL16_16kHz; |
| } else if (freq == 32000) { |
| strcpy(codec_info_.plname, "L16"); |
| codec_info_.pltype = -1; |
| codec_info_.plfreq = 32000; |
| codec_info_.pacsize = 320; |
| codec_info_.channels = 1; |
| codec_info_.rate = 512000; |
| _codecId = kCodecL16_32Khz; |
| } else if (freq == 48000) { |
| strcpy(codec_info_.plname, "L16"); |
| codec_info_.pltype = -1; |
| codec_info_.plfreq = 48000; |
| codec_info_.pacsize = 480; |
| codec_info_.channels = 1; |
| codec_info_.rate = 768000; |
| _codecId = kCodecL16_48Khz; |
| } |
| |
| // Readsize for 10ms of audio data (2 bytes per sample). |
| _readSizeBytes = 2 * codec_info_.plfreq / 100; |
| if (_startPointInMs > 0) { |
| while (_playoutPositionMs < _startPointInMs) { |
| read_len = pcm.Read(dummy, _readSizeBytes); |
| if (read_len != static_cast<int>(_readSizeBytes)) { |
| return -1; // Must have reached EOF before start position! |
| } |
| _playoutPositionMs += 10; |
| } |
| } |
| _reading = true; |
| return 0; |
| } |
| |
| int32_t ModuleFileUtility::ReadPCMData(InStream& pcm, |
| int8_t* outData, |
| size_t bufferSize) { |
| RTC_LOG(LS_VERBOSE) << "ModuleFileUtility::ReadPCMData(pcm= " << &pcm |
| << ", outData= " << static_cast<void*>(outData) |
| << ", bufSize= " << bufferSize << ")"; |
| |
| if (outData == NULL) { |
| RTC_LOG(LS_ERROR) << "buffer NULL"; |
| } |
| |
| // Readsize for 10ms of audio data (2 bytes per sample). |
| size_t bytesRequested = static_cast<size_t>(2 * codec_info_.plfreq / 100); |
| if (bufferSize < bytesRequested) { |
| RTC_LOG(LS_ERROR) |
| << "ReadPCMData: buffer not long enough for a 10ms frame."; |
| assert(false); |
| return -1; |
| } |
| |
| int bytesRead = pcm.Read(outData, bytesRequested); |
| if (bytesRead < static_cast<int>(bytesRequested)) { |
| if (pcm.Rewind() == -1) { |
| _reading = false; |
| } else { |
| if (InitPCMReading(pcm, _startPointInMs, _stopPointInMs, |
| codec_info_.plfreq) == -1) { |
| _reading = false; |
| } else { |
| size_t rest = bytesRequested - bytesRead; |
| int len = pcm.Read(&(outData[bytesRead]), rest); |
| if (len == static_cast<int>(rest)) { |
| bytesRead += len; |
| } else { |
| _reading = false; |
| } |
| } |
| if (bytesRead <= 0) { |
| RTC_LOG(LS_ERROR) << "ReadPCMData: Failed to rewind audio file."; |
| return -1; |
| } |
| } |
| } |
| |
| if (bytesRead <= 0) { |
| RTC_LOG(LS_VERBOSE) << "ReadPCMData: end of file"; |
| return -1; |
| } |
| _playoutPositionMs += 10; |
| if (_stopPointInMs && _playoutPositionMs >= _stopPointInMs) { |
| if (!pcm.Rewind()) { |
| if (InitPCMReading(pcm, _startPointInMs, _stopPointInMs, |
| codec_info_.plfreq) == -1) { |
| _reading = false; |
| } |
| } |
| } |
| return bytesRead; |
| } |
| |
| int32_t ModuleFileUtility::codec_info(CodecInst& codecInst) { |
| RTC_LOG(LS_VERBOSE) << "ModuleFileUtility::codec_info(codecInst= " |
| << &codecInst << ")"; |
| |
| if (!_reading) { |
| RTC_LOG(LS_ERROR) << "CodecInst: not currently reading audio file!"; |
| return -1; |
| } |
| memcpy(&codecInst, &codec_info_, sizeof(CodecInst)); |
| return 0; |
| } |
| |
| int32_t ModuleFileUtility::set_codec_info(const CodecInst& codecInst) { |
| _codecId = kCodecNoCodec; |
| if (STR_CASE_CMP(codecInst.plname, "PCMU") == 0) { |
| _codecId = kCodecPcmu; |
| } else if (STR_CASE_CMP(codecInst.plname, "PCMA") == 0) { |
| _codecId = kCodecPcma; |
| } else if (STR_CASE_CMP(codecInst.plname, "L16") == 0) { |
| if (codecInst.plfreq == 8000) { |
| _codecId = kCodecL16_8Khz; |
| } else if (codecInst.plfreq == 16000) { |
| _codecId = kCodecL16_16kHz; |
| } else if (codecInst.plfreq == 32000) { |
| _codecId = kCodecL16_32Khz; |
| } else if (codecInst.plfreq == 48000) { |
| _codecId = kCodecL16_48Khz; |
| } |
| } |
| #ifdef WEBRTC_CODEC_ILBC |
| else if (STR_CASE_CMP(codecInst.plname, "ilbc") == 0) { |
| if (codecInst.pacsize == 160) { |
| _codecId = kCodecIlbc20Ms; |
| } else if (codecInst.pacsize == 240) { |
| _codecId = kCodecIlbc30Ms; |
| } |
| } |
| #endif |
| #if (defined(WEBRTC_CODEC_ISAC) || defined(WEBRTC_CODEC_ISACFX)) |
| else if (STR_CASE_CMP(codecInst.plname, "isac") == 0) { |
| if (codecInst.plfreq == 16000) { |
| _codecId = kCodecIsac; |
| } else if (codecInst.plfreq == 32000) { |
| _codecId = kCodecIsacSwb; |
| } |
| } |
| #endif |
| else if (STR_CASE_CMP(codecInst.plname, "G722") == 0) { |
| _codecId = kCodecG722; |
| } |
| if (_codecId == kCodecNoCodec) { |
| return -1; |
| } |
| memcpy(&codec_info_, &codecInst, sizeof(CodecInst)); |
| return 0; |
| } |
| |
| uint32_t ModuleFileUtility::PlayoutPositionMs() { |
| RTC_LOG(LS_VERBOSE) << "ModuleFileUtility::PlayoutPosition()"; |
| |
| return _reading ? _playoutPositionMs : 0; |
| } |
| } // namespace webrtc |
