Supporting 48kHz PCM file.

webrtc/modules/media_file/media_file_impl.cc

 /*
  *  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.
  */
 
@@ skipping 114 matching lines @@
         if(!_ptrFileUtilityObj)
         {
             WEBRTC_TRACE(kTraceError, kTraceFile, _id,
                          "Playing, but no FileUtility object!");
             StopPlaying();
             return -1;
         }
 
         switch(_fileFormat)
         {
+            case kFileFormatPcm48kHzFile:
             case kFileFormatPcm32kHzFile:
             case kFileFormatPcm16kHzFile:
             case kFileFormatPcm8kHzFile:
                 bytesRead = _ptrFileUtilityObj->ReadPCMData(
                     *_ptrInStream,
                     buffer,
                     bufferLengthInBytes);
                 break;
             case kFileFormatCompressedFile:
                 bytesRead = _ptrFileUtilityObj->ReadCompressedData(
@@ skipping 327 matching lines @@
                              "Not a valid Compressed file!");
                 StopPlaying();
                 return -1;
             }
             _fileFormat = kFileFormatCompressedFile;
             break;
         }
         case kFileFormatPcm8kHzFile:
         case kFileFormatPcm16kHzFile:
         case kFileFormatPcm32kHzFile:
+        case kFileFormatPcm48kHzFile:
         {
             // ValidFileFormat() called in the beginneing of this function
             // prevents codecInst from being NULL here.
             assert(codecInst != NULL);
             if(!ValidFrequency(codecInst->plfreq) ||
                _ptrFileUtilityObj->InitPCMReading(stream, startPointMs,
                                                   stopPointMs,
                                                   codecInst->plfreq) == -1)
             {
                 WEBRTC_TRACE(kTraceError, kTraceFile, _id,
@@ skipping 132 matching lines @@
 
         int32_t bytesWritten = 0;
         uint32_t samplesWritten = codec_info_.pacsize;
         if(_ptrFileUtilityObj)
         {
             switch(_fileFormat)
             {
                 case kFileFormatPcm8kHzFile:
                 case kFileFormatPcm16kHzFile:
                 case kFileFormatPcm32kHzFile:
+                case kFileFormatPcm48kHzFile:
                     bytesWritten = _ptrFileUtilityObj->WritePCMData(
                         *_ptrOutStream,
                         buffer,
                         bufferLengthInBytes);
 
                     // Sample size is 2 bytes.
                     if(bytesWritten > 0)
                     {
                         samplesWritten = bytesWritten/sizeof(int16_t);
                     }
@@ skipping 194 matching lines @@
                              "Failed to initialize Compressed file!");
                 delete _ptrFileUtilityObj;
                 _ptrFileUtilityObj = NULL;
                 return -1;
             }
             _fileFormat = kFileFormatCompressedFile;
             break;
         }
         case kFileFormatPcm8kHzFile:
         case kFileFormatPcm16kHzFile:
+        case kFileFormatPcm32kHzFile:
+        case kFileFormatPcm48kHzFile:
         {
             if(!ValidFrequency(codecInst.plfreq) ||
                _ptrFileUtilityObj->InitPCMWriting(stream, codecInst.plfreq) ==
                -1)
             {
                 WEBRTC_TRACE(kTraceError, kTraceFile, _id,
-                             "Failed to initialize 8 or 16KHz PCM file!");
+                             "Failed to initialize PCM file!");
                 delete _ptrFileUtilityObj;
                 _ptrFileUtilityObj = NULL;
                 return -1;
             }
             _fileFormat = format;
             break;
         }
         case kFileFormatPreencodedFile:
         {
             if(_ptrFileUtilityObj->InitPreEncodedWriting(stream, codecInst) ==
@@ skipping 198 matching lines @@
 }
 
 bool MediaFileImpl::ValidFileFormat(const FileFormats format,
                                     const CodecInst*  codecInst)
 {
     if(codecInst == NULL)
     {
         if(format == kFileFormatPreencodedFile ||
            format == kFileFormatPcm8kHzFile    ||
            format == kFileFormatPcm16kHzFile   ||
-           format == kFileFormatPcm32kHzFile)
+           format == kFileFormatPcm32kHzFile   ||
+           format == kFileFormatPcm48kHzFile)
         {
             WEBRTC_TRACE(kTraceError, kTraceFile, -1,
                          "Codec info required for file format specified!");
             return false;
         }
     }
     return true;
 }
 
 bool MediaFileImpl::ValidFileName(const char* fileName)
@@ skipping 24 matching lines @@
     {
         WEBRTC_TRACE(kTraceError, kTraceFile, -1,
                      "minimum play duration for files is 20 ms!");
         return false;
     }
     return true;
 }
 
 bool MediaFileImpl::ValidFrequency(const uint32_t frequency)
 {
-    if((frequency == 8000) || (frequency == 16000)|| (frequency == 32000))
+    if((frequency == 8000) || (frequency == 16000)|| (frequency == 32000) || (frequency == 48000))
     {
         return true;
     }
     WEBRTC_TRACE(kTraceError, kTraceFile, -1,
-                 "Frequency should be 8000, 16000 or 32000 (Hz)");
+                 "Frequency should be 8000, 16000, 32000, or 48000 (Hz)");
     return false;
 }
 }  // namespace webrtc