Misc. small cleanups

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 61 matching lines @@
                  "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];
-    int32_t i, len;
+    int32_t i;
     bool dataFound = false;
     bool fmtFound = false;
     int8_t dummyRead;
 
 
     _dataSize = 0;
-    len = wav.Read(&RIFFheaderObj, sizeof(WAVE_RIFF_header));
-    if(len != sizeof(WAVE_RIFF_header))
+    int len = wav.Read(&RIFFheaderObj, sizeof(WAVE_RIFF_header));
+    if (len != static_cast<int>(sizeof(WAVE_RIFF_header)))
     {
         WEBRTC_TRACE(kTraceError, kTraceFile, _id,
                      "Not a wave file (too short)");
         return -1;
     }
 
     for (i = 0; i < 4; i++)
     {
         tmpStr[i] = RIFFheaderObj.ckID[i];
     }
@@ skipping 19 matching lines @@
     // 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 =
         (int32_t) ((uint32_t) tmpStr2[0] +
                          (((uint32_t)tmpStr2[1])<<8) +
                          (((uint32_t)tmpStr2[2])<<16) +
                          (((uint32_t)tmpStr2[3])<<24));
+    if (CHUNKheaderObj.fmt_ckSize < 0)

[niklas.enbom, 2016/01/07 20:16:46]

Chunk Size in wav header is an unsigned int and can use the full range afaik.
_dataSize was incorrect already before your CL, but this might be a good time to
fix it. 

[Peter Kasting, 2016/01/07 21:35:05]

So, to be clear, are you suggesting I remove this conditional, remove the
(int32_t) cast above, and change .fmt_ckSize to uint32_t?

[niklas.enbom, 2016/01/07 21:50:36]

That was my suggestion yes, but I haven't looked at how many other changes that
would lead to. It seems like it has been like this forever, so I'm fine with
just making the log clearer.

On 2016/01/07 21:35:05, Peter Kasting wrote:

[Peter Kasting, 2016/01/08 01:36:27]

I made the change.  As you suspected, this value is unsigned rather than signed
(I checked the specs as well as other WebRTC WAV-reading code).  In making this
change I cleaned up a few other issues in this file as well; look at the diff
for the latest patchset.

+    {
+        WEBRTC_TRACE(kTraceError, kTraceFile, _id,
+                     "Chunk size may not be negative");
+        return -1;
+    }
 
     memcpy(tmpStr, CHUNKheaderObj.fmt_ckID, 4);
 
