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_CONTROLLER_BASE_H 18 #define FIFO_FIFO_CONTROLLER_BASE_H 19 20 #include <stdint.h> 21 22 namespace android { 23 24 typedef int64_t fifo_counter_t; 25 typedef int32_t fifo_frames_t; 26 27 /** 28 * Manage the read/write indices of a circular buffer. 29 * 30 * The caller is responsible for reading and writing the actual data. 31 * Note that the span of available frames may not be contiguous. They 32 * may wrap around from the end to the beginning of the buffer. In that 33 * case the data must be read or written in at least two blocks of frames. 34 * 35 */ 36 class FifoControllerBase { 37 38 public: 39 /** 40 * Constructor for FifoControllerBase 41 * @param capacity Total size of the circular buffer in frames. 42 * @param threshold Number of frames to fill. Must be less than capacity. 43 */ 44 FifoControllerBase(fifo_frames_t capacity, fifo_frames_t threshold); 45 46 virtual ~FifoControllerBase(); 47 48 // Abstract methods to be implemented in subclasses. 49 /** 50 * @return Counter used by the reader of the FIFO. 51 */ 52 virtual fifo_counter_t getReadCounter() = 0; 53 54 /** 55 * This is normally only used internally. 56 * @param count Number of frames that have been read. 57 */ 58 virtual void setReadCounter(fifo_counter_t count) = 0; 59 60 /** 61 * @return Counter used by the reader of the FIFO. 62 */ 63 virtual fifo_counter_t getWriteCounter() = 0; 64 65 /** 66 * This is normally only used internally. 67 * @param count Number of frames that have been read. 68 */ 69 virtual void setWriteCounter(fifo_counter_t count) = 0; 70 71 /** 72 * This may be negative if an unthrottled reader has read beyond the available data. 73 * @return number of valid frames available to read. Never read more than this. 74 */ 75 fifo_frames_t getFullFramesAvailable(); 76 77 /** 78 * The index in a circular buffer of the next frame to read. 79 */ 80 fifo_frames_t getReadIndex(); 81 82 /** 83 * @param numFrames number of frames to advance the read index 84 */ 85 void advanceReadIndex(fifo_frames_t numFrames); 86 87 /** 88 * @return number of frames that can be written. Never write more than this. 89 */ 90 fifo_frames_t getEmptyFramesAvailable(); 91 92 /** 93 * The index in a circular buffer of the next frame to write. 94 */ 95 fifo_frames_t getWriteIndex(); 96 97 /** 98 * @param numFrames number of frames to advance the write index 99 */ 100 void advanceWriteIndex(fifo_frames_t numFrames); 101 102 /** 103 * You can request that the buffer not be filled above a maximum 104 * number of frames. 105 * @param threshold effective size of the buffer 106 */ 107 void setThreshold(fifo_frames_t threshold); 108 getThreshold()109 fifo_frames_t getThreshold() const { 110 return mThreshold; 111 } 112 getCapacity()113 fifo_frames_t getCapacity() const { 114 return mCapacity; 115 } 116 117 118 private: 119 fifo_frames_t mCapacity; 120 fifo_frames_t mThreshold; 121 }; 122 123 } // android 124 125 #endif // FIFO_FIFO_CONTROLLER_BASE_H 126