Replace scoped_ptr with unique_ptr in webrtc/modules/audio_coding/neteq/

webrtc/modules/audio_coding/neteq/tools/neteq_rtpplay.cc

 /*
  *  Copyright (c) 2013 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.
  */
 
 // TODO(hlundin): The functionality in this file should be moved into one or
 // several classes.
 
 #include <assert.h>
 #include <errno.h>
 #include <limits.h>  // For ULONG_MAX returned by strtoul.
 #include <stdio.h>
 #include <stdlib.h>  // For strtoul.
 
 #include <algorithm>
 #include <iostream>
+#include <memory>
 #include <limits>
 #include <string>
 
 #include "gflags/gflags.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/safe_conversions.h"
-#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/modules/audio_coding/codecs/pcm16b/pcm16b.h"
 #include "webrtc/modules/audio_coding/neteq/include/neteq.h"
 #include "webrtc/modules/audio_coding/neteq/tools/input_audio_file.h"
 #include "webrtc/modules/audio_coding/neteq/tools/output_audio_file.h"
 #include "webrtc/modules/audio_coding/neteq/tools/output_wav_file.h"
 #include "webrtc/modules/audio_coding/neteq/tools/packet.h"
 #include "webrtc/modules/audio_coding/neteq/tools/rtc_event_log_source.h"
 #include "webrtc/modules/audio_coding/neteq/tools/rtp_file_source.h"
 #include "webrtc/modules/include/module_common_types.h"
 #include "webrtc/system_wrappers/include/trace.h"