-    while ((len == sizeof(WAVE_CHUNK_header)) && (!fmtFound || !dataFound))
+    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 =
@@ skipping 30 matching lines @@
                 {
                     WEBRTC_TRACE(kTraceError, kTraceFile, _id,
                                  "File corrupted, reached EOF (reading fmt)");
                     return -1;
                 }
             }
             fmtFound = true;
         }
         else if(strcmp(tmpStr, "data") == 0)
         {
-            _dataSize = CHUNKheaderObj.fmt_ckSize;
+            _dataSize = static_cast<size_t>(CHUNKheaderObj.fmt_ckSize);
             dataFound = true;
             break;
         }
         else
         {
             for (i = 0; i < (CHUNKheaderObj.fmt_ckSize); i++)
             {
                 len = wav.Read(&dummyRead, 1);
                 if(len != 1)
                 {
                     WEBRTC_TRACE(kTraceError, kTraceFile, _id,
                                  "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 =
             (int32_t) ((uint32_t)tmpStr2[0] +
                              (((uint32_t)tmpStr2[1])<<8) +
                              (((uint32_t)tmpStr2[2])<<16) +
                              (((uint32_t)tmpStr2[3])<<24));
+        if (CHUNKheaderObj.fmt_ckSize < 0)
+        {
+            WEBRTC_TRACE(kTraceError, kTraceFile, _id,
+                         "Chunk size may not be negative");
+            return -1;
+        }
 
         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))
     {
@@ skipping 14 matching lines @@
     if((_wavFormatObj.nBitsPerSample != 8) &&
         (_wavFormatObj.nBitsPerSample != 16))
     {
         WEBRTC_TRACE(kTraceError, kTraceFile, _id,
                      "nBitsPerSample value=%d not supported!",
                      _wavFormatObj.nBitsPerSample);
         return -1;
     }
 
     // Calculate the number of bytes that 10 ms of audio data correspond to.
-    if(_wavFormatObj.formatTag == kWavFormatPcm)
-    {
-        // TODO (hellner): integer division for 22050 and 11025 would yield
-        //                 the same result as the else statement. Remove those
-        //                 special cases?
-        if(_wavFormatObj.nSamplesPerSec == 44100)
-        {
-            _readSizeBytes = 440 * _wavFormatObj.nChannels *
-                (_wavFormatObj.nBitsPerSample / 8);
-        } else if(_wavFormatObj.nSamplesPerSec == 22050) {
-            _readSizeBytes = 220 * _wavFormatObj.nChannels *
-                (_wavFormatObj.nBitsPerSample / 8);
-        } else if(_wavFormatObj.nSamplesPerSec == 11025) {
-            _readSizeBytes = 110 * _wavFormatObj.nChannels *
-                (_wavFormatObj.nBitsPerSample / 8);
-        } else {
-            _readSizeBytes = (_wavFormatObj.nSamplesPerSec/100) *
-              _wavFormatObj.nChannels * (_wavFormatObj.nBitsPerSample / 8);
-        }
-
-    } else {
-        _readSizeBytes = (_wavFormatObj.nSamplesPerSec/100) *
-            _wavFormatObj.nChannels * (_wavFormatObj.nBitsPerSample / 8);
-    }
+    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,
                                         uint32_t bitsPerSample,
                                         uint32_t formatTag)
 {
     codec_info_.pltype   = -1;
     codec_info_.plfreq   = samplesPerSec;
@@ skipping 91 matching lines @@
                      "failed to read WAV header!");
         return -1;
     }
 
     _playoutPositionMs = 0;
     _readPos = 0;
 
     if(start > 0)
     {
         uint8_t dummy[WAV_MAX_BUFFER_SIZE];
-        int32_t readLength;
+        int readLength;
         if(_readSizeBytes <= WAV_MAX_BUFFER_SIZE)
         {
             while (_playoutPositionMs < start)
             {
                 readLength = wav.Read(dummy, _readSizeBytes);
-                if(readLength == _readSizeBytes)
+                if(readLength == static_cast<int>(_readSizeBytes))
                 {
-                    _readPos += readLength;
+                    _readPos += _readSizeBytes;
                     _playoutPositionMs += 10;
                 }
                 else // Must have reached EOF before start position!
                 {
                     WEBRTC_TRACE(kTraceError, kTraceFile, _id,
                        "InitWavReading(), EOF before start position");
                     return -1;
                 }
             }
         }
         else
         {
             return -1;
         }
     }
     if( InitWavCodec(_wavFormatObj.nSamplesPerSec, _wavFormatObj.nChannels,
                      _wavFormatObj.nBitsPerSample,
                      _wavFormatObj.formatTag) != 0)
     {
         return -1;
     }
-    _bytesPerSample = _wavFormatObj.nBitsPerSample / 8;
+    _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)
 {
     WEBRTC_TRACE(
         kTraceStream,
         kTraceFile,
         _id,
         "ModuleFileUtility::ReadWavDataAsMono(wav= 0x%x, outData= 0x%d, "
         "bufSize= %" PRIuS ")",
         &wav,
         outData,
         bufferSize);
 
     // The number of bytes that should be read from file.
-    const uint32_t totalBytesNeeded = _readSizeBytes;
+    const size_t totalBytesNeeded = _readSizeBytes;
     // The number of bytes that will be written to outData.
-    const uint32_t bytesRequested = (codec_info_.channels == 2) ?
+    const size_t bytesRequested = (codec_info_.channels == 2) ?
         totalBytesNeeded >> 1 : totalBytesNeeded;
     if(bufferSize < bytesRequested)
     {
         WEBRTC_TRACE(kTraceError, kTraceFile, _id,
                      "ReadWavDataAsMono: output buffer is too short!");
         return -1;
     }
     if(outData == NULL)
     {
         WEBRTC_TRACE(kTraceError, kTraceFile, _id,
@@ skipping 18 matching lines @@
     }
     if(bytesRead < 0)
     {
         WEBRTC_TRACE(kTraceError, kTraceFile, _id,
                      "ReadWavDataAsMono: failed to read data from WAV file.");
         return -1;
     }
     // Output data is should be mono.
     if(codec_info_.channels == 2)
     {
-        for (uint32_t i = 0; i < bytesRequested / _bytesPerSample; i++)
+        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 bytesRequested;
+    return static_cast<int32_t>(bytesRequested);
 }
 
 int32_t ModuleFileUtility::ReadWavDataAsStereo(
     InStream& wav,
     int8_t* outDataLeft,
     int8_t* outDataRight,
     const size_t bufferSize)
 {
     WEBRTC_TRACE(
         kTraceStream,
@@ skipping 23 matching lines @@
         return -1;
     }
     if(! _reading)
     {
         WEBRTC_TRACE(kTraceError, kTraceFile, _id,
                      "ReadWavDataAsStereo: no longer reading file.");
         return -1;
     }
 
     // The number of bytes that should be read from file.
-    const uint32_t totalBytesNeeded = _readSizeBytes;
+    const size_t totalBytesNeeded = _readSizeBytes;
     // The number of bytes that will be written to the left and the right
     // buffers.
-    const uint32_t bytesRequested = totalBytesNeeded >> 1;
+    const size_t bytesRequested = totalBytesNeeded >> 1;
     if(bufferSize < bytesRequested)
     {
         WEBRTC_TRACE(kTraceError, kTraceFile, _id,
                      "ReadWavData: Output buffers are too short!");
         assert(false);
         return -1;
     }
 
     int32_t bytesRead = ReadWavData(wav, _tempData, totalBytesNeeded);
     if(bytesRead <= 0)
     {
         WEBRTC_TRACE(kTraceError, kTraceFile, _id,
                      "ReadWavDataAsStereo: failed to read data from WAV file.");
         return -1;
     }
 
     // Turn interleaved audio to left and right buffer. Note samples can be
     // either 1 or 2 bytes
     if(_bytesPerSample == 1)
     {
-        for (uint32_t i = 0; i < bytesRequested; i++)
+        for (size_t i = 0; i < bytesRequested; i++)
         {
             outDataLeft[i]  = _tempData[2 * i];
             outDataRight[i] = _tempData[(2 * i) + 1];
         }
     }
     else if(_bytesPerSample == 2)
     {
         int16_t* sampleData = reinterpret_cast<int16_t*>(_tempData);
         int16_t* outLeft = reinterpret_cast<int16_t*>(outDataLeft);
         int16_t* outRight = reinterpret_cast<int16_t*>(
             outDataRight);
 
         // Bytes requested to samples requested.
-        uint32_t sampleCount = bytesRequested >> 1;
-        for (uint32_t i = 0; i < sampleCount; i++)
+        size_t sampleCount = bytesRequested >> 1;
+        for (size_t i = 0; i < sampleCount; i++)
         {
             outLeft[i] = sampleData[2 * i];
             outRight[i] = sampleData[(2 * i) + 1];
         }
     } else {
         WEBRTC_TRACE(kTraceError, kTraceFile, _id,
-                   "ReadWavStereoData: unsupported sample size %d!",
+                   "ReadWavStereoData: unsupported sample size %" PRIuS "!",
                    _bytesPerSample);
         assert(false);
         return -1;
     }
-    return bytesRequested;
+    return static_cast<int32_t>(bytesRequested);
 }
 
-int32_t ModuleFileUtility::ReadWavData(
-    InStream& wav,
-    uint8_t* buffer,
-    const uint32_t dataLengthInBytes)
+int32_t ModuleFileUtility::ReadWavData(InStream& wav,
+                                       uint8_t* buffer,
+                                       size_t dataLengthInBytes)
 {
-    WEBRTC_TRACE(
-        kTraceStream,
-        kTraceFile,
-        _id,
-        "ModuleFileUtility::ReadWavData(wav= 0x%x, buffer= 0x%x, dataLen= %ld)",
-        &wav,
-        buffer,
-        dataLengthInBytes);
+    WEBRTC_TRACE(kTraceStream, kTraceFile, _id,
+                 "ModuleFileUtility::ReadWavData(wav= 0x%x, buffer= 0x%x, "
+                 "dataLen= %" PRIuS ")", &wav, buffer, dataLengthInBytes);
 
 
     if(buffer == NULL)
     {
         WEBRTC_TRACE(kTraceError, kTraceFile, _id,
                      "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) < (int32_t)dataLengthInBytes)
+    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;
@@ skipping 62 matching lines @@
         1 : codecInst.channels;
 
     if(STR_CASE_CMP(codecInst.plname, "PCMU") == 0)
     {
         _bytesPerSample = 1;
         if(WriteWavHeader(wav, 8000, _bytesPerSample, channels,
                           kWavFormatMuLaw, 0) == -1)
         {
             return -1;
         }
-    }else if(STR_CASE_CMP(codecInst.plname, "PCMA") == 0)
+    }
+    else if(STR_CASE_CMP(codecInst.plname, "PCMA") == 0)
     {
         _bytesPerSample = 1;
         if(WriteWavHeader(wav, 8000, _bytesPerSample, channels, kWavFormatALaw,
                           0) == -1)
         {
             return -1;
         }
     }
     else if(STR_CASE_CMP(codecInst.plname, "L16") == 0)
     {
@@ skipping 12 matching lines @@
     }
     _writing = true;
     _bytesWritten = 0;
     return 0;
 }
 
 int32_t ModuleFileUtility::WriteWavData(OutStream& out,
                                         const int8_t*  buffer,
                                         const size_t dataLength)
 {
-    WEBRTC_TRACE(
-        kTraceStream,
-        kTraceFile,
-        _id,
-        "ModuleFileUtility::WriteWavData(out= 0x%x, buf= 0x%x, dataLen= %" PRIuS
-        ")",
-        &out,
-        buffer,
-        dataLength);
+    WEBRTC_TRACE(kTraceStream, kTraceFile, _id,
+                 "ModuleFileUtility::WriteWavData(out= 0x%x, buf= 0x%x, "
+                 "dataLen= %" PRIuS ")", &out, buffer, dataLength);
 
     if(buffer == NULL)
     {
         WEBRTC_TRACE(kTraceError, kTraceFile, _id,
                      "WriteWavData: input buffer NULL!");
         return -1;
     }
 
     if(!out.Write(buffer, dataLength))
     {
         return -1;
     }
     _bytesWritten += dataLength;
     return static_cast<int32_t>(dataLength);
 }
 
 
 int32_t ModuleFileUtility::WriteWavHeader(
     OutStream& wav,
-    const uint32_t freq,
-    const uint32_t bytesPerSample,
-    const uint32_t channels,
-    const uint32_t format,
-    const uint32_t lengthInBytes)
+    uint32_t freq,
+    size_t bytesPerSample,
+    uint32_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 int32_t frameSize = (freq / 100) * channels;
+    const size_t frameSize = (freq / 100) * channels;
 
     // Calculate the number of full frames that the wave file contain.
-    const int32_t dataLengthInBytes = frameSize * (lengthInBytes / frameSize);
+    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;
+    uint32_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 32 matching lines @@
     memcpy(&codec_info_,&cinst,sizeof(CodecInst));
     _reading = true;
     return 0;
 }
 
 int32_t ModuleFileUtility::ReadPreEncodedData(
     InStream& in,
     int8_t* outData,
     const size_t bufferSize)
 {
-    WEBRTC_TRACE(
-        kTraceStream,
-        kTraceFile,
-        _id,
-        "ModuleFileUtility::ReadPreEncodedData(in= 0x%x, outData= 0x%x, "
-        "bufferSize= %" PRIuS ")",
-        &in,
-        outData,
-        bufferSize);
+    WEBRTC_TRACE(kTraceStream, kTraceFile, _id,
+                 "ModuleFileUtility::ReadPreEncodedData(in= 0x%x, "
+                 "outData= 0x%x, bufferSize= %" PRIuS ")", &in, outData,
+                 bufferSize);
 
     if(outData == NULL)
     {
         WEBRTC_TRACE(kTraceError, kTraceFile, _id, "output buffer NULL");
     }
 
-    uint32_t frameLen;
+    size_t frameLen;
     uint8_t buf[64];
     // Each frame has a two byte header containing the frame length.
     int32_t res = in.Read(buf, 2);
     if(res != 2)
     {
         if(!in.Rewind())
         {
             // The first byte is the codec identifier.
             in.Read(buf, 1);
             res = in.Read(buf, 2);
         }
         else
         {
             return -1;
         }
     }
     frameLen = buf[0] + buf[1] * 256;
     if(bufferSize < frameLen)
     {
-        WEBRTC_TRACE(
-            kTraceError,
-            kTraceFile,
-            _id,
-            "buffer not large enough to read %d bytes of pre-encoded data!",
-            frameLen);
+        WEBRTC_TRACE(kTraceError, kTraceFile, _id,
+                     "buffer not large enough to read %" PRIuS " bytes of "
+                     "pre-encoded data!", frameLen);
         return -1;
     }
     return in.Read(outData, frameLen);
 }
 
 int32_t ModuleFileUtility::InitPreEncodedWriting(
     OutStream& out,
     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;
 }
 
 int32_t ModuleFileUtility::WritePreEncodedData(
     OutStream& out,
     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);
+    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");
     }
 
     size_t bytesWritten = 0;
     // The first two bytes is the size of the frame.
     int16_t lengthBuf;
     lengthBuf = (int16_t)dataLength;
@@ skipping 10 matching lines @@
     }
     bytesWritten += dataLength;
     return static_cast<int32_t>(bytesWritten);
 }
 
 int32_t ModuleFileUtility::InitCompressedReading(
     InStream& in,
     const uint32_t start,
     const uint32_t stop)
 {
-    WEBRTC_TRACE(
-        kTraceDebug,
-        kTraceFile,
-        _id,
-        "ModuleFileUtility::InitCompressedReading(in= 0x%x, start= %d,\
- stop= %d)",
-        &in,
-        start,
-        stop);
+    WEBRTC_TRACE(kTraceDebug, kTraceFile, _id,
+                 "ModuleFileUtility::InitCompressedReading(in= 0x%x, "
+                 "start= %d, stop= %d)", &in, start, stop);
 
 #if defined(WEBRTC_CODEC_ILBC)
     int16_t read_len = 0;
 #endif
     _codecId = kCodecNoCodec;
     _playoutPositionMs = 0;
     _reading = false;
 
     _startPointInMs = start;
     _stopPointInMs = stop;
 
     // Read the codec name
     int32_t cnt = 0;
     char buf[64];
     do
     {
         in.Read(&buf[cnt++], 1);
     } while ((buf[cnt-1] != '\n') && (64 > cnt));
 
     if(cnt==64)
     {
         return -1;
-    } else {
-        buf[cnt]=0;
     }
+    buf[cnt]=0;
 
 #ifdef WEBRTC_CODEC_ILBC
     if(!strcmp("#!iLBC20\n", buf))
     {
         codec_info_.pltype = 102;
         strcpy(codec_info_.plname, "ilbc");
         codec_info_.plfreq   = 8000;
         codec_info_.pacsize  = 160;
         codec_info_.channels = 1;
         codec_info_.rate     = 13300;
         _codecId = kCodecIlbc20Ms;
 
         if(_startPointInMs > 0)
         {
             while (_playoutPositionMs <= _startPointInMs)
             {
                 read_len = in.Read(buf, 38);
-                if(read_len == 38)
-                {
-                    _playoutPositionMs += 20;
-                }
-                else
+                if(read_len != 38)
                 {
                     return -1;
                 }
+                _playoutPositionMs += 20;
             }
         }
     }
 
     if(!strcmp("#!iLBC30\n", buf))
     {
         codec_info_.pltype = 102;
         strcpy(codec_info_.plname, "ilbc");
         codec_info_.plfreq   = 8000;
         codec_info_.pacsize  = 240;
         codec_info_.channels = 1;
         codec_info_.rate     = 13300;
         _codecId = kCodecIlbc30Ms;
 
         if(_startPointInMs > 0)
         {
             while (_playoutPositionMs <= _startPointInMs)
             {
                 read_len = in.Read(buf, 50);
-                if(read_len == 50)
-                {
-                    _playoutPositionMs += 20;
-                }
-                else
+                if(read_len != 50)
                 {
                     return -1;
                 }
+                _playoutPositionMs += 20;
             }
         }
     }
 #endif
     if(_codecId == kCodecNoCodec)
     {
         return -1;
     }
     _reading = true;
     return 0;
 }
 
 int32_t ModuleFileUtility::ReadCompressedData(InStream& in,
                                               int8_t* outData,
                                               size_t bufferSize)
 {
-    WEBRTC_TRACE(
-        kTraceStream,
-        kTraceFile,
-        _id,
-        "ModuleFileUtility::ReadCompressedData(in=0x%x, outData=0x%x, bytes=%"
-        PRIuS ")",
-        &in,
-        outData,
-        bufferSize);
+    WEBRTC_TRACE(kTraceStream, kTraceFile, _id,
+                 "ModuleFileUtility::ReadCompressedData(in=0x%x, outData=0x%x, "
+                 "bytes=%" PRIuS ")", &in, outData, bufferSize);
 
-    uint32_t bytesRead = 0;
+    int bytesRead = 0;
 
     if(! _reading)
     {
         WEBRTC_TRACE(kTraceError, kTraceFile, _id, "not currently reading!");
         return -1;
     }
 
 #ifdef WEBRTC_CODEC_ILBC
     if((_codecId == kCodecIlbc20Ms) ||
         (_codecId == kCodecIlbc30Ms))
     {
-        uint32_t byteSize = 0;
+        size_t byteSize = 0;
          if(_codecId == kCodecIlbc30Ms)
         {
             byteSize = 50;
         }
         if(_codecId == kCodecIlbc20Ms)
         {
             byteSize = 38;
         }
         if(bufferSize < byteSize)
         {
             WEBRTC_TRACE(kTraceError, kTraceFile, _id,
-                           "output buffer is too short to read ILBC compressed\
- data.");
+                         "output buffer is too short to read ILBC compressed "
+                         "data.");
             assert(false);
             return -1;
         }
 
         bytesRead = in.Read(outData, byteSize);
-        if(bytesRead != byteSize)
+        if(bytesRead != static_cast<int>(byteSize))
         {
             if(!in.Rewind())
             {
                 InitCompressedReading(in, _startPointInMs, _stopPointInMs);
                 bytesRead = in.Read(outData, byteSize);
-                if(bytesRead != byteSize)
+                if(bytesRead != static_cast<int>(byteSize))
                 {
                     _reading = false;
                     return -1;
                 }
             }
             else
             {
                 _reading = false;
                 return -1;
             }
@@ skipping 21 matching lines @@
         }
     }
     return bytesRead;
 }
 
 int32_t ModuleFileUtility::InitCompressedWriting(
     OutStream& out,
     const CodecInst& codecInst)
 {
     WEBRTC_TRACE(kTraceDebug, kTraceFile, _id,
-               "ModuleFileUtility::InitCompressedWriting(out= 0x%x,\
- codecName= %s)",
-               &out, codecInst.plname);
+                 "ModuleFileUtility::InitCompressedWriting(out= 0x%x, "
+                 "codecName= %s)", &out, codecInst.plname);
 
     _writing = false;
 
 #ifdef WEBRTC_CODEC_ILBC
     if(STR_CASE_CMP(codecInst.plname, "ilbc") == 0)
     {
         if(codecInst.pacsize == 160)
         {
             _codecId = kCodecIlbc20Ms;
             out.Write("#!iLBC20\n",9);
@@ skipping 18 matching lines @@
     WEBRTC_TRACE(kTraceError, kTraceFile, _id,
                  "codecInst defines unsupported compression codec!");
     return -1;
 }
 
 int32_t ModuleFileUtility::WriteCompressedData(
     OutStream& out,
     const int8_t* buffer,
     const size_t dataLength)
 {
-    WEBRTC_TRACE(
-        kTraceStream,
-        kTraceFile,
-        _id,
-        "ModuleFileUtility::WriteCompressedData(out= 0x%x, buf= 0x%x, "
-        "dataLen= %" PRIuS ")",
-        &out,
-        buffer,
-        dataLength);
+    WEBRTC_TRACE(kTraceStream, kTraceFile, _id,
+                 "ModuleFileUtility::WriteCompressedData(out= 0x%x, buf= 0x%x, "
+                 "dataLen= %" PRIuS ")", &out, buffer, dataLength);
 
     if(buffer == NULL)
     {
         WEBRTC_TRACE(kTraceError, kTraceFile, _id,"buffer NULL");
     }
 
     if(!out.Write(buffer, dataLength))
     {
         return -1;
     }
     return static_cast<int32_t>(dataLength);
 }
 
 int32_t ModuleFileUtility::InitPCMReading(InStream& pcm,
                                           const uint32_t start,
                                           const uint32_t stop,
                                           uint32_t freq)
 {
-    WEBRTC_TRACE(
-        kTraceInfo,
-        kTraceFile,
-        _id,
-        "ModuleFileUtility::InitPCMReading(pcm= 0x%x, start=%d, stop=%d,\
- freq=%d)",
-        &pcm,
-        start,
-        stop,
-        freq);
+    WEBRTC_TRACE(kTraceInfo, kTraceFile, _id,
+                 "ModuleFileUtility::InitPCMReading(pcm= 0x%x, start=%d, "
+                 "stop=%d, freq=%d)", &pcm, start, stop, freq);
 
     int8_t dummy[320];
-    int32_t read_len;
+    int read_len;
 
     _playoutPositionMs = 0;
     _startPointInMs = start;
     _stopPointInMs = stop;
     _reading = false;
 
     if(freq == 8000)
     {
         strcpy(codec_info_.plname, "L16");
         codec_info_.pltype   = -1;
@@ skipping 24 matching lines @@
         _codecId = kCodecL16_32Khz;
     }
 
     // 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 == _readSizeBytes)
+            if(read_len != static_cast<int>(_readSizeBytes))
             {
-                _playoutPositionMs += 10;
+                return -1;  // Must have reached EOF before start position!
             }
-            else // Must have reached EOF before start position!
-            {
-                return -1;
-            }
+            _playoutPositionMs += 10;
         }
     }
     _reading = true;
     return 0;
 }
 
 int32_t ModuleFileUtility::ReadPCMData(InStream& pcm,
                                        int8_t* outData,
                                        size_t bufferSize)
 {
-    WEBRTC_TRACE(
-        kTraceStream,
-        kTraceFile,
-        _id,
-        "ModuleFileUtility::ReadPCMData(pcm= 0x%x, outData= 0x%x, bufSize= %"
-        PRIuS ")",
-        &pcm,
-        outData,
-        bufferSize);
+    WEBRTC_TRACE(kTraceStream, kTraceFile, _id,
+                 "ModuleFileUtility::ReadPCMData(pcm= 0x%x, outData= 0x%x, "
+                 "bufSize= %" PRIuS ")", &pcm, outData, bufferSize);
 
     if(outData == NULL)
     {
-        WEBRTC_TRACE(kTraceError, kTraceFile, _id,"buffer NULL");
+        WEBRTC_TRACE(kTraceError, kTraceFile, _id, "buffer NULL");
     }
 
     // Readsize for 10ms of audio data (2 bytes per sample).
-    uint32_t bytesRequested = 2 * codec_info_.plfreq / 100;
+    size_t bytesRequested = static_cast<size_t>(2 * codec_info_.plfreq / 100);
     if(bufferSize <  bytesRequested)
     {
         WEBRTC_TRACE(kTraceError, kTraceFile, _id,
                    "ReadPCMData: buffer not long enough for a 10ms frame.");
         assert(false);
         return -1;
     }
 
-    uint32_t bytesRead = pcm.Read(outData, bytesRequested);
-    if(bytesRead < bytesRequested)
+    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
             {
-                int32_t rest = bytesRequested - bytesRead;
-                int32_t len = pcm.Read(&(outData[bytesRead]), rest);
-                if(len == rest)
+                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)
             {
                 WEBRTC_TRACE(kTraceError, kTraceFile, _id,
-                        "ReadPCMData: Failed to rewind audio file.");
+                             "ReadPCMData: Failed to rewind audio file.");
                 return -1;
             }
         }
     }
 
     if(bytesRead <= 0)
     {
         WEBRTC_TRACE(kTraceStream, kTraceFile, _id,
-                   "ReadPCMData: end of file");
+                     "ReadPCMData: end of file");
         return -1;
     }
     _playoutPositionMs += 10;
     if(_stopPointInMs && _playoutPositionMs >= _stopPointInMs)
     {
         if(!pcm.Rewind())
         {
             if(InitPCMReading(pcm, _startPointInMs, _stopPointInMs,
                               codec_info_.plfreq) == -1)
             {
@@ skipping 50 matching lines @@
     }
     _writing = true;
     _bytesWritten = 0;
     return 0;
 }
 
 int32_t ModuleFileUtility::WritePCMData(OutStream& out,
                                         const int8_t*  buffer,
                                         const size_t dataLength)
 {
-    WEBRTC_TRACE(
-        kTraceStream,
-        kTraceFile,
-        _id,
-        "ModuleFileUtility::WritePCMData(out= 0x%x, buf= 0x%x, dataLen= %" PRIuS
-        ")",
-        &out,
-        buffer,
-        dataLength);
+    WEBRTC_TRACE(kTraceStream, kTraceFile, _id,
+                 "ModuleFileUtility::WritePCMData(out= 0x%x, buf= 0x%x, "
+                 "dataLen= %" PRIuS ")", &out, buffer, dataLength);
 
     if(buffer == NULL)
     {
         WEBRTC_TRACE(kTraceError, kTraceFile, _id, "buffer NULL");
     }
 
     if(!out.Write(buffer, dataLength))
     {
         return -1;
     }
@@ skipping 142 matching lines @@
         case kFileFormatPcm8kHzFile:
         {
             // 8 samples per ms. 2 bytes per sample.
             int32_t denominator = 8*2;
             time_in_ms = (file_size.st_size)/denominator;
             break;
         }
         case kFileFormatCompressedFile:
         {
             int32_t cnt = 0;
-            int32_t read_len = 0;
+            int read_len = 0;
             char buf[64];
             do
             {
                 read_len = inStreamObj->Read(&buf[cnt++], 1);
                 if(read_len != 1)
                 {
                     return -1;
                 }
             } while ((buf[cnt-1] != '\n') && (64 > cnt));
 
@@ skipping 36 matching lines @@
             break;
     }
     inStreamObj->CloseFile();
     delete inStreamObj;
     return time_in_ms;
 }
 
 uint32_t ModuleFileUtility::PlayoutPositionMs()
 {
     WEBRTC_TRACE(kTraceStream, kTraceFile, _id,
-               "ModuleFileUtility::PlayoutPosition()");
+                 "ModuleFileUtility::PlayoutPosition()");
 
-    if(_reading)
-    {
-        return _playoutPositionMs;
-    }
-    else
-    {
-        return 0;
-    }
+    return _reading ? _playoutPositionMs : 0;
 }
 }  // namespace webrtc