Motown: Change media type (stream type) representation

services/media/audio/platform/generic/output_formatter.cc

 // Copyright 2015 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 <limits>
 #include <type_traits>
 
 #include "base/logging.h"
 #include "mojo/services/media/common/cpp/linear_transform.h"
 #include "services/media/audio/platform/generic/output_formatter.h"
@@ skipping 50 matching lines @@
   static inline void Fill(void* dest, size_t samples) {
     ::memset(dest, 0x80, samples * sizeof(DType));
   }
 };
 
 // A templated class which implements the ProduceOutput and FillWithSilence
 // methods of OutputFormatter
 template <typename DType, uint32_t DChCount>
 class OutputFormatterImpl : public OutputFormatter {
  public:
-  explicit OutputFormatterImpl(const LpcmMediaTypeDetailsPtr& format)
+  explicit OutputFormatterImpl(const AudioMediaTypeDetailsPtr& format)
     : OutputFormatter(format, sizeof(DType), DChCount) {}
 
   void ProduceOutput(const int32_t* source,
                      void*          dest_void,
                      uint32_t       frames) const override {
     using DC = DstConverter<DType>;
     DType* dest = static_cast<DType*>(dest_void);
 
     for (size_t i = 0; i < (static_cast<size_t>(frames) * DChCount); ++i) {
       register int32_t val = source[i];
       if (val > std::numeric_limits<int16_t>::max()) {
         dest[i] = DC::Convert(std::numeric_limits<int16_t>::max());
       } else if (val < std::numeric_limits<int16_t>::min()) {
         dest[i] = DC::Convert(std::numeric_limits<int16_t>::min());
       } else {
         dest[i] = DC::Convert(val);
       }
     }
   }
 
   void FillWithSilence(void* dest, uint32_t frames) const override {
     SilenceMaker<DType>::Fill(dest, frames * DChCount);
   }
 };
 
 // Constructor/destructor for the common OutputFormatter base class.
-OutputFormatter::OutputFormatter(const LpcmMediaTypeDetailsPtr& format,
+OutputFormatter::OutputFormatter(const AudioMediaTypeDetailsPtr& format,
                                  uint32_t bytes_per_sample,
                                  uint32_t channels)
   : format_(format.Clone()),
     channels_(channels),
     bytes_per_sample_(bytes_per_sample),
     bytes_per_frame_(bytes_per_sample * channels) {}
 
 OutputFormatter::~OutputFormatter() {}
 
 // Selection routines which will instantiate a particular templatized version of
 // the output formatter.
 template <typename DType>
 static inline OutputFormatterPtr SelectOF(
-    const LpcmMediaTypeDetailsPtr& format) {
+    const AudioMediaTypeDetailsPtr& format) {
   switch (format->channels) {
   case 1:
     return OutputFormatterPtr(new OutputFormatterImpl<DType, 1>(format));
   case 2:
     return OutputFormatterPtr(new OutputFormatterImpl<DType, 2>(format));
   default:
     LOG(ERROR) << "Unsupported output channels "
                << format->channels;
     return nullptr;
   }
 }
 
 OutputFormatterPtr OutputFormatter::Select(
-    const LpcmMediaTypeDetailsPtr& format) {
+    const AudioMediaTypeDetailsPtr& format) {
   DCHECK(format);
 
   switch (format->sample_format) {
-  case LpcmSampleFormat::UNSIGNED_8:
+  case AudioSampleFormat::UNSIGNED_8:
     return SelectOF<uint8_t>(format);
-  case LpcmSampleFormat::SIGNED_16:
+  case AudioSampleFormat::SIGNED_16:
     return SelectOF<int16_t>(format);
   default:
     LOG(ERROR) << "Unsupported output sample format "
                << format->sample_format;
     return nullptr;
   }
 }
 
 }  // namespace audio
 }  // namespace media
 }  // namespace mojo