Support Opus Ambisonics playback

media/filters/ffmpeg_audio_decoder.cc

 // Copyright (c) 2012 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/filters/ffmpeg_audio_decoder.h"
 
 #include <stdint.h>
 
 #include "base/callback_helpers.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 66 matching lines @@
     DLOG(ERROR) << "AVCodecContext and AVFrame disagree on channel count.";
     return AVERROR(EINVAL);
   }
 
   if (s->sample_rate != frame->sample_rate) {
     DLOG(ERROR) << "AVCodecContext and AVFrame disagree on sample rate."
                 << s->sample_rate << " vs " << frame->sample_rate;
     return AVERROR(EINVAL);
   }
 
+  // Use CHANNEL_LAYOUT_DISCRETE for Opus Ambisonics signals
+  int is_opus_ambisonics = 0;

[DaleCurtis, 2017/03/20 17:38:58]

bool.

[flim-chromium, 2017/03/22 06:20:51]

Done.

+  if (s->codec_id == AV_CODEC_ID_OPUS && s->extradata_size >= 19) {
+    int mapping_family = s->extradata[18];
+    is_opus_ambisonics = mapping_family == 2;
+  }
+  ChannelLayout channel_layout = is_opus_ambisonics

[DaleCurtis, 2017/03/20 17:38:58]

&& channels > 8.

[flim-chromium, 2017/03/22 06:20:51]

Ambisonics signals could also be < 8 channels. Or do you mean even if it's not
opus ambisonics signal?

[DaleCurtis, 2017/03/22 18:56:30]

I mean I don't think DISCRETE will be passed or work correctly all through out
the stack if < 8 channels; specifically OSX may have troubles. You'll need to do
some further research at all the places we convert from channel count to layout
and use DISCRETE today.

[flim-chromium, 2017/03/29 03:15:25]

Thanks for the explanation. I've added '&& channels > 8'.

