blob: cec4a072952f64a24c277109de911e785f53db89 (
plain)
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
|
// Copyright (c) 2011 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_AUDIO_IMPL_H_
#define PPAPI_SHARED_IMPL_AUDIO_IMPL_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/ppb_audio.h"
namespace pp {
namespace shared_impl {
// 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 AudioImpl : public base::DelegateSimpleThread::Delegate {
public:
AudioImpl();
virtual ~AudioImpl();
bool playing() const { return playing_; }
// Sets the callback information that the background thread will use. This
// is optional. Without a callback, 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.
void SetCallback(PPB_Audio_Callback callback, void* user_data);
// Configures the current state to be playing or not. The caller is
// responsible for ensuring the new state is the opposite of the current one.
//
// This is the implementation for PPB_Audio.Start/StopPlayback, except that
// it does not actually notify the audio system to stop playback, it just
// configures our object to stop generating callbacks. The actual stop
// playback request will be done in the derived classes and will be different
// from the proxy and the renderer.
void SetStartPlaybackState();
void SetStopPlaybackState();
// Sets the shared memory and socket handles. This will automatically start
// playback if we're currently set to play.
void SetStreamInfo(base::SharedMemoryHandle shared_memory_handle,
size_t shared_memory_size,
base::SyncSocket::Handle socket_handle);
private:
// Starts execution of the audio thread.
void StartThread();
// DelegateSimpleThread::Delegate implementation. Run on the audio thread.
virtual void Run();
// True if playing the stream.
bool playing_;
// Socket used to notify us when audio is ready to accept new samples. This
// pointer is created in StreamCreated().
scoped_ptr<base::SyncSocket> socket_;
// Sample buffer in shared memory. This pointer is created in
// StreamCreated(). 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_thread_;
// Callback to call when audio is ready to accept new samples.
PPB_Audio_Callback callback_;
// User data pointer passed verbatim to the callback function.
void* user_data_;
};
} // namespace shared_impl
} // namespace pp
#endif // PPAPI_SHARED_IMPL_AUDIO_IMPL_H_
|
