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(const RingBuffer & parcelable)32 RingBufferParcelable::RingBufferParcelable(const RingBuffer& parcelable)
33 : mReadCounterParcelable(parcelable.readCounterParcelable),
34 mWriteCounterParcelable(parcelable.writeCounterParcelable),
35 mDataParcelable(parcelable.dataParcelable),
36 mSharedMemoryIndex(parcelable.sharedMemoryIndex),
37 mBytesPerFrame(parcelable.bytesPerFrame),
38 mFramesPerBurst(parcelable.framesPerBurst),
39 mCapacityInFrames(parcelable.capacityInFrames),
40 mFlags(static_cast<RingbufferFlags>(parcelable.flags)) {
41 static_assert(sizeof(mFlags) == sizeof(parcelable.flags));
42 }
43
parcelable() const44 RingBuffer RingBufferParcelable::parcelable() const {
45 RingBuffer result;
46 result.readCounterParcelable = mReadCounterParcelable.parcelable();
47 result.writeCounterParcelable = mWriteCounterParcelable.parcelable();
48 result.dataParcelable = mDataParcelable.parcelable();
49 result.sharedMemoryIndex = mSharedMemoryIndex;
50 result.bytesPerFrame = mBytesPerFrame;
51 result.framesPerBurst = mFramesPerBurst;
52 result.capacityInFrames = mCapacityInFrames;
53 static_assert(sizeof(mFlags) == sizeof(result.flags));
54 result.flags = static_cast<int32_t>(mFlags);
55 return result;
56 }
57
58 // 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)59 void RingBufferParcelable::setupMemory(int32_t sharedMemoryIndex,
60 int32_t dataMemoryOffset,
61 int32_t dataSizeInBytes,
62 int32_t readCounterOffset,
63 int32_t writeCounterOffset,
64 int32_t counterSizeBytes) {
65 mSharedMemoryIndex = sharedMemoryIndex;
66 mReadCounterParcelable.setup(sharedMemoryIndex, readCounterOffset, counterSizeBytes);
67 mWriteCounterParcelable.setup(sharedMemoryIndex, writeCounterOffset, counterSizeBytes);
68 mDataParcelable.setup(sharedMemoryIndex, dataMemoryOffset, dataSizeInBytes);
69 }
70
setupMemory(int32_t sharedMemoryIndex,int32_t dataMemoryOffset,int32_t dataSizeInBytes)71 void RingBufferParcelable::setupMemory(int32_t sharedMemoryIndex,
72 int32_t dataMemoryOffset,
73 int32_t dataSizeInBytes) {
74 mSharedMemoryIndex = sharedMemoryIndex;
75 mReadCounterParcelable.setup(sharedMemoryIndex, 0, 0);
76 mWriteCounterParcelable.setup(sharedMemoryIndex, 0, 0);
77 mDataParcelable.setup(sharedMemoryIndex, dataMemoryOffset, dataSizeInBytes);
78 }
79
getBytesPerFrame() const80 int32_t RingBufferParcelable::getBytesPerFrame() const {
81 return mBytesPerFrame;
82 }
83
setBytesPerFrame(int32_t bytesPerFrame)84 void RingBufferParcelable::setBytesPerFrame(int32_t bytesPerFrame) {
85 mBytesPerFrame = bytesPerFrame;
86 }
87
getFramesPerBurst() const88 int32_t RingBufferParcelable::getFramesPerBurst() const {
89 return mFramesPerBurst;
90 }
91
setFramesPerBurst(int32_t framesPerBurst)92 void RingBufferParcelable::setFramesPerBurst(int32_t framesPerBurst) {
93 mFramesPerBurst = framesPerBurst;
94 }
95
getCapacityInFrames() const96 int32_t RingBufferParcelable::getCapacityInFrames() const {
97 return mCapacityInFrames;
98 }
99
setCapacityInFrames(int32_t capacityInFrames)100 void RingBufferParcelable::setCapacityInFrames(int32_t capacityInFrames) {
101 mCapacityInFrames = capacityInFrames;
102 }
103
resolve(SharedMemoryParcelable * memoryParcels,RingBufferDescriptor * descriptor)104 aaudio_result_t RingBufferParcelable::resolve(SharedMemoryParcelable *memoryParcels, RingBufferDescriptor *descriptor) {
105 aaudio_result_t result;
106
107 result = mReadCounterParcelable.resolve(memoryParcels,
108 (void **) &descriptor->readCounterAddress);
109 if (result != AAUDIO_OK) {
110 return result;
111 }
112
113 result = mWriteCounterParcelable.resolve(memoryParcels,
114 (void **) &descriptor->writeCounterAddress);
115 if (result != AAUDIO_OK) {
116 return result;
117 }
118
119 result = mDataParcelable.resolve(memoryParcels, (void **) &descriptor->dataAddress);
120 if (result != AAUDIO_OK) {
121 return result;
122 }
123
124 descriptor->bytesPerFrame = mBytesPerFrame;
125 descriptor->framesPerBurst = mFramesPerBurst;
126 descriptor->capacityInFrames = mCapacityInFrames;
127 descriptor->flags = mFlags;
128 return AAUDIO_OK;
129 }
130
updateMemory(const RingBufferParcelable & parcelable)131 void RingBufferParcelable::updateMemory(const RingBufferParcelable& parcelable) {
132 setupMemory(mSharedMemoryIndex, 0,
133 parcelable.getCapacityInFrames() * parcelable.getBytesPerFrame());
134 setBytesPerFrame(parcelable.getBytesPerFrame());
135 setFramesPerBurst(parcelable.getFramesPerBurst());
136 setCapacityInFrames(parcelable.getCapacityInFrames());
137 }
138
validate() const139 aaudio_result_t RingBufferParcelable::validate() const {
140 if (mCapacityInFrames < 0 || mCapacityInFrames >= 32 * 1024) {
141 ALOGE("invalid mCapacityInFrames = %d", mCapacityInFrames);
142 return AAUDIO_ERROR_INTERNAL;
143 }
144 if (mBytesPerFrame < 0 || mBytesPerFrame >= 256) {
145 ALOGE("invalid mBytesPerFrame = %d", mBytesPerFrame);
146 return AAUDIO_ERROR_INTERNAL;
147 }
148 if (mFramesPerBurst < 0 || mFramesPerBurst >= 16 * 1024) {
149 ALOGE("invalid mFramesPerBurst = %d", mFramesPerBurst);
150 return AAUDIO_ERROR_INTERNAL;
151 }
152 return AAUDIO_OK;
153 }
154
155
dump()156 void RingBufferParcelable::dump() {
157 ALOGD("mCapacityInFrames = %d ---------", mCapacityInFrames);
158 if (mCapacityInFrames > 0) {
159 ALOGD("mBytesPerFrame = %d", mBytesPerFrame);
160 ALOGD("mFramesPerBurst = %d", mFramesPerBurst);
161 ALOGD("mFlags = %u", mFlags);
162 mReadCounterParcelable.dump();
163 mWriteCounterParcelable.dump();
164 mDataParcelable.dump();
165 }
166 }
167