Fix trivial lint errors in FileRecorder and FilePlayer

webrtc/modules/utility/source/file_player.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.
  */
 
 #include "webrtc/modules/utility/include/file_player.h"
 
 #include "webrtc/common_audio/resampler/include/resampler.h"
 #include "webrtc/common_types.h"
 #include "webrtc/engine_configurations.h"
 #include "webrtc/modules/media_file/media_file.h"
 #include "webrtc/modules/media_file/media_file_defines.h"
 #include "webrtc/modules/utility/source/coder.h"
 #include "webrtc/system_wrappers/include/critical_section_wrapper.h"
 #include "webrtc/system_wrappers/include/logging.h"
 #include "webrtc/typedefs.h"
 
 namespace webrtc {
 
 namespace {
 
 class FilePlayerImpl : public FilePlayer {
  public:
   FilePlayerImpl(uint32_t instanceID, FileFormats fileFormat);
-  ~FilePlayerImpl();
+  ~FilePlayerImpl() override;
 
-  virtual int Get10msAudioFromFile(int16_t* outBuffer,
-                                   size_t& lengthInSamples,
-                                   int frequencyInHz);
-  virtual int32_t RegisterModuleFileCallback(FileCallback* callback);
-  virtual int32_t StartPlayingFile(const char* fileName,
-                                   bool loop,
-                                   uint32_t startPosition,
-                                   float volumeScaling,
-                                   uint32_t notification,
-                                   uint32_t stopPosition,
-                                   const CodecInst* codecInst);
-  virtual int32_t StartPlayingFile(InStream& sourceStream,
-                                   uint32_t startPosition,
-                                   float volumeScaling,
-                                   uint32_t notification,
-                                   uint32_t stopPosition,
-                                   const CodecInst* codecInst);
-  virtual int32_t StopPlayingFile();
-  virtual bool IsPlayingFile() const;
-  virtual int32_t GetPlayoutPosition(uint32_t& durationMs);
-  virtual int32_t AudioCodec(CodecInst& audioCodec) const;
-  virtual int32_t Frequency() const;
-  virtual int32_t SetAudioScaling(float scaleFactor);
+  int Get10msAudioFromFile(int16_t* outBuffer,
+                           size_t* lengthInSamples,
+                           int frequencyInHz) override;
+  int32_t RegisterModuleFileCallback(FileCallback* callback) override;
+  int32_t StartPlayingFile(const char* fileName,
+                           bool loop,
+                           uint32_t startPosition,
+                           float volumeScaling,
+                           uint32_t notification,
+                           uint32_t stopPosition,
+                           const CodecInst* codecInst) override;
+  int32_t StartPlayingFile(InStream* sourceStream,
+                           uint32_t startPosition,
+                           float volumeScaling,
+                           uint32_t notification,
+                           uint32_t stopPosition,
+                           const CodecInst* codecInst) override;
+  int32_t StopPlayingFile() override;
+  bool IsPlayingFile() const override;
+  int32_t GetPlayoutPosition(uint32_t* durationMs) override;
+  int32_t AudioCodec(CodecInst* audioCodec) const override;
+  int32_t Frequency() const override;
+  int32_t SetAudioScaling(float scaleFactor) override;
 
  private:
   int32_t SetUpAudioDecoder();
 
   const FileFormats _fileFormat;
   MediaFile& _fileModule;
 
   uint32_t _decodedLengthInMS;
 
   AudioCoder _audioDecoder;
@@ skipping 36 matching lines @@
     return 32000;
   } else if (_codec.plfreq == 44000) {
     return 32000;
   } else if (_codec.plfreq == 48000) {
     return 32000;
   } else {
     return _codec.plfreq;
   }
 }
 
-int32_t FilePlayerImpl::AudioCodec(CodecInst& audioCodec) const {
-  audioCodec = _codec;
+int32_t FilePlayerImpl::AudioCodec(CodecInst* audioCodec) const {
+  *audioCodec = _codec;
   return 0;
 }
 
 int32_t FilePlayerImpl::Get10msAudioFromFile(int16_t* outBuffer,
-                                             size_t& lengthInSamples,
+                                             size_t* lengthInSamples,
                                              int frequencyInHz) {
   if (_codec.plfreq == 0) {
     LOG(LS_WARNING) << "Get10msAudioFromFile() playing not started!"
                     << " codec freq = " << _codec.plfreq
                     << ", wanted freq = " << frequencyInHz;
     return -1;
   }
 
   AudioFrame unresampledAudioFrame;
   if (STR_CASE_CMP(_codec.plname, "L16") == 0) {
     unresampledAudioFrame.sample_rate_hz_ = _codec.plfreq;
 
     // L16 is un-encoded data. Just pull 10 ms.
     size_t lengthInBytes = sizeof(unresampledAudioFrame.data_);
-    if (_fileModule.PlayoutAudioData((int8_t*)unresampledAudioFrame.data_,
-                                     lengthInBytes) == -1) {
+    if (_fileModule.PlayoutAudioData(
+            reinterpret_cast<int8_t*>(unresampledAudioFrame.data_),
+            lengthInBytes) == -1) {
       // End of file reached.
       return -1;
     }
     if (lengthInBytes == 0) {
-      lengthInSamples = 0;
+      *lengthInSamples = 0;
       return 0;
     }
     // One sample is two bytes.
     unresampledAudioFrame.samples_per_channel_ = lengthInBytes >> 1;
 
   } else {
     // Decode will generate 10 ms of audio data. PlayoutAudioData(..)
     // expects a full frame. If the frame size is larger than 10 ms,
     // PlayoutAudioData(..) data should be called proportionally less often.
     int16_t encodedBuffer[MAX_AUDIO_BUFFER_IN_SAMPLES];
     size_t encodedLengthInBytes = 0;
     if (++_numberOf10MsInDecoder >= _numberOf10MsPerFrame) {
       _numberOf10MsInDecoder = 0;
       size_t bytesFromFile = sizeof(encodedBuffer);
-      if (_fileModule.PlayoutAudioData((int8_t*)encodedBuffer, bytesFromFile) ==
-          -1) {
+      if (_fileModule.PlayoutAudioData(reinterpret_cast<int8_t*>(encodedBuffer),
+                                       bytesFromFile) == -1) {
         // End of file reached.
         return -1;
       }
       encodedLengthInBytes = bytesFromFile;
     }
-    if (_audioDecoder.Decode(unresampledAudioFrame, frequencyInHz,
-                             (int8_t*)encodedBuffer,
+    if (_audioDecoder.Decode(&unresampledAudioFrame, frequencyInHz,
+                             reinterpret_cast<int8_t*>(encodedBuffer),
                              encodedLengthInBytes) == -1) {
       return -1;
     }
   }
 
   size_t outLen = 0;
   if (_resampler.ResetIfNeeded(unresampledAudioFrame.sample_rate_hz_,
                                frequencyInHz, 1)) {
     LOG(LS_WARNING) << "Get10msAudioFromFile() unexpected codec.";
 
     // New sampling frequency. Update state.
     outLen = static_cast<size_t>(frequencyInHz / 100);
     memset(outBuffer, 0, outLen * sizeof(int16_t));
     return 0;
   }
   _resampler.Push(unresampledAudioFrame.data_,
                   unresampledAudioFrame.samples_per_channel_, outBuffer,
                   MAX_AUDIO_BUFFER_IN_SAMPLES, outLen);
 
-  lengthInSamples = outLen;
+  *lengthInSamples = outLen;
 
   if (_scaling != 1.0) {
     for (size_t i = 0; i < outLen; i++) {
       outBuffer[i] = (int16_t)(outBuffer[i] * _scaling);
     }
   }
   _decodedLengthInMS += 10;
   return 0;
 }
 
@@ skipping 71 matching lines @@
     }
     SetAudioScaling(volumeScaling);
   }
   if (SetUpAudioDecoder() == -1) {
     StopPlayingFile();
     return -1;
   }
   return 0;
 }
 
-int32_t FilePlayerImpl::StartPlayingFile(InStream& sourceStream,
+int32_t FilePlayerImpl::StartPlayingFile(InStream* sourceStream,
                                          uint32_t startPosition,
                                          float volumeScaling,
                                          uint32_t notification,
                                          uint32_t stopPosition,
                                          const CodecInst* codecInst) {
   if (_fileFormat == kFileFormatPcm16kHzFile ||
       _fileFormat == kFileFormatPcm32kHzFile ||
       _fileFormat == kFileFormatPcm8kHzFile) {
     CodecInst codecInstL16;
     strncpy(codecInstL16.plname, "L16", 32);
@@ skipping 13 matching lines @@
     } else if (_fileFormat == kFileFormatPcm32kHzFile) {
       codecInstL16.rate = 512000;
       codecInstL16.plfreq = 32000;
       codecInstL16.pacsize = 160;
     } else {
       LOG(LS_ERROR) << "StartPlayingFile() sample frequency not "
                     << "supported for PCM format.";
       return -1;
     }
     if (_fileModule.StartPlayingAudioStream(
-            sourceStream, notification, _fileFormat, &codecInstL16,
+            *sourceStream, notification, _fileFormat, &codecInstL16,
             startPosition, stopPosition) == -1) {
       LOG(LS_ERROR) << "StartPlayingFile() failed to initialize stream "
                     << "playout.";
       return -1;
     }
 
   } else if (_fileFormat == kFileFormatPreencodedFile) {
-    if (_fileModule.StartPlayingAudioStream(sourceStream, notification,
+    if (_fileModule.StartPlayingAudioStream(*sourceStream, notification,
                                             _fileFormat, codecInst) == -1) {
       LOG(LS_ERROR) << "StartPlayingFile() failed to initialize stream "
                     << "playout.";
       return -1;
     }
   } else {
     CodecInst* no_inst = NULL;
-    if (_fileModule.StartPlayingAudioStream(sourceStream, notification,
+    if (_fileModule.StartPlayingAudioStream(*sourceStream, notification,
                                             _fileFormat, no_inst, startPosition,
                                             stopPosition) == -1) {
       LOG(LS_ERROR) << "StartPlayingFile() failed to initialize stream "
                     << "playout.";
       return -1;
     }
   }
   SetAudioScaling(volumeScaling);
 
   if (SetUpAudioDecoder() == -1) {
     StopPlayingFile();
     return -1;
   }
   return 0;
 }
 
 int32_t FilePlayerImpl::StopPlayingFile() {
   memset(&_codec, 0, sizeof(CodecInst));
   _numberOf10MsPerFrame = 0;
   _numberOf10MsInDecoder = 0;
   return _fileModule.StopPlaying();
 }
 
 bool FilePlayerImpl::IsPlayingFile() const {
   return _fileModule.IsPlaying();
 }
 
-int32_t FilePlayerImpl::GetPlayoutPosition(uint32_t& durationMs) {
-  return _fileModule.PlayoutPositionMs(durationMs);
+int32_t FilePlayerImpl::GetPlayoutPosition(uint32_t* durationMs) {
+  return _fileModule.PlayoutPositionMs(*durationMs);
 }
 
 int32_t FilePlayerImpl::SetUpAudioDecoder() {
   if ((_fileModule.codec_info(_codec) == -1)) {
     LOG(LS_WARNING) << "Failed to retrieve codec info of file data.";
     return -1;
   }
   if (STR_CASE_CMP(_codec.plname, "L16") != 0 &&
       _audioDecoder.SetDecodeCodec(_codec) == -1) {
     LOG(LS_WARNING) << "SetUpAudioDecoder() codec " << _codec.plname
@@ skipping 29 matching lines @@
 FilePlayer* FilePlayer::CreateFilePlayer(uint32_t instanceID,
                                          FileFormats fileFormat) {
   return FilePlayer::NewFilePlayer(instanceID, fileFormat).release();
 }
 
 void FilePlayer::DestroyFilePlayer(FilePlayer* player) {
   delete player;
 }
 
 }  // namespace webrtc