ppb_audio_shared.h revision c5cede9ae108bb15f6b7a8aea21c7e1fefa2834c 
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 PPAPI_SHARED_IMPL_PPB_AUDIO_SHARED_H_
6#define PPAPI_SHARED_IMPL_PPB_AUDIO_SHARED_H_
7
8#include "base/memory/scoped_ptr.h"
9#include "base/memory/shared_memory.h"
10#include "base/sync_socket.h"
11#include "base/threading/simple_thread.h"
12#include "media/base/audio_bus.h"
13#include "ppapi/c/ppb_audio.h"
14#include "ppapi/c/ppb_audio_config.h"
15#include "ppapi/shared_impl/resource.h"
16#include "ppapi/thunk/ppb_audio_api.h"
17
18#if defined(OS_NACL)
19#include "ppapi/nacl_irt/public/irt_ppapi.h"
20#endif
21
22namespace ppapi {
23
24class PPAPI_SHARED_EXPORT AudioCallbackCombined {
25 public:
26  AudioCallbackCombined();
27  explicit AudioCallbackCombined(PPB_Audio_Callback_1_0 callback_1_0);
28  explicit AudioCallbackCombined(PPB_Audio_Callback callback);
29
30  ~AudioCallbackCombined();
31
32  bool IsValid() const;
33
34  void Run(void* sample_buffer,
35           uint32_t buffer_size_in_bytes,
36           PP_TimeDelta latency,
37           void* user_data) const;
38
39 private:
40  PPB_Audio_Callback_1_0 callback_1_0_;
41  PPB_Audio_Callback callback_;
42};
43
44// Implements the logic to map shared memory and run the audio thread signaled
45// from the sync socket. Both the proxy and the renderer implementation use
46// this code.
47class PPAPI_SHARED_EXPORT PPB_Audio_Shared
48    : public thunk::PPB_Audio_API,
49      public base::DelegateSimpleThread::Delegate {
50 public:
51  PPB_Audio_Shared();
52  virtual ~PPB_Audio_Shared();
53
54  bool playing() const { return playing_; }
55
56  // Sets the callback information that the background thread will use. This
57  // is optional. Without a callback, the thread will not be run. This
58  // non-callback mode is used in the renderer with the proxy, since the proxy
59  // handles the callback entirely within the plugin process.
60  void SetCallback(const AudioCallbackCombined& callback, void* user_data);
61
62  // Configures the current state to be playing or not. The caller is
63  // responsible for ensuring the new state is the opposite of the current one.
64  //
65  // This is the implementation for PPB_Audio.Start/StopPlayback, except that
66  // it does not actually notify the audio system to stop playback, it just
67  // configures our object to stop generating callbacks. The actual stop
68  // playback request will be done in the derived classes and will be different
69  // from the proxy and the renderer.
70  void SetStartPlaybackState();
71  void SetStopPlaybackState();
72
73  // Sets the shared memory and socket handles. This will automatically start
74  // playback if we're currently set to play.
75  void SetStreamInfo(PP_Instance instance,
76                     base::SharedMemoryHandle shared_memory_handle,
77                     size_t shared_memory_size,
78                     base::SyncSocket::Handle socket_handle,
79                     PP_AudioSampleRate sample_rate,
80                     int sample_frame_count);
81
82#if defined(OS_NACL)
83  // NaCl has a special API for IRT code to create threads that can call back
84  // into user code.
85  static void SetThreadFunctions(const struct PP_ThreadFunctions* functions);
86#endif
87
88 private:
89  // Starts execution of the audio thread.
90  void StartThread();
91
92  // Stop execution of the audio thread.
93  void StopThread();
94
95  // DelegateSimpleThread::Delegate implementation. Run on the audio thread.
96  virtual void Run();
97
98  // True if playing the stream.
99  bool playing_;
100
101  // Socket used to notify us when audio is ready to accept new samples. This
102  // pointer is created in StreamCreated().
103  scoped_ptr<base::CancelableSyncSocket> socket_;
104
105  // Sample buffer in shared memory. This pointer is created in
106  // StreamCreated(). The memory is only mapped when the audio thread is
107  // created.
108  scoped_ptr<base::SharedMemory> shared_memory_;
109
110  // The size of the sample buffer in bytes.
111  size_t shared_memory_size_;
112
113#if !defined(OS_NACL)
114  // When the callback is set, this thread is spawned for calling it.
115  scoped_ptr<base::DelegateSimpleThread> audio_thread_;
116#else
117  uintptr_t thread_id_;
118  bool thread_active_;
119
120  static void CallRun(void* self);
121#endif
122
123  // Callback to call when audio is ready to accept new samples.
124  AudioCallbackCombined callback_;
125
126  // User data pointer passed verbatim to the callback function.
127  void* user_data_;
128
129  // AudioBus for shuttling data across the shared memory.
130  scoped_ptr<media::AudioBus> audio_bus_;
131
132  // Internal buffer for client's integer audio data.
133  int client_buffer_size_bytes_;
134  scoped_ptr<uint8_t[]> client_buffer_;
135
136  // The size (in bytes) of one second of audio data. Used to calculate latency.
137  size_t bytes_per_second_;
138
139  // Buffer index used to coordinate with the browser side audio receiver.
140  uint32_t buffer_index_;
141
142  DISALLOW_COPY_AND_ASSIGN(PPB_Audio_Shared);
143};
144
145}  // namespace ppapi
146
147#endif  // PPAPI_SHARED_IMPL_PPB_AUDIO_SHARED_H_
148