Check buffer index in shared memory for input audio.

media/audio/audio_input_device.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/audio/audio_input_device.h"
 
 #include "base/bind.h"
 #include "base/memory/scoped_vector.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/time/time.h"
@@ skipping 21 matching lines @@
                       CaptureCallback* capture_callback);
   ~AudioThreadCallback() override;
 
   void MapSharedMemory() override;
 
   // Called whenever we receive notifications about pending data.
   void Process(uint32 pending_data) override;
 
  private:
   int current_segment_id_;
+  uint32 last_buffer_id_;
   ScopedVector<media::AudioBus> audio_buses_;
   CaptureCallback* capture_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(AudioThreadCallback);
 };
 
 AudioInputDevice::AudioInputDevice(
     scoped_ptr<AudioInputIPC> ipc,
     const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner)
     : ScopedTaskRunnerObserver(io_task_runner),
@@ skipping 213 matching lines @@
 // AudioInputDevice::AudioThreadCallback
 AudioInputDevice::AudioThreadCallback::AudioThreadCallback(
     const AudioParameters& audio_parameters,
     base::SharedMemoryHandle memory,
     int memory_length,
     int total_segments,
     CaptureCallback* capture_callback)
     : AudioDeviceThread::Callback(audio_parameters, memory, memory_length,
                                   total_segments),
       current_segment_id_(0),
+      last_buffer_id_(UINT32_MAX),
       capture_callback_(capture_callback) {
 }
 
 AudioInputDevice::AudioThreadCallback::~AudioThreadCallback() {
 }
 
 void AudioInputDevice::AudioThreadCallback::MapSharedMemory() {
   shared_memory_.Map(memory_length_);
 
   // Create vector of audio buses by wrapping existing blocks of memory.
   uint8* ptr = static_cast<uint8*>(shared_memory_.memory());
   for (int i = 0; i < total_segments_; ++i) {
     media::AudioInputBuffer* buffer =
         reinterpret_cast<media::AudioInputBuffer*>(ptr);
     scoped_ptr<media::AudioBus> audio_bus =
         media::AudioBus::WrapMemory(audio_parameters_, buffer->audio);
     audio_buses_.push_back(audio_bus.Pass());
     ptr += segment_length_;
   }
 }
 
 void AudioInputDevice::AudioThreadCallback::Process(uint32 pending_data) {
+  CHECK_EQ(current_segment_id_, static_cast<int>(pending_data));
+
   // The shared memory represents parameters, size of the data buffer and the
   // actual data buffer containing audio data. Map the memory into this
   // structure and parse out parameters and the data area.
   uint8* ptr = static_cast<uint8*>(shared_memory_.memory());
   ptr += current_segment_id_ * segment_length_;
   AudioInputBuffer* buffer = reinterpret_cast<AudioInputBuffer*>(ptr);
   // Usually this will be equal but in the case of low sample rate (e.g. 8kHz,
   // the buffer may be bigger (on mac at least)).
   DCHECK_GE(buffer->params.size,
             segment_length_ - sizeof(AudioInputBufferParameters));
   double volume = buffer->params.volume;
   bool key_pressed = buffer->params.key_pressed;
+  uint32 hardware_delay_bytes = buffer->params.hardware_delay_bytes;

[tommi (sloooow) - chröme, 2015/08/14 09:56:21]

nit: are these temporaries necessary?

[Henrik Grunell, 2015/08/14 12:38:32]

Good point, removed all of them.

+  uint32 buffer_id = buffer->params.id;
+
+  // Verify correct sequence.
+  if (last_buffer_id_ == UINT32_MAX)

[DaleCurtis, 2015/08/13 22:00:49]

Again, shouldn't be necessary since overflow is defined, UINT32_MAX + 1 == 0

[Henrik Grunell, 2015/08/14 12:38:32]

Done.

+    CHECK_EQ(0u, buffer_id);
+  else
+    CHECK_EQ(last_buffer_id_ + 1, buffer_id);
+  last_buffer_id_ = buffer_id;
 
   // Use pre-allocated audio bus wrapping existing block of shared memory.
   media::AudioBus* audio_bus = audio_buses_[current_segment_id_];
 
   // Deliver captured data to the client in floating point format
   // and update the audio-delay measurement.
-  int audio_delay_milliseconds = pending_data / bytes_per_ms_;
+  int audio_delay_milliseconds = hardware_delay_bytes / bytes_per_ms_;
   capture_callback_->Capture(
       audio_bus, audio_delay_milliseconds, volume, key_pressed);
 
   if (++current_segment_id_ >= total_segments_)
     current_segment_id_ = 0;
 }
 
 }  // namespace media