@@ skipping 249 matching lines @@
   if (payload_type == FLAGS_avt || payload_type == FLAGS_red)
     return 0;
   return -1;
 }
 
 int CodecTimestampRate(uint8_t payload_type) {
   return (payload_type == FLAGS_g722) ? 8000 : CodecSampleRate(payload_type);
 }
 
 size_t ReplacePayload(webrtc::test::InputAudioFile* replacement_audio_file,
-                      rtc::scoped_ptr<int16_t[]>* replacement_audio,
-                      rtc::scoped_ptr<uint8_t[]>* payload,
+                      std::unique_ptr<int16_t[]>* replacement_audio,
+                      std::unique_ptr<uint8_t[]>* payload,
                       size_t* payload_mem_size_bytes,
                       size_t* frame_size_samples,
                       WebRtcRTPHeader* rtp_header,
                       const webrtc::test::Packet* next_packet) {
   size_t payload_len = 0;
   // Check for CNG.
   if (IsComfortNoise(rtp_header->header.payloadType)) {
     // If CNG, simply insert a zero-energy one-byte payload.
     if (*payload_mem_size_bytes < 1) {
       (*payload).reset(new uint8_t[1]);
@@ skipping 94 matching lines @@
       return 0;
     }
     // Print usage information.
     std::cout << google::ProgramUsage();
     return 0;
   }
 
   printf("Input file: %s\n", argv[1]);
 
   bool is_rtp_dump = false;
-  rtc::scoped_ptr<webrtc::test::PacketSource> file_source;
+  std::unique_ptr<webrtc::test::PacketSource> file_source;
   webrtc::test::RtcEventLogSource* event_log_source = nullptr;
   if (webrtc::test::RtpFileSource::ValidRtpDump(argv[1]) ||
       webrtc::test::RtpFileSource::ValidPcap(argv[1])) {
     is_rtp_dump = true;
     file_source.reset(webrtc::test::RtpFileSource::Create(argv[1]));
   } else {
     event_log_source = webrtc::test::RtcEventLogSource::Create(argv[1]);
     file_source.reset(event_log_source);
   }
 
   assert(file_source.get());
 
   // Check if an SSRC value was provided.
   if (!FLAGS_ssrc.empty()) {
     uint32_t ssrc;
     RTC_CHECK(ParseSsrc(FLAGS_ssrc, &ssrc)) << "Flag verification has failed.";
     file_source->SelectSsrc(ssrc);
   }
 
   // Check if a replacement audio file was provided, and if so, open it.
   bool replace_payload = false;
-  rtc::scoped_ptr<webrtc::test::InputAudioFile> replacement_audio_file;
+  std::unique_ptr<webrtc::test::InputAudioFile> replacement_audio_file;
   if (!FLAGS_replacement_audio_file.empty()) {
     replacement_audio_file.reset(
         new webrtc::test::InputAudioFile(FLAGS_replacement_audio_file));
     replace_payload = true;
   }
 
   // Read first packet.
-  rtc::scoped_ptr<webrtc::test::Packet> packet(file_source->NextPacket());
+  std::unique_ptr<webrtc::test::Packet> packet(file_source->NextPacket());
   if (!packet) {
     printf(
         "Warning: input file is empty, or the filters did not match any "
         "packets\n");
     webrtc::Trace::ReturnTrace();
     return 0;
   }
   if (packet->payload_length_bytes() == 0 && !replace_payload) {
     std::cerr << "Warning: input file contains header-only packets, but no "
               << "replacement file is specified." << std::endl;
     webrtc::Trace::ReturnTrace();
     return -1;
   }
 
   // Check the sample rate.
   int sample_rate_hz = CodecSampleRate(packet->header().payloadType);
   if (sample_rate_hz <= 0) {
     printf("Warning: Invalid sample rate from RTP packet.\n");
     webrtc::Trace::ReturnTrace();
     return 0;
   }
 
   // Open the output file now that we know the sample rate. (Rate is only needed
   // for wav files.)
   // Check output file type.
   std::string output_file_name = argv[2];
-  rtc::scoped_ptr<webrtc::test::AudioSink> output;
+  std::unique_ptr<webrtc::test::AudioSink> output;
   if (output_file_name.size() >= 4 &&
       output_file_name.substr(output_file_name.size() - 4) == ".wav") {
     // Open a wav file.
     output.reset(
         new webrtc::test::OutputWavFile(output_file_name, sample_rate_hz));
   } else {
     // Open a pcm file.
     output.reset(new webrtc::test::OutputAudioFile(output_file_name));
   }
 
   std::cout << "Output file: " << argv[2] << std::endl;
 
   // Enable tracing.
   webrtc::Trace::CreateTrace();
   webrtc::Trace::SetTraceFile((webrtc::test::OutputPath() +
       "neteq_trace.txt").c_str());
   webrtc::Trace::set_level_filter(webrtc::kTraceAll);
 
   // Initialize NetEq instance.
   NetEq::Config config;
   config.sample_rate_hz = sample_rate_hz;
   NetEq* neteq = NetEq::Create(config);
   RegisterPayloadTypes(neteq);
 
 
   // Set up variables for audio replacement if needed.
-  rtc::scoped_ptr<webrtc::test::Packet> next_packet;
+  std::unique_ptr<webrtc::test::Packet> next_packet;
   bool next_packet_available = false;
   size_t input_frame_size_timestamps = 0;
-  rtc::scoped_ptr<int16_t[]> replacement_audio;
-  rtc::scoped_ptr<uint8_t[]> payload;
+  std::unique_ptr<int16_t[]> replacement_audio;
+  std::unique_ptr<uint8_t[]> payload;
   size_t payload_mem_size_bytes = 0;
   if (replace_payload) {
     // Initially assume that the frame size is 30 ms at the initial sample rate.
     // This value will be replaced with the correct one as soon as two
     // consecutive packets are found.
     input_frame_size_timestamps = 30 * sample_rate_hz / 1000;
     replacement_audio.reset(new int16_t[input_frame_size_timestamps]);
     payload_mem_size_bytes = 2 * input_frame_size_timestamps;
     payload.reset(new uint8_t[payload_mem_size_bytes]);
     next_packet.reset(file_source->NextPacket());
@@ skipping 129 matching lines @@
     }
   }
   printf("Simulation done\n");
   printf("Produced %i ms of audio\n",
          static_cast<int>(time_now_ms - start_time_ms));
 
   delete neteq;
   webrtc::Trace::ReturnTrace();
   return 0;
 }