1 /* 2 * Copyright 2015 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 #ifndef FIFO_FIFO_BUFFER_H 18 #define FIFO_FIFO_BUFFER_H 19 20 #include <stdint.h> 21 22 #include "FifoControllerBase.h" 23 24 namespace android { 25 26 /** 27 * Structure that represents a region in a circular buffer that might be at the 28 * end of the array and split in two. 29 */ 30 struct WrappingBuffer { 31 enum { 32 SIZE = 2 33 }; 34 void *data[SIZE]; 35 int32_t numFrames[SIZE]; 36 }; 37 38 class FifoBuffer { 39 public: 40 FifoBuffer(int32_t bytesPerFrame, fifo_frames_t capacityInFrames); 41 42 FifoBuffer(int32_t bytesPerFrame, 43 fifo_frames_t capacityInFrames, 44 fifo_counter_t *readCounterAddress, 45 fifo_counter_t *writeCounterAddress, 46 void *dataStorageAddress); 47 48 ~FifoBuffer(); 49 50 int32_t convertFramesToBytes(fifo_frames_t frames); 51 52 fifo_frames_t read(void *destination, fifo_frames_t framesToRead); 53 54 fifo_frames_t write(const void *source, fifo_frames_t framesToWrite); 55 56 fifo_frames_t getThreshold(); 57 58 void setThreshold(fifo_frames_t threshold); 59 60 fifo_frames_t getBufferCapacityInFrames(); 61 62 /** 63 * Return pointer to available full frames in data1 and set size in numFrames1. 64 * if the data is split across the end of the FIFO then set data2 and numFrames2. 65 * Other wise set them to null 66 * @param wrappingBuffer 67 * @return total full frames available 68 */ 69 fifo_frames_t getFullDataAvailable(WrappingBuffer *wrappingBuffer); 70 71 /** 72 * Return pointer to available empty frames in data1 and set size in numFrames1. 73 * if the room is split across the end of the FIFO then set data2 and numFrames2. 74 * Other wise set them to null 75 * @param wrappingBuffer 76 * @return total empty frames available 77 */ 78 fifo_frames_t getEmptyRoomAvailable(WrappingBuffer *wrappingBuffer); 79 80 /** 81 * Copy data from the FIFO into the buffer. 82 * @param buffer 83 * @param numFrames 84 * @return 85 */ 86 fifo_frames_t readNow(void *buffer, fifo_frames_t numFrames); 87 88 int64_t getNextReadTime(int32_t frameRate); 89 getUnderrunCount()90 int32_t getUnderrunCount() const { return mUnderrunCount; } 91 getFifoControllerBase()92 FifoControllerBase *getFifoControllerBase() { return mFifo; } 93 getBytesPerFrame()94 int32_t getBytesPerFrame() { 95 return mBytesPerFrame; 96 } 97 getReadCounter()98 fifo_counter_t getReadCounter() { 99 return mFifo->getReadCounter(); 100 } 101 setReadCounter(fifo_counter_t n)102 void setReadCounter(fifo_counter_t n) { 103 mFifo->setReadCounter(n); 104 } 105 getWriteCounter()106 fifo_counter_t getWriteCounter() { 107 return mFifo->getWriteCounter(); 108 } 109 setWriteCounter(fifo_counter_t n)110 void setWriteCounter(fifo_counter_t n) { 111 mFifo->setWriteCounter(n); 112 } 113 114 /* 115 * This is generally only called before or after the buffer is used. 116 */ 117 void eraseMemory(); 118 119 private: 120 121 void fillWrappingBuffer(WrappingBuffer *wrappingBuffer, 122 int32_t framesAvailable, int32_t startIndex); 123 124 const fifo_frames_t mFrameCapacity; 125 const int32_t mBytesPerFrame; 126 uint8_t *mStorage; 127 bool mStorageOwned; // did this object allocate the storage? 128 FifoControllerBase *mFifo; 129 fifo_counter_t mFramesReadCount; 130 fifo_counter_t mFramesUnderrunCount; 131 int32_t mUnderrunCount; // need? just use frames 132 int32_t mLastReadSize; 133 }; 134 135 } // android 136 137 #endif //FIFO_FIFO_BUFFER_H 138