Cast: Added support for AES-CTR crypto.

media/cast/audio_sender/audio_encoder.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/cast/audio_sender/audio_encoder.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 76 matching lines @@
         buffer_fill_end_ = 0;
       }
     }
   }
 
  protected:
   virtual void TransferSamplesIntoBuffer(const AudioBus* audio_bus,
                                          int source_offset,
                                          int buffer_fill_offset,
                                          int num_samples) = 0;
-  virtual bool EncodeFromFilledBuffer(std::vector<uint8>* out) = 0;
+  virtual bool EncodeFromFilledBuffer(std::string* out) = 0;
 
   CastEnvironment* const cast_environment_;
   const AudioCodec codec_;
   const int num_channels_;
   const int samples_per_10ms_;
   const FrameEncodedCallback callback_;
 
  private:
   // In the case where a call to EncodeAudio() cannot completely fill the
   // buffer, this points to the position at which to populate data in a later
@@ skipping 41 matching lines @@
     // Opus requires channel-interleaved samples in a single array.
     for (int ch = 0; ch < audio_bus->channels(); ++ch) {
       const float* src = audio_bus->channel(ch) + source_offset;
       const float* const src_end = src + num_samples;
       float* dest = buffer_.get() + buffer_fill_offset * num_channels_ + ch;
       for (; src < src_end; ++src, dest += num_channels_)
         *dest = *src;
     }
   }
 
-  virtual bool EncodeFromFilledBuffer(std::vector<uint8>* out) OVERRIDE {
+  virtual bool EncodeFromFilledBuffer(std::string* out) OVERRIDE {
     out->resize(kOpusMaxPayloadSize);
     const opus_int32 result = opus_encode_float(
-        opus_encoder_, buffer_.get(), samples_per_10ms_, &out->front(),
-        kOpusMaxPayloadSize);
+        opus_encoder_, buffer_.get(), samples_per_10ms_,
+        reinterpret_cast<uint8*>(&out->at(0)), kOpusMaxPayloadSize);
     if (result > 1) {
       out->resize(result);
       return true;
     } else if (result < 0) {
       LOG(ERROR) << "Error code from opus_encode_float(): " << result;
       return false;
     } else {
       // Do nothing: The documentation says that a return value of zero or
       // one byte means the packet does not need to be transmitted.
       return false;
@@ skipping 29 matching lines @@
  private:
   virtual void TransferSamplesIntoBuffer(const AudioBus* audio_bus,
                                          int source_offset,
                                          int buffer_fill_offset,
                                          int num_samples) OVERRIDE {
     audio_bus->ToInterleavedPartial(
         source_offset, num_samples, sizeof(int16),
         buffer_.get() + buffer_fill_offset * num_channels_);
   }
 
-  virtual bool EncodeFromFilledBuffer(std::vector<uint8>* out) OVERRIDE {
+  virtual bool EncodeFromFilledBuffer(std::string* out) OVERRIDE {
     // Output 16-bit PCM integers in big-endian byte order.
     out->resize(num_channels_ * samples_per_10ms_ * sizeof(int16));
     const int16* src = buffer_.get();
     const int16* const src_end = src + num_channels_ * samples_per_10ms_;
-    uint16* dest = reinterpret_cast<uint16*>(&out->front());
+    uint16* dest = reinterpret_cast<uint16*>(&out->at(0));
     for (; src < src_end; ++src, ++dest)
       *dest = base::HostToNet16(*src);
     return true;
   }
 
  private:
   const scoped_ptr<int16[]> buffer_;
 
   DISALLOW_COPY_AND_ASSIGN(Pcm16Impl);
 };
@@ skipping 45 matching lines @@
 void AudioEncoder::EncodeAudio(
     const AudioBus* audio_bus,
     const base::TimeTicks& recorded_time,
     const base::Closure& done_callback) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::AUDIO_ENCODER));
   impl_->EncodeAudio(audio_bus, recorded_time, done_callback);
 }
 
 }  // namespace cast
 }  // namespace media