+                                 ? CHANNEL_LAYOUT_DISCRETE
+                                 : ChannelLayoutToChromeChannelLayout(
+                                       s->channel_layout,
+                                       s->channels);
+
   // Determine how big the buffer should be and allocate it. FFmpeg may adjust
   // how big each channel data is in order to meet the alignment policy, so
   // we need to take this into consideration.
   int buffer_size_in_bytes = av_samples_get_buffer_size(
       &frame->linesize[0], channels, frame->nb_samples, format,
       0 /* align, use ffmpeg default */);
   // Check for errors from av_samples_get_buffer_size().
   if (buffer_size_in_bytes < 0)
     return buffer_size_in_bytes;
   int frames_required = buffer_size_in_bytes / bytes_per_channel / channels;
   DCHECK_GE(frames_required, frame->nb_samples);
   scoped_refptr<AudioBuffer> buffer = AudioBuffer::CreateBuffer(
       sample_format,
-      ChannelLayoutToChromeChannelLayout(s->channel_layout, s->channels),
+      channel_layout,
       channels,
       s->sample_rate,
       frames_required);
 
   // Initialize the data[] and extended_data[] fields to point into the memory
   // allocated for AudioBuffer. |number_of_planes| will be 1 for interleaved
   // audio and equal to |channels| for planar audio.
   int number_of_planes = buffer->channel_data().size();
   if (number_of_planes <= AV_NUM_DATA_POINTERS) {
     DCHECK_EQ(frame->extended_data, frame->data);
@@ skipping 183 matching lines @@
     bool config_changed = false;
     if (frame_decoded) {
       const int channels = DetermineChannels(av_frame_.get());
       ChannelLayout channel_layout = ChannelLayoutToChromeChannelLayout(
           codec_context_->channel_layout, codec_context_->channels);
 
       bool is_sample_rate_change =
           av_frame_->sample_rate != config_.samples_per_second();
       bool is_config_stale =
           is_sample_rate_change ||
-          channels != ChannelLayoutToChannelCount(config_.channel_layout()) ||
+          channels != config_.channels() ||
           av_frame_->format != av_sample_format_;
 
       // Only consider channel layout changes for AAC.
       // TODO(tguilbert, dalecurtis): Due to http://crbug.com/600538 we need to
       // allow channel layout changes for the moment. See if ffmpeg is fixable.
       if (config_.codec() == kCodecAAC)
         is_config_stale |= channel_layout != config_.channel_layout();
 
       if (is_config_stale) {
         // Only allow midstream configuration changes for AAC. Sample format is
         // not expected to change between AAC profiles.
         if (config_.codec() == kCodecAAC &&
             av_frame_->format == av_sample_format_) {
           MEDIA_LOG(DEBUG, media_log_)
               << " Detected AAC midstream configuration change"
               << " PTS:" << buffer->timestamp().InMicroseconds()
               << " Sample Rate: " << av_frame_->sample_rate << " vs "
               << config_.samples_per_second()
               << ", ChannelLayout: " << channel_layout << " vs "
               << config_.channel_layout() << ", Channels: " << channels
               << " vs "
-              << ChannelLayoutToChannelCount(config_.channel_layout());
+              << config_.channels();
           config_.Initialize(config_.codec(), config_.sample_format(),
                              channel_layout, av_frame_->sample_rate,
                              config_.extra_data(), config_.encryption_scheme(),
                              config_.seek_preroll(), config_.codec_delay());
           config_changed = true;
           if (is_sample_rate_change)
             ResetTimestampState();
         } else {
           MEDIA_LOG(ERROR, media_log_)
               << "Unsupported midstream configuration change!"
               << " Sample Rate: " << av_frame_->sample_rate << " vs "
               << config_.samples_per_second() << ", Channels: " << channels
-              << " vs " << ChannelLayoutToChannelCount(config_.channel_layout())
+              << " vs " << config_.channels()
               << ", Sample Format: " << av_frame_->format << " vs "
               << av_sample_format_;
           // This is an unrecoverable error, so bail out.
           av_frame_unref(av_frame_.get());
           return false;
         }
       }
 
       // Get the AudioBuffer that the data was decoded into. Adjust the number
       // of frames, in case fewer than requested were actually decoded.
       output = reinterpret_cast<AudioBuffer*>(
           av_buffer_get_opaque(av_frame_->buf[0]));
 
-      DCHECK_EQ(ChannelLayoutToChannelCount(config_.channel_layout()),
-                output->channel_count());
+      DCHECK_EQ(config_.channels(), output->channel_count());
       const int unread_frames = output->frame_count() - av_frame_->nb_samples;
       DCHECK_GE(unread_frames, 0);
       if (unread_frames > 0)
         output->TrimEnd(unread_frames);
       av_frame_unref(av_frame_.get());
     }
 
     // WARNING: |av_frame_| no longer has valid data at this point.
     const int decoded_frames = frame_decoded ? output->frame_count() : 0;
     if (IsEndOfStream(result, decoded_frames, buffer)) {
@@ skipping 44 matching lines @@
                 << codec_context_->codec_id;
     ReleaseFFmpegResources();
     state_ = kUninitialized;
     return false;
   }
 
   // Success!
   av_frame_.reset(av_frame_alloc());
   av_sample_format_ = codec_context_->sample_fmt;
 
-  if (codec_context_->channels !=
-      ChannelLayoutToChannelCount(config_.channel_layout())) {
+
+  if (codec_context_->channels != config_.channels()) {
     DLOG(ERROR) << "Audio configuration specified "
-                << ChannelLayoutToChannelCount(config_.channel_layout())
+                << config_.channels()
                 << " channels, but FFmpeg thinks the file contains "
                 << codec_context_->channels << " channels";
     ReleaseFFmpegResources();
     state_ = kUninitialized;
     return false;
   }
 
   ResetTimestampState();
   return true;
 }
 
 void FFmpegAudioDecoder::ResetTimestampState() {
   // Opus codec delay is handled by ffmpeg.
   const int codec_delay =
       config_.codec() == kCodecOpus ? 0 : config_.codec_delay();
   discard_helper_.reset(
       new AudioDiscardHelper(config_.samples_per_second(), codec_delay,
                              config_.codec() == kCodecVorbis));
   discard_helper_->Reset(codec_delay);
 }
 
 }  // namespace media