Convert channel counts to size_t.

webrtc/modules/media_file/media_file_utility.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 246 matching lines @@
     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,
-                                        uint32_t channels,
+                                        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)
@@ skipping 389 matching lines @@
                                           const CodecInst& codecInst)
 {
 
     if(set_codec_info(codecInst) != 0)
     {
         WEBRTC_TRACE(kTraceError, kTraceFile, _id,
                      "codecInst identifies unsupported codec!");
         return -1;
     }
     _writing = false;
-    uint32_t channels = (codecInst.channels == 0) ?
-        1 : codecInst.channels;
+    size_t channels = (codecInst.channels == 0) ? 1 : codecInst.channels;
 
     if(STR_CASE_CMP(codecInst.plname, "PCMU") == 0)
     {
         _bytesPerSample = 1;
         if(WriteWavHeader(wav, 8000, _bytesPerSample, channels,
                           kWavFormatMuLaw, 0) == -1)
         {
             return -1;
         }
     }
@@ skipping 47 matching lines @@
     }
     _bytesWritten += dataLength;
     return static_cast<int32_t>(dataLength);
 }
 
 
 int32_t ModuleFileUtility::WriteWavHeader(
     OutStream& wav,
     uint32_t freq,
     size_t bytesPerSample,
-    uint32_t channels,
+    size_t channels,
     uint32_t format,
     size_t lengthInBytes)
 {
     // Frame size in bytes for 10 ms of audio.
     // TODO (hellner): 44.1 kHz has 440 samples frame size. Doesn't seem to
     //                 be taken into consideration here!
     const size_t frameSize = (freq / 100) * channels;
 
     // Calculate the number of full frames that the wave file contain.
     const size_t dataLengthInBytes = frameSize * (lengthInBytes / frameSize);
 
     uint8_t buf[kWavHeaderSize];
     webrtc::WriteWavHeader(buf, channels, freq, static_cast<WavFormat>(format),
                            bytesPerSample, dataLengthInBytes / bytesPerSample);
     wav.Write(buf, kWavHeaderSize);
     return 0;
 }
 
 int32_t ModuleFileUtility::UpdateWavHeader(OutStream& wav)
 {
     int32_t res = -1;
     if(wav.Rewind() == -1)
     {
         return -1;
     }
-    uint32_t channels = (codec_info_.channels == 0) ? 1 : codec_info_.channels;
+    size_t channels = (codec_info_.channels == 0) ? 1 : codec_info_.channels;
 
     if(STR_CASE_CMP(codec_info_.plname, "L16") == 0)
     {
         res = WriteWavHeader(wav, codec_info_.plfreq, 2, channels,
                              kWavFormatPcm, _bytesWritten);
     } else if(STR_CASE_CMP(codec_info_.plname, "PCMU") == 0) {
             res = WriteWavHeader(wav, 8000, 1, channels, kWavFormatMuLaw,
                                  _bytesWritten);
     } else if(STR_CASE_CMP(codec_info_.plname, "PCMA") == 0) {
             res = WriteWavHeader(wav, 8000, 1, channels, kWavFormatALaw,
@@ skipping 82 matching lines @@
     const CodecInst& codecInst)
 {
 
     if(set_codec_info(codecInst) != 0)
     {
         WEBRTC_TRACE(kTraceError, kTraceFile, _id, "CodecInst not recognized!");
         return -1;
     }
     _writing = true;
     _bytesWritten = 1;
-     out.Write(&_codecId, 1);
-     return 0;
+    out.Write(&_codecId, 1);
+    return 0;
 }
 
 int32_t ModuleFileUtility::WritePreEncodedData(
     OutStream& out,
-    const int8_t*  buffer,
+    const int8_t* buffer,
     const size_t dataLength)
 {
     WEBRTC_TRACE(kTraceStream, kTraceFile, _id,
                  "ModuleFileUtility::WritePreEncodedData(out= 0x%x, "
                  "inData= 0x%x, dataLen= %" PRIuS ")", &out, buffer,
                  dataLength);
 
     if(buffer == NULL)
     {
         WEBRTC_TRACE(kTraceError, kTraceFile, _id,"buffer NULL");
@@ skipping 122 matching lines @@
     {
         WEBRTC_TRACE(kTraceError, kTraceFile, _id, "not currently reading!");
         return -1;
     }
 
 #ifdef WEBRTC_CODEC_ILBC
     if((_codecId == kCodecIlbc20Ms) ||
         (_codecId == kCodecIlbc30Ms))
     {
         size_t byteSize = 0;
-         if(_codecId == kCodecIlbc30Ms)
+        if(_codecId == kCodecIlbc30Ms)
         {
             byteSize = 50;
         }
         if(_codecId == kCodecIlbc20Ms)
         {
             byteSize = 38;
         }
         if(bufferSize < byteSize)
         {
             WEBRTC_TRACE(kTraceError, kTraceFile, _id,
@@ skipping 527 matching lines @@
 }
 
 uint32_t ModuleFileUtility::PlayoutPositionMs()
 {
     WEBRTC_TRACE(kTraceStream, kTraceFile, _id,
                  "ModuleFileUtility::PlayoutPosition()");
 
     return _reading ? _playoutPositionMs : 0;
 }
 }  // namespace webrtc