[Chromecast] Remove command-line switch to change the number of mixer output channels

chromecast/media/cma/decoder/cast_audio_decoder_linux.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 "chromecast/media/cma/decoder/cast_audio_decoder.h"
 
 #include <stdint.h>
 #include <limits>
 #include <queue>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
-#include "base/command_line.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/single_thread_task_runner.h"
-#include "base/strings/string_number_conversions.h"
-#include "chromecast/base/chromecast_switches.h"
 #include "chromecast/media/cma/base/decoder_buffer_adapter.h"
 #include "chromecast/media/cma/base/decoder_buffer_base.h"
 #include "chromecast/media/cma/base/decoder_config_adapter.h"
 #include "media/base/audio_buffer.h"
 #include "media/base/audio_bus.h"
 #include "media/base/cdm_context.h"
 #include "media/base/channel_layout.h"
 #include "media/base/channel_mixer.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/sample_format.h"
@@ skipping 12 matching lines @@
   2,  // offset 9, channels
   0, 0,  // offset 10, skip
   static_cast<uint8_t>(kOpusSamplingRate & 0xFF),  // offset 12, LE
   static_cast<uint8_t>((kOpusSamplingRate >> 8) & 0xFF),
   static_cast<uint8_t>((kOpusSamplingRate >> 16) & 0xFF),
   static_cast<uint8_t>((kOpusSamplingRate >> 24) & 0xFF),
   0, 0,  // offset 16, gain
   0,  // offset 18, stereo mapping
 };
 
