Relocate last remnants of webkit/renderer/media code.

media/cdm/ppapi/ffmpeg_cdm_audio_decoder.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 "webkit/renderer/media/crypto/ppapi/ffmpeg_cdm_audio_decoder.h"
+#include "media/cdm/ppapi/ffmpeg_cdm_audio_decoder.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "media/base/audio_bus.h"
 #include "media/base/audio_timestamp_helper.h"
 #include "media/base/buffers.h"
 #include "media/base/data_buffer.h"
 #include "media/base/limits.h"
-#include "webkit/renderer/media/crypto/ppapi/cdm/content_decryption_module.h"
 
 // Include FFmpeg header files.
 extern "C" {
 // Temporarily disable possible loss of data warning.
 MSVC_PUSH_DISABLE_WARNING(4244);
 #include <libavcodec/avcodec.h>
 MSVC_POP_WARNING();
 }  // extern "C"
 
-namespace webkit_media {
+namespace media {
 
 // Maximum number of channels with defined layout in src/media.
 static const int kMaxChannels = 8;
 
 static AVCodecID CdmAudioCodecToCodecID(
     cdm::AudioDecoderConfig::AudioCodec audio_codec) {
   switch (audio_codec) {
     case cdm::AudioDecoderConfig::kCodecVorbis:
       return AV_CODEC_ID_VORBIS;
     case cdm::AudioDecoderConfig::kCodecAac:
@@ skipping 47 matching lines @@
 FFmpegCdmAudioDecoder::FFmpegCdmAudioDecoder(cdm::Host* host)
     : is_initialized_(false),
       host_(host),
       codec_context_(NULL),
       av_frame_(NULL),
       bits_per_channel_(0),
       samples_per_second_(0),
       channels_(0),
       av_sample_format_(0),
       bytes_per_frame_(0),
-      last_input_timestamp_(media::kNoTimestamp()),
+      last_input_timestamp_(kNoTimestamp()),
       output_bytes_to_drop_(0) {
 }
 
 FFmpegCdmAudioDecoder::~FFmpegCdmAudioDecoder() {
   ReleaseFFmpegResources();
 }
 
 bool FFmpegCdmAudioDecoder::Initialize(const cdm::AudioDecoderConfig& config) {
   DVLOG(1) << "Initialize()";
 
@@ skipping 32 matching lines @@
   // Some codecs will only output float data, so we need to convert to integer
   // before returning the decoded buffer.
   if (codec_context_->sample_fmt == AV_SAMPLE_FMT_FLTP ||
       codec_context_->sample_fmt == AV_SAMPLE_FMT_FLT) {
     // Preallocate the AudioBus for float conversions.  We can treat interleaved
     // float data as a single planar channel since our output is expected in an
     // interleaved format anyways.
     int channels = codec_context_->channels;
     if (codec_context_->sample_fmt == AV_SAMPLE_FMT_FLT)
       channels = 1;
-    converter_bus_ = media::AudioBus::CreateWrapper(channels);
+    converter_bus_ = AudioBus::CreateWrapper(channels);
   }
 
   // Success!
   av_frame_ = avcodec_alloc_frame();
   bits_per_channel_ = config.bits_per_channel;
   samples_per_second_ = config.samples_per_second;
   bytes_per_frame_ = codec_context_->channels * bits_per_channel_ / 8;
   output_timestamp_helper_.reset(
-      new media::AudioTimestampHelper(config.samples_per_second));
+      new AudioTimestampHelper(config.samples_per_second));
   serialized_audio_frames_.reserve(bytes_per_frame_ * samples_per_second_);
   is_initialized_ = true;
 
   // Store initial values to guard against midstream configuration changes.
   channels_ = codec_context_->channels;
   av_sample_format_ = codec_context_->sample_fmt;
 
   return true;
 }
 
@@ skipping 10 matching lines @@
   ResetTimestampState();
 }
 
 // static
 bool FFmpegCdmAudioDecoder::IsValidConfig(
     const cdm::AudioDecoderConfig& config) {
   return config.codec != cdm::AudioDecoderConfig::kUnknownAudioCodec &&
          config.channel_count > 0 &&
          config.channel_count <= kMaxChannels &&
          config.bits_per_channel > 0 &&
-         config.bits_per_channel <= media::limits::kMaxBitsPerSample &&
+         config.bits_per_channel <= limits::kMaxBitsPerSample &&
          config.samples_per_second > 0 &&
-         config.samples_per_second <= media::limits::kMaxSampleRate;
+         config.samples_per_second <= limits::kMaxSampleRate;
 }
 
 cdm::Status FFmpegCdmAudioDecoder::DecodeBuffer(
     const uint8_t* compressed_buffer,
     int32_t compressed_buffer_size,
     int64_t input_timestamp,
     cdm::AudioFrames* decoded_frames) {
   DVLOG(1) << "DecodeBuffer()";
   const bool is_end_of_stream = !compressed_buffer;
   base::TimeDelta timestamp =
       base::TimeDelta::FromMicroseconds(input_timestamp);
 
   bool is_vorbis = codec_context_->codec_id == AV_CODEC_ID_VORBIS;
   if (!is_end_of_stream) {
-    if (last_input_timestamp_ == media::kNoTimestamp()) {
+    if (last_input_timestamp_ == kNoTimestamp()) {
       if (is_vorbis && timestamp < base::TimeDelta()) {
         // Dropping frames for negative timestamps as outlined in section A.2
         // in the Vorbis spec. http://xiph.org/vorbis/doc/Vorbis_I_spec.html
         int frames_to_drop = floor(
             0.5 + -timestamp.InSecondsF() * samples_per_second_);
         output_bytes_to_drop_ = bytes_per_frame_ * frames_to_drop;
       } else {
         last_input_timestamp_ = timestamp;
       }
-    } else if (timestamp != media::kNoTimestamp()) {
+    } else if (timestamp != kNoTimestamp()) {
       if (timestamp < last_input_timestamp_) {
         base::TimeDelta diff = timestamp - last_input_timestamp_;
         DVLOG(1) << "Input timestamps are not monotonically increasing! "
                  << " ts " << timestamp.InMicroseconds() << " us"
                  << " diff " << diff.InMicroseconds() << " us";
         return cdm::kDecodeError;
       }
 
       last_input_timestamp_ = timestamp;
     }
@@ skipping 29 matching lines @@
           << compressed_buffer_size << " bytes";
 
       return cdm::kDecodeError;
     }
 
     // Update packet size and data pointer in case we need to call the decoder
     // with the remaining bytes from this packet.
     packet.size -= result;
     packet.data += result;
 
-    if (output_timestamp_helper_->base_timestamp() == media::kNoTimestamp() &&
+    if (output_timestamp_helper_->base_timestamp() == kNoTimestamp() &&
         !is_end_of_stream) {
-      DCHECK(timestamp != media::kNoTimestamp());
+      DCHECK(timestamp != kNoTimestamp());
       if (output_bytes_to_drop_ > 0) {
         // Currently Vorbis is the only codec that causes us to drop samples.
         // If we have to drop samples it always means the timeline starts at 0.
         DCHECK_EQ(codec_context_->codec_id, AV_CODEC_ID_VORBIS);
         output_timestamp_helper_->SetBaseTimestamp(base::TimeDelta());
       } else {
         output_timestamp_helper_->SetBaseTimestamp(timestamp);
       }
     }
 
@@ skipping 28 matching lines @@
     if (decoded_audio_size > 0 && output_bytes_to_drop_ > 0) {
       DCHECK_EQ(decoded_audio_size % bytes_per_frame_, 0)
           << "Decoder didn't output full frames";
 
       int dropped_size = std::min(decoded_audio_size, output_bytes_to_drop_);
       start_sample = dropped_size / bytes_per_frame_;
       decoded_audio_size -= dropped_size;
       output_bytes_to_drop_ -= dropped_size;
     }
 
-    scoped_refptr<media::DataBuffer> output;
+    scoped_refptr<DataBuffer> output;
     if (decoded_audio_size > 0) {
       DCHECK_EQ(decoded_audio_size % bytes_per_frame_, 0)
           << "Decoder didn't output full frames";
 
       // Convert float data using an AudioBus.
       if (converter_bus_) {
         // Setup the AudioBus as a wrapper of the AVFrame data and then use
         // AudioBus::ToInterleaved() to convert the data as necessary.
         int skip_frames = start_sample;
         int total_frames = av_frame_->nb_samples;
         int frames_to_interleave = decoded_audio_size / bytes_per_frame_;
         if (codec_context_->sample_fmt == AV_SAMPLE_FMT_FLT) {
           DCHECK_EQ(converter_bus_->channels(), 1);
           total_frames *= codec_context_->channels;
           skip_frames *= codec_context_->channels;
           frames_to_interleave *= codec_context_->channels;
         }
 
         converter_bus_->set_frames(total_frames);
         for (int i = 0; i < converter_bus_->channels(); ++i) {
           converter_bus_->SetChannelData(i, reinterpret_cast<float*>(
               av_frame_->extended_data[i]));
         }
 
-        output = new media::DataBuffer(decoded_audio_size);
+        output = new DataBuffer(decoded_audio_size);
         output->set_data_size(decoded_audio_size);
 
         DCHECK_EQ(frames_to_interleave, converter_bus_->frames() - skip_frames);
         converter_bus_->ToInterleavedPartial(
             skip_frames, frames_to_interleave, bits_per_channel_ / 8,
             output->writable_data());
       } else {
-        output = media::DataBuffer::CopyFrom(
+        output = DataBuffer::CopyFrom(
             av_frame_->extended_data[0] + start_sample * bytes_per_frame_,
             decoded_audio_size);
       }
 
       base::TimeDelta output_timestamp =
           output_timestamp_helper_->GetTimestamp();
       output_timestamp_helper_->AddFrames(decoded_audio_size /
                                           bytes_per_frame_);
 
       // Serialize the audio samples into |serialized_audio_frames_|.
@@ skipping 19 matching lines @@
     decoded_frames->FrameBuffer()->SetSize(serialized_audio_frames_.size());
     serialized_audio_frames_.clear();
 
     return cdm::kSuccess;
   }
 
   return cdm::kNeedMoreData;
 }
 
 void FFmpegCdmAudioDecoder::ResetTimestampState() {
-  output_timestamp_helper_->SetBaseTimestamp(media::kNoTimestamp());
-  last_input_timestamp_ = media::kNoTimestamp();
+  output_timestamp_helper_->SetBaseTimestamp(kNoTimestamp());
+  last_input_timestamp_ = kNoTimestamp();
   output_bytes_to_drop_ = 0;
 }
 
 void FFmpegCdmAudioDecoder::ReleaseFFmpegResources() {
   DVLOG(1) << "ReleaseFFmpegResources()";
 
   if (codec_context_) {
     av_free(codec_context_->extradata);
     avcodec_close(codec_context_);
     av_free(codec_context_);
     codec_context_ = NULL;
   }
   if (av_frame_) {
     av_free(av_frame_);
     av_frame_ = NULL;
   }
 }
 
 void FFmpegCdmAudioDecoder::SerializeInt64(int64 value) {
   int previous_size = serialized_audio_frames_.size();
   serialized_audio_frames_.resize(previous_size + sizeof(value));
   memcpy(&serialized_audio_frames_[0] + previous_size, &value, sizeof(value));
 }
 
-}  // namespace webkit_media
+}  // namespace media