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
|
/*
* Copyright (C) 2007 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ANDROID_AUDIO_TRACK_SHARED_H
#define ANDROID_AUDIO_TRACK_SHARED_H
#include <stdint.h>
#include <sys/types.h>
#include <utils/threads.h>
namespace android {
// ----------------------------------------------------------------------------
// Maximum cumulated timeout milliseconds before restarting audioflinger thread
#define MAX_STARTUP_TIMEOUT_MS 3000 // Longer timeout period at startup to cope with A2DP
// init time
#define MAX_RUN_TIMEOUT_MS 1000
#define WAIT_PERIOD_MS 10
// AudioTrack no longer uses this, it is for AudioRecord only:
#define RESTORE_TIMEOUT_MS 5000 // Maximum waiting time for a track to be restored
#define CBLK_UNDERRUN 0x01 // set: underrun (out) or overrrun (in), clear: no underrun or overrun
#define CBLK_FORCEREADY 0x02 // set: track is considered ready immediately by AudioFlinger,
// clear: track is ready when buffer full
#define CBLK_INVALID 0x04 // track buffer invalidated by AudioFlinger, need to re-create
#define CBLK_DISABLED 0x08 // track disabled by AudioFlinger due to underrun, need to re-start
// AudioTrack no longer uses these, they are for AudioRecord only:
#define CBLK_RESTORING 0x10 // track is being restored after invalidation by AudioFlinger
#define CBLK_RESTORED 0x20 // track has been restored after invalidation by AudioFlinger
// Important: do not add any virtual methods, including ~
struct audio_track_cblk_t
{
// The data members are grouped so that members accessed frequently and in the same context
// are in the same line of data cache.
Mutex lock; // sizeof(int)
Condition cv; // sizeof(int)
// next 4 are offsets within "buffers"
volatile uint32_t user;
volatile uint32_t server;
uint32_t userBase;
uint32_t serverBase;
int mPad1; // unused, but preserves cache line alignment
uint32_t frameCount;
// Cache line boundary
uint32_t loopStart;
uint32_t loopEnd; // read-only for server, read/write for client
int loopCount; // read/write for client
// Channel volumes are fixed point U4.12, so 0x1000 means 1.0.
// Left channel is in [0:15], right channel is in [16:31].
// Always read and write the combined pair atomically.
// For AudioTrack only, not used by AudioRecord.
private:
uint32_t mVolumeLR;
public:
uint32_t sampleRate;
uint8_t mPad2; // unused
// read-only for client, server writes once at initialization and is then read-only
uint8_t mName; // normal tracks: track name, fast tracks: track index
// used by client only
uint16_t bufferTimeoutMs; // Maximum cumulated timeout before restarting
// audioflinger
uint16_t waitTimeMs; // Cumulated wait time, used by client only
private:
// client write-only, server read-only
uint16_t mSendLevel; // Fixed point U4.12 so 0x1000 means 1.0
public:
volatile int32_t flags;
// Cache line boundary (32 bytes)
// Since the control block is always located in shared memory, this constructor
// is only used for placement new(). It is never used for regular new() or stack.
audio_track_cblk_t();
// called by client only, where client includes regular
// AudioTrack and AudioFlinger::PlaybackThread::OutputTrack
uint32_t stepUserIn(uint32_t frameCount) { return stepUser(frameCount, false); }
uint32_t stepUserOut(uint32_t frameCount) { return stepUser(frameCount, true); }
bool stepServer(uint32_t frameCount, bool isOut);
// if there is a shared buffer, "buffers" is the value of pointer() for the shared
// buffer, otherwise "buffers" points immediately after the control block
void* buffer(void *buffers, uint32_t frameSize, uint32_t offset) const;
uint32_t framesAvailableIn() { return framesAvailable(false); }
uint32_t framesAvailableOut() { return framesAvailable(true); }
uint32_t framesAvailableIn_l() { return framesAvailable_l(false); }
uint32_t framesAvailableOut_l() { return framesAvailable_l(true); }
uint32_t framesReadyIn() { return framesReady(false); }
uint32_t framesReadyOut() { return framesReady(true); }
bool tryLock();
// No barriers on the following operations, so the ordering of loads/stores
// with respect to other parameters is UNPREDICTABLE. That's considered safe.
// for AudioTrack client only, caller must limit to 0.0 <= sendLevel <= 1.0
void setSendLevel(float sendLevel) {
mSendLevel = uint16_t(sendLevel * 0x1000);
}
// for AudioFlinger only; the return value must be validated by the caller
uint16_t getSendLevel_U4_12() const {
return mSendLevel;
}
// for AudioTrack client only, caller must limit to 0 <= volumeLR <= 0x10001000
void setVolumeLR(uint32_t volumeLR) {
mVolumeLR = volumeLR;
}
// for AudioFlinger only; the return value must be validated by the caller
uint32_t getVolumeLR() const {
return mVolumeLR;
}
private:
// isOut == true means AudioTrack, isOut == false means AudioRecord
uint32_t stepUser(uint32_t frameCount, bool isOut);
uint32_t framesAvailable(bool isOut);
uint32_t framesAvailable_l(bool isOut);
uint32_t framesReady(bool isOut);
};
// ----------------------------------------------------------------------------
}; // namespace android
#endif // ANDROID_AUDIO_TRACK_SHARED_H
|