-const int kStereoOutputChannelCount = 2;
-const int kLayout71OutputChannelCount = 8;
+const int kOutputChannelCount = 2;  // Always output stereo audio.
 const int kMaxChannelInput = 2;
 
 class CastAudioDecoderImpl : public CastAudioDecoder {
  public:
   CastAudioDecoderImpl(
       const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
       const InitializedCallback& initialized_callback,
       OutputFormat output_format)
       : task_runner_(task_runner),
         initialized_callback_(initialized_callback),
         output_format_(output_format),
         initialized_(false),
         decode_pending_(false),
-        weak_factory_(this) {
-    if (base::CommandLine::InitializedForCurrentProcess() &&
-        base::CommandLine::ForCurrentProcess()->HasSwitch(
-            switches::kAlsaNumOutputChannels)) {
-      base::StringToInt(
-          base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
-              switches::kAlsaNumOutputChannels),
-          &num_output_channels_);
-    } else {
-      num_output_channels_ = kStereoOutputChannelCount;
-    }
-    DCHECK(num_output_channels_ == kStereoOutputChannelCount ||
-           num_output_channels_ == kLayout71OutputChannelCount);
-  }
+        weak_factory_(this) {}
 
   ~CastAudioDecoderImpl() override {}
 
   void Initialize(const media::AudioConfig& config) {
     DCHECK(!initialized_);
     DCHECK_LE(config_.channel_number, kMaxChannelInput);
     config_ = config;
-
     if (config_.channel_number == 1) {
       // If the input is mono, create a ChannelMixer to convert mono to stereo.
       // TODO(kmackay) Support other channel format conversions?
       mixer_.reset(new ::media::ChannelMixer(::media::CHANNEL_LAYOUT_MONO,
                                              ::media::CHANNEL_LAYOUT_STEREO));
     }
-    if (num_output_channels_ == kLayout71OutputChannelCount) {
-      // If there are 8 output channel, create a Channel Mixer to convert
-      // stereo to CHANNEL_LAYOUT_7_1.
-      // TODO(tianyuwang): This is a hack for 8 channel test USB speaker.
-      // Channel mixer from MONO TO LAYOUT 7_1 doesn't work with the current
-      // test USB speaker. As a result, we need to convert MONO channel
-      // to STEREO first then convert it to LAYOUT_7_1.
-      mixer_7_1_.reset(new ::media::ChannelMixer(::media::CHANNEL_LAYOUT_STEREO,
-                                                 ::media::CHANNEL_LAYOUT_7_1));
-    }
-
     base::WeakPtr<CastAudioDecoderImpl> self = weak_factory_.GetWeakPtr();
     if (config.codec == media::kCodecOpus) {
       // Insert fake extradata to make OpusAudioDecoder work with v2mirroring.
       if (config_.extra_data.empty() &&
           config_.samples_per_second == kOpusSamplingRate &&
           config_.channel_number == 2)
         config_.extra_data.assign(
             kFakeOpusExtraData,
             kFakeOpusExtraData + sizeof(kFakeOpusExtraData));
       decoder_.reset(new ::media::OpusAudioDecoder(task_runner_));
@@ skipping 116 matching lines @@
     int bus_frame_offset = 0;
     for (auto& chunk : decoded_chunks_) {
       chunk->ReadFrames(chunk->frame_count(), 0, bus_frame_offset,
                         decoded.get());
       bus_frame_offset += chunk->frame_count();
     }
 
     if (mixer_) {
       // Convert to stereo if necessary.
       std::unique_ptr<::media::AudioBus> converted_to_stereo =
-          ::media::AudioBus::Create(kStereoOutputChannelCount, num_frames);
+          ::media::AudioBus::Create(kOutputChannelCount, num_frames);
       mixer_->Transform(decoded.get(), converted_to_stereo.get());
       decoded.swap(converted_to_stereo);
     }
 
-    // TODO(tianyuwang): Remove this hack for 7_1 USB test speaker.
-    if (mixer_7_1_) {
-      // Convert to layout 7_1 if necessary.
-      std::unique_ptr<::media::AudioBus> converted_to_7_1 =
-          ::media::AudioBus::Create(num_output_channels_, num_frames);
-      mixer_7_1_->Transform(decoded.get(), converted_to_7_1.get());
-      decoded.swap(converted_to_7_1);
-    }
-
     // Convert to the desired output format.
     return FinishConversion(decoded.get());
   }
 
   scoped_refptr<media::DecoderBufferBase> FinishConversion(
       ::media::AudioBus* bus) {
-    DCHECK_EQ(num_output_channels_, bus->channels());
-    int size = bus->frames() * num_output_channels_ *
+    DCHECK_EQ(kOutputChannelCount, bus->channels());
+    int size = bus->frames() * kOutputChannelCount *
                OutputFormatSizeInBytes(output_format_);
     scoped_refptr<::media::DecoderBuffer> result(
         new ::media::DecoderBuffer(size));
 
     if (output_format_ == kOutputSigned16) {
       bus->ToInterleaved(bus->frames(), OutputFormatSizeInBytes(output_format_),
                          result->writable_data());
     } else if (output_format_ == kOutputPlanarFloat) {
       // Data in an AudioBus is already in planar float format; just copy each
       // channel into the result buffer in order.
@@ skipping 13 matching lines @@
         new media::DecoderBufferAdapter(config_.id, result));
   }
 
   const scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
   InitializedCallback initialized_callback_;
   OutputFormat output_format_;
   media::AudioConfig config_;
   std::unique_ptr<::media::AudioDecoder> decoder_;
   std::queue<DecodeBufferCallbackPair> decode_queue_;
   bool initialized_;
-  int num_output_channels_;
   std::unique_ptr<::media::ChannelMixer> mixer_;
-  std::unique_ptr<::media::ChannelMixer> mixer_7_1_;
   bool decode_pending_;
   std::vector<scoped_refptr<::media::AudioBuffer>> decoded_chunks_;
   base::WeakPtrFactory<CastAudioDecoderImpl> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(CastAudioDecoderImpl);
 };
 
 }  // namespace
 
 // static
@@ skipping 16 matching lines @@
       return 2;
     case CastAudioDecoder::OutputFormat::kOutputPlanarFloat:
       return 4;
   }
   NOTREACHED();
   return 1;
 }
 
 }  // namespace media
 }  // namespace chromecast