1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
|
// 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.
#ifndef PPAPI_SHARED_IMPL_PPB_AUDIO_INPUT_SHARED_H_
#define PPAPI_SHARED_IMPL_PPB_AUDIO_INPUT_SHARED_H_
#include "base/basictypes.h"
#include "base/compiler_specific.h"
#include "base/memory/ref_counted.h"
#include "base/memory/scoped_ptr.h"
#include "base/shared_memory.h"
#include "base/sync_socket.h"
#include "base/threading/simple_thread.h"
#include "ppapi/c/dev/ppb_audio_input_dev.h"
#include "ppapi/c/ppb_audio_config.h"
#include "ppapi/shared_impl/resource.h"
#include "ppapi/shared_impl/scoped_pp_resource.h"
#include "ppapi/shared_impl/tracked_callback.h"
#include "ppapi/thunk/ppb_audio_input_api.h"
namespace ppapi {
// Implements the logic to map shared memory and run the audio thread signaled
// from the sync socket. Both the proxy and the renderer implementation use
// this code.
class PPAPI_SHARED_EXPORT PPB_AudioInput_Shared
: public Resource,
public thunk::PPB_AudioInput_API,
public base::DelegateSimpleThread::Delegate {
public:
// Used by the proxy.
explicit PPB_AudioInput_Shared(const HostResource& audio_input);
// Used by the impl.
explicit PPB_AudioInput_Shared(PP_Instance instance);
virtual ~PPB_AudioInput_Shared();
// Resource overrides.
virtual thunk::PPB_AudioInput_API* AsPPB_AudioInput_API() OVERRIDE;
// Implementation of PPB_AudioInput_API non-trusted methods.
virtual int32_t EnumerateDevices(
PP_Resource* devices,
const PP_CompletionCallback& callback) OVERRIDE;
virtual int32_t Open(const std::string& device_id,
PP_Resource config,
PPB_AudioInput_Callback audio_input_callback,
void* user_data,
const PP_CompletionCallback& callback) OVERRIDE;
virtual PP_Resource GetCurrentConfig() OVERRIDE;
virtual PP_Bool StartCapture() OVERRIDE;
virtual PP_Bool StopCapture() OVERRIDE;
virtual void Close() OVERRIDE;
void OnEnumerateDevicesComplete(int32_t result,
const std::vector<DeviceRefData>& devices);
void OnOpenComplete(int32_t result,
base::SharedMemoryHandle shared_memory_handle,
size_t shared_memory_size,
base::SyncSocket::Handle socket_handle);
static PP_CompletionCallback MakeIgnoredCompletionCallback();
protected:
enum OpenState {
BEFORE_OPEN,
OPENED,
CLOSED
};
// Subclasses should implement these methods to do impl- and proxy-specific
// work.
virtual int32_t InternalEnumerateDevices(PP_Resource* devices,
PP_CompletionCallback callback) = 0;
virtual int32_t InternalOpen(const std::string& device_id,
PP_AudioSampleRate sample_rate,
uint32_t sample_frame_count,
PP_CompletionCallback callback) = 0;
virtual PP_Bool InternalStartCapture() = 0;
virtual PP_Bool InternalStopCapture() = 0;
virtual void InternalClose() = 0;
// Configures the current state to be capturing or not. The caller is
// responsible for ensuring the new state is the opposite of the current one.
//
// This is the implementation for PPB_AudioInput.Start/StopCapture, except
// that it does not actually notify the audio system to stop capture, it just
// configures our object to stop generating callbacks. The actual stop
// capture request will be done in the derived classes and will be different
// from the proxy and the renderer.
void SetStartCaptureState();
void SetStopCaptureState();
// Sets the shared memory and socket handles. This will automatically start
// capture if we're currently set to capture.
void SetStreamInfo(base::SharedMemoryHandle shared_memory_handle,
size_t shared_memory_size,
base::SyncSocket::Handle socket_handle);
// Starts execution of the audio input thread.
void StartThread();
// Stops execution of the audio input thread.
void StopThread();
// DelegateSimpleThread::Delegate implementation.
// Run on the audio input thread.
virtual void Run();
// The common implementation of OpenTrusted() and Open(). It will call
// InternalOpen() to do impl- and proxy-specific work.
// OpenTrusted() will call this methods with a NULL |audio_input_callback|,
// in this case, the thread will not be run. This non-callback mode is used in
// the renderer with the proxy, since the proxy handles the callback entirely
// within the plugin process.
int32_t CommonOpen(const std::string& device_id,
PP_Resource config,
PPB_AudioInput_Callback audio_input_callback,
void* user_data,
PP_CompletionCallback callback);
OpenState open_state_;
// True if capturing the stream.
bool capturing_;
// Socket used to notify us when new samples are available. This pointer is
// created in SetStreamInfo().
scoped_ptr<base::CancelableSyncSocket> socket_;
// Sample buffer in shared memory. This pointer is created in
// SetStreamInfo(). The memory is only mapped when the audio thread is
// created.
scoped_ptr<base::SharedMemory> shared_memory_;
// The size of the sample buffer in bytes.
size_t shared_memory_size_;
// When the callback is set, this thread is spawned for calling it.
scoped_ptr<base::DelegateSimpleThread> audio_input_thread_;
// Callback to call when new samples are available.
PPB_AudioInput_Callback audio_input_callback_;
// User data pointer passed verbatim to the callback function.
void* user_data_;
scoped_refptr<TrackedCallback> enumerate_devices_callback_;
scoped_refptr<TrackedCallback> open_callback_;
// Owning reference to the current config object. This isn't actually used,
// we just dish it out as requested by the plugin.
ScopedPPResource config_;
// Output parameter of EnumerateDevices(). It should not be accessed after
// |enumerate_devices_callback_| is run.
PP_Resource* devices_;
ResourceObjectType resource_object_type_;
DISALLOW_COPY_AND_ASSIGN(PPB_AudioInput_Shared);
};
} // namespace ppapi
#endif // PPAPI_SHARED_IMPL_PPB_AUDIO_INPUT_SHARED_H_
|
