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