media/audio/audio_device_thread.h

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef MEDIA_AUDIO_AUDIO_DEVICE_THREAD_H_
   6 #define MEDIA_AUDIO_AUDIO_DEVICE_THREAD_H_
   7
   8 #include "base/basictypes.h"
   9 #include "base/memory/ref_counted.h"
  10 #include "base/memory/scoped_ptr.h"
  11 #include "base/memory/shared_memory.h"
  12 #include "base/sync_socket.h"
  13 #include "base/synchronization/lock.h"
  14 #include "media/audio/audio_parameters.h"
  15 #include "media/base/media_export.h"
  16
  17 namespace base {
  18 class MessageLoop;
  19 }
  20
  21 namespace media {
  22 class AudioBus;
  23
  24 // Data transfer between browser and render process uses a combination
  25 // of sync sockets and shared memory. To read from the socket and render
  26 // data, we use a worker thread, a.k.a. the AudioDeviceThread, which reads
  27 // data from the browser via the socket and fills the shared memory from the
  28 // audio thread via the AudioDeviceThread::Callback interface/class.
  29 // For more details see the documentation in audio_device.h.
  30 //
  31 // TODO(tommi): Multiple audio input/output device instances should be able to
  32 // share the same thread instead of spinning one per instance.
  33 class MEDIA_EXPORT AudioDeviceThread {
  34  public:
  35   // This is the callback interface/base class that Audio[Output|Input]Device
  36   // implements to render input/output data. The callbacks run on the
  37   // thread owned by AudioDeviceThread.
  38   class Callback {
  39    public:
  40     Callback(const AudioParameters& audio_parameters,
  41              base::SharedMemoryHandle memory,
  42              int memory_length,
  43              int total_segments);
  44     virtual ~Callback();
  45
  46     // One time initialization for the callback object on the audio thread.
  47     void InitializeOnAudioThread();
  48
  49     // Derived implementations must call shared_memory_.Map appropriately
  50     // before Process can be called.
  51     virtual void MapSharedMemory() = 0;
  52
  53     // Called whenever we receive notifications about pending data.
  54     virtual void Process(uint32 pending_data) = 0;
  55
  56    protected:
  57     // Protected so that derived classes can access directly.
  58     // The variables are 'const' since values are calculated/set in the
  59     // constructor and must never change.
  60     const AudioParameters audio_parameters_;
  61     const int samples_per_ms_;
  62     const int bytes_per_ms_;
  63
  64     base::SharedMemory shared_memory_;
  65     const int memory_length_;
  66     const int total_segments_;
  67     int segment_length_;
  68
  69    private:
  70     DISALLOW_COPY_AND_ASSIGN(Callback);
  71   };
  72
  73   AudioDeviceThread();
  74   ~AudioDeviceThread();
  75
  76   // Starts the audio thread. The thread must not already be running.  If
  77   // |sychronized_buffers| is set, the browser expects to be notified via the
  78   // |socket| every time AudioDeviceThread::Process() completes.
  79   void Start(AudioDeviceThread::Callback* callback,
  80              base::SyncSocket::Handle socket,
  81              const char* thread_name,
  82              bool synchronized_buffers);
  83
  84   // This tells the audio thread to stop and clean up the data.
  85   // The method can stop the thread synchronously or asynchronously.
  86   // In the latter case, the thread will still be running after Stop()
  87   // returns, but the callback pointer is cleared so no further callbacks will
  88   // be made (IOW after Stop() returns, it is safe to delete the callback).
  89   // The |loop_for_join| parameter is required for asynchronous operation
  90   // in order to join the worker thread and close the thread handle later via a
  91   // posted task.
  92   // If set to NULL, function will wait for the thread to exit before returning.
  93   void Stop(base::MessageLoop* loop_for_join);
  94
  95   // Returns true if the thread is stopped or stopping.
  96   bool IsStopped();
  97
  98  private:
  99   // Our own private SimpleThread override.  We implement this in a
 100   // private class so that we get the following benefits:
 101   // 1) AudioDeviceThread doesn't expose SimpleThread methods.
 102   //    I.e. the caller can't call Start()/Stop() - which would be bad.
 103   // 2) We override ThreadMain to add additional on-thread initialization
 104   //    while still synchronized with SimpleThread::Start() to provide
 105   //    reliable initialization.
 106   class Thread;
 107
 108   base::Lock thread_lock_;
 109   scoped_refptr<AudioDeviceThread::Thread> thread_;
 110
 111   DISALLOW_COPY_AND_ASSIGN(AudioDeviceThread);
 112 };
 113
 114 }  // namespace media.
 115
 116 #endif  // MEDIA_AUDIO_AUDIO_DEVICE_THREAD_H_