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 "RingBufferParcelable"
18 //#define LOG_NDEBUG 0
19 #include <utils/Log.h>
20 
21 #include <stdint.h>
22 
23 #include <binder/Parcelable.h>
24 #include <utility/AAudioUtilities.h>
25 
26 #include "binding/AAudioServiceDefinitions.h"
27 #include "binding/SharedRegionParcelable.h"
28 #include "binding/RingBufferParcelable.h"
29 
30 using namespace aaudio;
31 
RingBufferParcelable()32 RingBufferParcelable::RingBufferParcelable() {}
~RingBufferParcelable()33 RingBufferParcelable::~RingBufferParcelable() {}
34 
35 // 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)36 void RingBufferParcelable::setupMemory(int32_t sharedMemoryIndex,
37                  int32_t dataMemoryOffset,
38                  int32_t dataSizeInBytes,
39                  int32_t readCounterOffset,
40                  int32_t writeCounterOffset,
41                  int32_t counterSizeBytes) {
42     mReadCounterParcelable.setup(sharedMemoryIndex, readCounterOffset, counterSizeBytes);
43     mWriteCounterParcelable.setup(sharedMemoryIndex, writeCounterOffset, counterSizeBytes);
44     mDataParcelable.setup(sharedMemoryIndex, dataMemoryOffset, dataSizeInBytes);
45 }
46 
setupMemory(int32_t sharedMemoryIndex,int32_t dataMemoryOffset,int32_t dataSizeInBytes)47 void RingBufferParcelable::setupMemory(int32_t sharedMemoryIndex,
48                  int32_t dataMemoryOffset,
49                  int32_t dataSizeInBytes) {
50     mReadCounterParcelable.setup(sharedMemoryIndex, 0, 0);
51     mWriteCounterParcelable.setup(sharedMemoryIndex, 0, 0);
52     mDataParcelable.setup(sharedMemoryIndex, dataMemoryOffset, dataSizeInBytes);
53 }
54 
getBytesPerFrame()55 int32_t RingBufferParcelable::getBytesPerFrame() {
56     return mBytesPerFrame;
57 }
58 
setBytesPerFrame(int32_t bytesPerFrame)59 void RingBufferParcelable::setBytesPerFrame(int32_t bytesPerFrame) {
60     mBytesPerFrame = bytesPerFrame;
61 }
62 
getFramesPerBurst()63 int32_t RingBufferParcelable::getFramesPerBurst() {
64     return mFramesPerBurst;
65 }
66 
setFramesPerBurst(int32_t framesPerBurst)67 void RingBufferParcelable::setFramesPerBurst(int32_t framesPerBurst) {
68     mFramesPerBurst = framesPerBurst;
69 }
70 
getCapacityInFrames()71 int32_t RingBufferParcelable::getCapacityInFrames() {
72     return mCapacityInFrames;
73 }
74 
setCapacityInFrames(int32_t capacityInFrames)75 void RingBufferParcelable::setCapacityInFrames(int32_t capacityInFrames) {
76     mCapacityInFrames = capacityInFrames;
77 }
78 
79 /**
80  * The read and write must be symmetric.
81  */
writeToParcel(Parcel * parcel) const82 status_t RingBufferParcelable::writeToParcel(Parcel* parcel) const {
83     status_t status = AAudioConvert_aaudioToAndroidStatus(validate());
84     if (status != NO_ERROR) goto error;
85 
86     status = parcel->writeInt32(mCapacityInFrames);
87     if (status != NO_ERROR) goto error;
88     if (mCapacityInFrames > 0) {
89         status = parcel->writeInt32(mBytesPerFrame);
90         if (status != NO_ERROR) goto error;
91         status = parcel->writeInt32(mFramesPerBurst);
92         if (status != NO_ERROR) goto error;
93         status = parcel->writeInt32(mFlags);
94         if (status != NO_ERROR) goto error;
95         status = mReadCounterParcelable.writeToParcel(parcel);
96         if (status != NO_ERROR) goto error;
97         status = mWriteCounterParcelable.writeToParcel(parcel);
98         if (status != NO_ERROR) goto error;
99         status = mDataParcelable.writeToParcel(parcel);
100         if (status != NO_ERROR) goto error;
101     }
102     return NO_ERROR;
103 error:
104     ALOGE("%s returning %d", __func__, status);
105     return status;
106 }
107 
readFromParcel(const Parcel * parcel)108 status_t RingBufferParcelable::readFromParcel(const Parcel* parcel) {
109     status_t status = parcel->readInt32(&mCapacityInFrames);
110     if (status != NO_ERROR) goto error;
111     if (mCapacityInFrames > 0) {
112         status = parcel->readInt32(&mBytesPerFrame);
113         if (status != NO_ERROR) goto error;
114         status = parcel->readInt32(&mFramesPerBurst);
115         if (status != NO_ERROR) goto error;
116         status = parcel->readInt32((int32_t *)&mFlags);
117         if (status != NO_ERROR) goto error;
118         status = mReadCounterParcelable.readFromParcel(parcel);
119         if (status != NO_ERROR) goto error;
120         status = mWriteCounterParcelable.readFromParcel(parcel);
121         if (status != NO_ERROR) goto error;
122         status = mDataParcelable.readFromParcel(parcel);
123         if (status != NO_ERROR) goto error;
124     }
125     return AAudioConvert_aaudioToAndroidStatus(validate());
126 error:
127     ALOGE("%s returning %d", __func__, status);
128     return status;
129 }
130 
resolve(SharedMemoryParcelable * memoryParcels,RingBufferDescriptor * descriptor)131 aaudio_result_t RingBufferParcelable::resolve(SharedMemoryParcelable *memoryParcels, RingBufferDescriptor *descriptor) {
132     aaudio_result_t result;
133 
134     result = mReadCounterParcelable.resolve(memoryParcels,
135                                             (void **) &descriptor->readCounterAddress);
136     if (result != AAUDIO_OK) {
137         return result;
138     }
139 
140     result = mWriteCounterParcelable.resolve(memoryParcels,
141                                              (void **) &descriptor->writeCounterAddress);
142     if (result != AAUDIO_OK) {
143         return result;
144     }
145 
146     result = mDataParcelable.resolve(memoryParcels, (void **) &descriptor->dataAddress);
147     if (result != AAUDIO_OK) {
148         return result;
149     }
150 
151     descriptor->bytesPerFrame = mBytesPerFrame;
152     descriptor->framesPerBurst = mFramesPerBurst;
153     descriptor->capacityInFrames = mCapacityInFrames;
154     descriptor->flags = mFlags;
155     return AAUDIO_OK;
156 }
157 
validate() const158 aaudio_result_t RingBufferParcelable::validate() const {
159     if (mCapacityInFrames < 0 || mCapacityInFrames >= 32 * 1024) {
160         ALOGE("invalid mCapacityInFrames = %d", mCapacityInFrames);
161         return AAUDIO_ERROR_INTERNAL;
162     }
163     if (mBytesPerFrame < 0 || mBytesPerFrame >= 256) {
164         ALOGE("invalid mBytesPerFrame = %d", mBytesPerFrame);
165         return AAUDIO_ERROR_INTERNAL;
166     }
167     if (mFramesPerBurst < 0 || mFramesPerBurst >= 16 * 1024) {
168         ALOGE("invalid mFramesPerBurst = %d", mFramesPerBurst);
169         return AAUDIO_ERROR_INTERNAL;
170     }
171     return AAUDIO_OK;
172 }
173 
174 
dump()175 void RingBufferParcelable::dump() {
176     ALOGD("mCapacityInFrames = %d ---------", mCapacityInFrames);
177     if (mCapacityInFrames > 0) {
178         ALOGD("mBytesPerFrame = %d", mBytesPerFrame);
179         ALOGD("mFramesPerBurst = %d", mFramesPerBurst);
180         ALOGD("mFlags = %u", mFlags);
181         mReadCounterParcelable.dump();
182         mWriteCounterParcelable.dump();
183         mDataParcelable.dump();
184     }
185 }
186