1 /*
2 * Copyright 2016 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #define LOG_TAG "AAudio"
18 //#define LOG_NDEBUG 0
19 #include <utils/Log.h>
20
21 #include <stdint.h>
22
23 #include <binder/Parcelable.h>
24
25 #include "binding/AAudioServiceDefinitions.h"
26 #include "binding/SharedRegionParcelable.h"
27 #include "binding/RingBufferParcelable.h"
28
29 using namespace aaudio;
30
RingBufferParcelable()31 RingBufferParcelable::RingBufferParcelable() {}
~RingBufferParcelable()32 RingBufferParcelable::~RingBufferParcelable() {}
33
34 // TODO This assumes that all three use the same SharedMemoryParcelable
setupMemory(int32_t sharedMemoryIndex,int32_t dataMemoryOffset,int32_t dataSizeInBytes,int32_t readCounterOffset,int32_t writeCounterOffset,int32_t counterSizeBytes)35 void RingBufferParcelable::setupMemory(int32_t sharedMemoryIndex,
36 int32_t dataMemoryOffset,
37 int32_t dataSizeInBytes,
38 int32_t readCounterOffset,
39 int32_t writeCounterOffset,
40 int32_t counterSizeBytes) {
41 mReadCounterParcelable.setup(sharedMemoryIndex, readCounterOffset, counterSizeBytes);
42 mWriteCounterParcelable.setup(sharedMemoryIndex, writeCounterOffset, counterSizeBytes);
43 mDataParcelable.setup(sharedMemoryIndex, dataMemoryOffset, dataSizeInBytes);
44 }
45
setupMemory(int32_t sharedMemoryIndex,int32_t dataMemoryOffset,int32_t dataSizeInBytes)46 void RingBufferParcelable::setupMemory(int32_t sharedMemoryIndex,
47 int32_t dataMemoryOffset,
48 int32_t dataSizeInBytes) {
49 mReadCounterParcelable.setup(sharedMemoryIndex, 0, 0);
50 mWriteCounterParcelable.setup(sharedMemoryIndex, 0, 0);
51 mDataParcelable.setup(sharedMemoryIndex, dataMemoryOffset, dataSizeInBytes);
52 }
53
getBytesPerFrame()54 int32_t RingBufferParcelable::getBytesPerFrame() {
55 return mBytesPerFrame;
56 }
57
setBytesPerFrame(int32_t bytesPerFrame)58 void RingBufferParcelable::setBytesPerFrame(int32_t bytesPerFrame) {
59 mBytesPerFrame = bytesPerFrame;
60 }
61
getFramesPerBurst()62 int32_t RingBufferParcelable::getFramesPerBurst() {
63 return mFramesPerBurst;
64 }
65
setFramesPerBurst(int32_t framesPerBurst)66 void RingBufferParcelable::setFramesPerBurst(int32_t framesPerBurst) {
67 mFramesPerBurst = framesPerBurst;
68 }
69
getCapacityInFrames()70 int32_t RingBufferParcelable::getCapacityInFrames() {
71 return mCapacityInFrames;
72 }
73
setCapacityInFrames(int32_t capacityInFrames)74 void RingBufferParcelable::setCapacityInFrames(int32_t capacityInFrames) {
75 mCapacityInFrames = capacityInFrames;
76 }
77
78 /**
79 * The read and write must be symmetric.
80 */
writeToParcel(Parcel * parcel) const81 status_t RingBufferParcelable::writeToParcel(Parcel* parcel) const {
82 status_t status = parcel->writeInt32(mCapacityInFrames);
83 if (status != NO_ERROR) goto error;
84 if (mCapacityInFrames > 0) {
85 status = parcel->writeInt32(mBytesPerFrame);
86 if (status != NO_ERROR) goto error;
87 status = parcel->writeInt32(mFramesPerBurst);
88 if (status != NO_ERROR) goto error;
89 status = parcel->writeInt32(mFlags);
90 if (status != NO_ERROR) goto error;
91 status = mReadCounterParcelable.writeToParcel(parcel);
92 if (status != NO_ERROR) goto error;
93 status = mWriteCounterParcelable.writeToParcel(parcel);
94 if (status != NO_ERROR) goto error;
95 status = mDataParcelable.writeToParcel(parcel);
96 if (status != NO_ERROR) goto error;
97 }
98 return NO_ERROR;
99 error:
100 ALOGE("RingBufferParcelable::writeToParcel() error = %d", status);
101 return status;
102 }
103
readFromParcel(const Parcel * parcel)104 status_t RingBufferParcelable::readFromParcel(const Parcel* parcel) {
105 status_t status = parcel->readInt32(&mCapacityInFrames);
106 if (status != NO_ERROR) goto error;
107 if (mCapacityInFrames > 0) {
108 status = parcel->readInt32(&mBytesPerFrame);
109 if (status != NO_ERROR) goto error;
110 status = parcel->readInt32(&mFramesPerBurst);
111 if (status != NO_ERROR) goto error;
112 status = parcel->readInt32((int32_t *)&mFlags);
113 if (status != NO_ERROR) goto error;
114 status = mReadCounterParcelable.readFromParcel(parcel);
115 if (status != NO_ERROR) goto error;
116 status = mWriteCounterParcelable.readFromParcel(parcel);
117 if (status != NO_ERROR) goto error;
118 status = mDataParcelable.readFromParcel(parcel);
119 if (status != NO_ERROR) goto error;
120 }
121 return NO_ERROR;
122 error:
123 ALOGE("RingBufferParcelable::readFromParcel() error = %d", status);
124 return status;
125 }
126
resolve(SharedMemoryParcelable * memoryParcels,RingBufferDescriptor * descriptor)127 aaudio_result_t RingBufferParcelable::resolve(SharedMemoryParcelable *memoryParcels, RingBufferDescriptor *descriptor) {
128 aaudio_result_t result;
129
130 result = mReadCounterParcelable.resolve(memoryParcels,
131 (void **) &descriptor->readCounterAddress);
132 if (result != AAUDIO_OK) {
133 return result;
134 }
135
136 result = mWriteCounterParcelable.resolve(memoryParcels,
137 (void **) &descriptor->writeCounterAddress);
138 if (result != AAUDIO_OK) {
139 return result;
140 }
141
142 result = mDataParcelable.resolve(memoryParcels, (void **) &descriptor->dataAddress);
143 if (result != AAUDIO_OK) {
144 return result;
145 }
146
147 descriptor->bytesPerFrame = mBytesPerFrame;
148 descriptor->framesPerBurst = mFramesPerBurst;
149 descriptor->capacityInFrames = mCapacityInFrames;
150 descriptor->flags = mFlags;
151 return AAUDIO_OK;
152 }
153
validate()154 aaudio_result_t RingBufferParcelable::validate() {
155 aaudio_result_t result;
156 if (mCapacityInFrames < 0 || mCapacityInFrames >= 32 * 1024) {
157 ALOGE("RingBufferParcelable invalid mCapacityInFrames = %d", mCapacityInFrames);
158 return AAUDIO_ERROR_INTERNAL;
159 }
160 if (mBytesPerFrame < 0 || mBytesPerFrame >= 256) {
161 ALOGE("RingBufferParcelable invalid mBytesPerFrame = %d", mBytesPerFrame);
162 return AAUDIO_ERROR_INTERNAL;
163 }
164 if (mFramesPerBurst < 0 || mFramesPerBurst >= 16 * 1024) {
165 ALOGE("RingBufferParcelable invalid mFramesPerBurst = %d", mFramesPerBurst);
166 return AAUDIO_ERROR_INTERNAL;
167 }
168 if ((result = mReadCounterParcelable.validate()) != AAUDIO_OK) {
169 ALOGE("RingBufferParcelable invalid mReadCounterParcelable = %d", result);
170 return result;
171 }
172 if ((result = mWriteCounterParcelable.validate()) != AAUDIO_OK) {
173 ALOGE("RingBufferParcelable invalid mWriteCounterParcelable = %d", result);
174 return result;
175 }
176 if ((result = mDataParcelable.validate()) != AAUDIO_OK) {
177 ALOGE("RingBufferParcelable invalid mDataParcelable = %d", result);
178 return result;
179 }
180 return AAUDIO_OK;
181 }
182
183
dump()184 void RingBufferParcelable::dump() {
185 ALOGD("RingBufferParcelable mCapacityInFrames = %d ---------", mCapacityInFrames);
186 if (mCapacityInFrames > 0) {
187 ALOGD("RingBufferParcelable mBytesPerFrame = %d", mBytesPerFrame);
188 ALOGD("RingBufferParcelable mFramesPerBurst = %d", mFramesPerBurst);
189 ALOGD("RingBufferParcelable mFlags = %u", mFlags);
190 mReadCounterParcelable.dump();
191 mWriteCounterParcelable.dump();
192 mDataParcelable.dump();
193 }
194 }
195