Mojom updates for Motown.

services/media/audio/audio_track_impl.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 <algorithm>
 #include <limits>
 
 #include "base/logging.h"
 #include "mojo/services/media/common/cpp/linear_transform.h"
 #include "services/media/audio/audio_output_manager.h"
 #include "services/media/audio/audio_server_impl.h"
 #include "services/media/audio/audio_track_impl.h"
 #include "services/media/audio/audio_track_to_output_link.h"
 
 namespace mojo {
 namespace media {
 namespace audio {
 
 constexpr size_t AudioTrackImpl::PTS_FRACTIONAL_BITS;
 
 // TODO(johngro): If there is ever a better way to do this type of static-table
 // initialization using mojom generated structs, we should switch to it.
 static const struct {
   LpcmSampleFormat sample_format;
-  uint8_t min_samples_per_frame;
-  uint8_t max_samples_per_frame;
+  BoolRange interleaved;
+  uint8_t min_channels;
+  uint8_t max_channels;
   uint32_t min_frames_per_second;
   uint32_t max_frames_per_second;
 } kSupportedLpcmTypeSets[] = {
   {
     .sample_format = LpcmSampleFormat::UNSIGNED_8,
-    .min_samples_per_frame = 1,
-    .max_samples_per_frame = 2,
+    .interleaved           = BoolRange::TRUE,
+    .min_channels          = 1,
+    .max_channels          = 2,
     .min_frames_per_second = 1000,
     .max_frames_per_second = 48000,
   },
   {
     .sample_format = LpcmSampleFormat::SIGNED_16,
-    .min_samples_per_frame = 1,
-    .max_samples_per_frame = 2,
+    .interleaved           = BoolRange::TRUE,
+    .min_channels          = 1,
+    .max_channels          = 2,
     .min_frames_per_second = 1000,
     .max_frames_per_second = 48000,
   },
 };
 
 AudioTrackImpl::AudioTrackImpl(InterfaceRequest<AudioTrack> iface,
                              AudioServerImpl* owner)
   : owner_(owner),
     binding_(this),
     pipe_(this, owner) {
@@ skipping 33 matching lines @@
     const MediaTypeSetPtr& mts =
       (desc->supported_media_types[i] = MediaTypeSet::New());
 
     mts->scheme  = MediaTypeScheme::LPCM;
     mts->details = MediaTypeSetDetails::New();
 
     const auto& s = kSupportedLpcmTypeSets[i];
     LpcmMediaTypeSetDetailsPtr lpcm_detail = LpcmMediaTypeSetDetails::New();
 
     lpcm_detail->sample_format         = s.sample_format;
-    lpcm_detail->min_samples_per_frame = s.min_samples_per_frame;
-    lpcm_detail->max_samples_per_frame = s.max_samples_per_frame;
+    lpcm_detail->interleaved           = s.interleaved;
+    lpcm_detail->min_channels          = s.min_channels;
+    lpcm_detail->max_channels          = s.max_channels;
     lpcm_detail->min_frames_per_second = s.min_frames_per_second;
     lpcm_detail->max_frames_per_second = s.max_frames_per_second;
     mts->details->set_lpcm(lpcm_detail.Pass());
   }
 
   cbk.Run(desc.Pass());
 }
 
 void AudioTrackImpl::Configure(AudioTrackConfigurationPtr configuration,
                               InterfaceRequest<MediaPipe> req,
@@ skipping 12 matching lines @@
   }
 
   // Search our supported configuration sets to find one compatible with this
   // request.
   auto& cfg = configuration->media_type->details->get_lpcm();
   size_t i;
   for (i = 0; i < arraysize(kSupportedLpcmTypeSets); ++i) {
     const auto& cfg_set = kSupportedLpcmTypeSets[i];
 
     if ((cfg->sample_format == cfg_set.sample_format) &&
-        (cfg->samples_per_frame >= cfg_set.min_samples_per_frame) &&
-        (cfg->samples_per_frame <= cfg_set.max_samples_per_frame) &&
+        (cfg_set.interleaved == BoolRange::EITHER ||
+            cfg->interleaved == (cfg_set.interleaved == BoolRange::TRUE)) &&
+        (cfg->channels >= cfg_set.min_channels) &&
+        (cfg->channels <= cfg_set.max_channels) &&
         (cfg->frames_per_second >= cfg_set.min_frames_per_second) &&
         (cfg->frames_per_second <= cfg_set.max_frames_per_second)) {
       break;
     }
   }
 
   if (i >= arraysize(kSupportedLpcmTypeSets)) {
     cbk.Run(MediaResult::UNSUPPORTED_CONFIG);
     return;
   }
@@ skipping 33 matching lines @@
 
     case LpcmSampleFormat::SIGNED_24_IN_32:
       bytes_per_frame_ = 4;
       break;
 
     default:
       DCHECK(false);
       bytes_per_frame_ = 2;
       break;
   }
-  bytes_per_frame_ *= cfg->samples_per_frame;
+  bytes_per_frame_ *= cfg->channels;
 
   // Overflow trying to convert from frames to bytes?
   uint64_t requested_frames = configuration->max_frames;
   if (requested_frames >
      (std::numeric_limits<size_t>::max() / bytes_per_frame_)) {
     cbk.Run(MediaResult::INSUFFICIENT_RESOURCES);
     return;
   }
 
   size_t requested_bytes = (requested_frames * bytes_per_frame_);
@@ skipping 71 matching lines @@
   for (const auto& output : outputs_) {
     DCHECK(output);
     output->FlushPendingQueue();
   }
   cbk.Run(MediaResult::OK);
 }
 
 }  // namespace audio
 }  // namespace media
 }  // namespace mojo