Rename single buffer mode to shared buffer mode

Change-Id: Id43d0737d9367981644e498942ebc0077d61038c

diff --git a/include/gui/BufferItem.h b/include/gui/BufferItem.h
index 6f45181..f45d852 100644 (file)
--- a/include/gui/BufferItem.h
+++ b/include/gui/BufferItem.h
@@ -121,10 +121,10 @@ class BufferItem : public Flattenable<BufferItem> {
 
     // Indicates that the consumer should acquire the next frame as soon as it
     // can and not wait for a frame to become available. This is only relevant
-    // in single buffer mode.
+    // in shared buffer mode.
     bool mAutoRefresh;
 
-    // Indicates that this buffer was queued by the producer. When in single
+    // Indicates that this buffer was queued by the producer. When in shared
     // buffer mode acquire() can return a BufferItem that wasn't in the queue.
     bool mQueuedBuffer;
 

diff --git a/include/gui/BufferQueueCore.h b/include/gui/BufferQueueCore.h
index 1b950ab..d232dbb 100644 (file)
--- a/include/gui/BufferQueueCore.h
+++ b/include/gui/BufferQueueCore.h
@@ -291,21 +291,21 @@ private:
     // enqueue buffers without blocking.
     bool mAsyncMode;
 
-    // mSingleBufferMode indicates whether or not single buffer mode is enabled.
-    bool mSingleBufferMode;
+    // mSharedBufferMode indicates whether or not shared buffer mode is enabled.
+    bool mSharedBufferMode;
 
-    // When single buffer mode is enabled, this indicates whether the consumer
+    // When shared buffer mode is enabled, this indicates whether the consumer
     // should acquire buffers even if BufferQueue doesn't indicate that they are
     // available.
     bool mAutoRefresh;
 
-    // When single buffer mode is enabled, this tracks which slot contains the
+    // When shared buffer mode is enabled, this tracks which slot contains the
     // shared buffer.
-    int mSingleBufferSlot;
+    int mSharedBufferSlot;
 
-    // Cached data about the shared buffer in single buffer mode
-    struct SingleBufferCache {
-        SingleBufferCache(Rect _crop, uint32_t _transform, int _scalingMode,
+    // Cached data about the shared buffer in shared buffer mode
+    struct SharedBufferCache {
+        SharedBufferCache(Rect _crop, uint32_t _transform, int _scalingMode,
                 android_dataspace _dataspace)
         : crop(_crop),
           transform(_transform),
@@ -317,7 +317,7 @@ private:
         uint32_t transform;
         uint32_t scalingMode;
         android_dataspace dataspace;
-    } mSingleBufferCache;
+    } mSharedBufferCache;
 
 }; // class BufferQueueCore
 

diff --git a/include/gui/BufferQueueProducer.h b/include/gui/BufferQueueProducer.h
index 312f323..691487d 100644 (file)
--- a/include/gui/BufferQueueProducer.h
+++ b/include/gui/BufferQueueProducer.h
@@ -173,8 +173,8 @@ public:
     // See IGraphicBufferProducer::getNextFrameNumber
     virtual uint64_t getNextFrameNumber() const override;
 
-    // See IGraphicBufferProducer::setSingleBufferMode
-    virtual status_t setSingleBufferMode(bool singleBufferMode) override;
+    // See IGraphicBufferProducer::setSharedBufferMode
+    virtual status_t setSharedBufferMode(bool sharedBufferMode) override;
 
     // See IGraphicBufferProducer::setAutoRefresh
     virtual status_t setAutoRefresh(bool autoRefresh) override;

diff --git a/include/gui/BufferSlot.h b/include/gui/BufferSlot.h
index 943fa82..57704b1 100644 (file)
--- a/include/gui/BufferSlot.h
+++ b/include/gui/BufferSlot.h
@@ -79,7 +79,7 @@ struct BufferState {
     // transitions to FREE when releaseBuffer (or detachBuffer) is called. A
     // detached buffer can also enter the ACQUIRED state via attachBuffer.
     //
-    // SHARED indicates that this buffer is being used in single-buffer
+    // SHARED indicates that this buffer is being used in shared buffer
     // mode. It can be in any combination of the other states at the same time,
     // except for FREE (since that excludes being in any other state). It can
     // also be dequeued, queued, or acquired multiple times.

diff --git a/include/gui/IGraphicBufferProducer.h b/include/gui/IGraphicBufferProducer.h
index fee7c63..32bf988 100644 (file)
--- a/include/gui/IGraphicBufferProducer.h
+++ b/include/gui/IGraphicBufferProducer.h
@@ -524,17 +524,17 @@ public:
     // Returns the number of the next frame which will be dequeued.
     virtual uint64_t getNextFrameNumber() const = 0;
 
-    // Used to enable/disable single buffer mode.
+    // Used to enable/disable shared buffer mode.
     //
-    // When single buffer mode is enabled the first buffer that is queued or
+    // When shared buffer mode is enabled the first buffer that is queued or
     // dequeued will be cached and returned to all subsequent calls to
     // dequeueBuffer and acquireBuffer. This allows the producer and consumer to
     // simultaneously access the same buffer.
-    virtual status_t setSingleBufferMode(bool singleBufferMode) = 0;
+    virtual status_t setSharedBufferMode(bool sharedBufferMode) = 0;
 
     // Used to enable/disable auto-refresh.
     //
-    // Auto refresh has no effect outside of single buffer mode. In single
+    // Auto refresh has no effect outside of shared buffer mode. In shared
     // buffer mode, when enabled, it indicates to the consumer that it should
     // attempt to acquire buffers even if it is not aware of any being
     // available.

diff --git a/include/gui/Surface.h b/include/gui/Surface.h
index 9f51cdd..5d1d7bf 100644 (file)
--- a/include/gui/Surface.h
+++ b/include/gui/Surface.h
@@ -169,7 +169,7 @@ private:
     int dispatchSetSidebandStream(va_list args);
     int dispatchSetBuffersDataSpace(va_list args);
     int dispatchSetSurfaceDamage(va_list args);
-    int dispatchSetSingleBufferMode(va_list args);
+    int dispatchSetSharedBufferMode(va_list args);
     int dispatchSetAutoRefresh(va_list args);
 
 protected:
@@ -199,7 +199,7 @@ protected:
 public:
     virtual int setMaxDequeuedBufferCount(int maxDequeuedBuffers);
     virtual int setAsyncMode(bool async);
-    virtual int setSingleBufferMode(bool singleBufferMode);
+    virtual int setSharedBufferMode(bool sharedBufferMode);
     virtual int setAutoRefresh(bool autoRefresh);
     virtual int lock(ANativeWindow_Buffer* outBuffer, ARect* inOutDirtyBounds);
     virtual int unlockAndPost();
@@ -337,10 +337,10 @@ private:
     uint32_t mGenerationNumber;
 
     // Caches the values that have been passed to the producer.
-    bool mSingleBufferMode;
+    bool mSharedBufferMode;
     bool mAutoRefresh;
 
-    // If in single buffer mode and auto refresh is enabled, store the shared
+    // If in shared buffer mode and auto refresh is enabled, store the shared
     // buffer slot and return it for all calls to queue/dequeue without going
     // over Binder.
     int mSharedBufferSlot;

diff --git a/libs/gui/BufferQueueConsumer.cpp b/libs/gui/BufferQueueConsumer.cpp
index 4029496..b591c4e 100644 (file)
--- a/libs/gui/BufferQueueConsumer.cpp
+++ b/libs/gui/BufferQueueConsumer.cpp
@@ -70,8 +70,8 @@ status_t BufferQueueConsumer::acquireBuffer(BufferItem* outBuffer,
             return INVALID_OPERATION;
         }
 
-        bool sharedBufferAvailable = mCore->mSingleBufferMode &&
-                mCore->mAutoRefresh && mCore->mSingleBufferSlot !=
+        bool sharedBufferAvailable = mCore->mSharedBufferMode &&
+                mCore->mAutoRefresh && mCore->mSharedBufferSlot !=
                 BufferQueueCore::INVALID_BUFFER_SLOT;
 
         // In asynchronous mode the list is guaranteed to be one buffer deep,
@@ -85,7 +85,7 @@ status_t BufferQueueConsumer::acquireBuffer(BufferItem* outBuffer,
         // If expectedPresent is specified, we may not want to return a buffer yet.
         // If it's specified and there's more than one buffer queued, we may want
         // to drop a buffer.
-        // Skip this if we're in single buffer mode and the queue is empty,
+        // Skip this if we're in shared buffer mode and the queue is empty,
         // since in that case we'll just return the shared buffer.
         if (expectedPresent != 0 && !mCore->mQueue.empty()) {
             const int MAX_REASONABLE_NSEC = 1000000000ULL; // 1 second
@@ -148,10 +148,10 @@ status_t BufferQueueConsumer::acquireBuffer(BufferItem* outBuffer,
                     // Front buffer is still in mSlots, so mark the slot as free
                     mSlots[front->mSlot].mBufferState.freeQueued();
 
-                    // After leaving single buffer mode, the shared buffer will
+                    // After leaving shared buffer mode, the shared buffer will
                     // still be around. Mark it as no longer shared if this
                     // operation causes it to be free.
-                    if (!mCore->mSingleBufferMode &&
+                    if (!mCore->mSharedBufferMode &&
                             mSlots[front->mSlot].mBufferState.isFree()) {
                         mSlots[front->mSlot].mBufferState.mShared = false;
                     }
@@ -199,28 +199,28 @@ status_t BufferQueueConsumer::acquireBuffer(BufferItem* outBuffer,
             // make sure the buffer has finished allocating before acquiring it
             mCore->waitWhileAllocatingLocked();
 
-            slot = mCore->mSingleBufferSlot;
+            slot = mCore->mSharedBufferSlot;
 
             // Recreate the BufferItem for the shared buffer from the data that
             // was cached when it was last queued.
             outBuffer->mGraphicBuffer = mSlots[slot].mGraphicBuffer;
             outBuffer->mFence = Fence::NO_FENCE;
-            outBuffer->mCrop = mCore->mSingleBufferCache.crop;
-            outBuffer->mTransform = mCore->mSingleBufferCache.transform &
+            outBuffer->mCrop = mCore->mSharedBufferCache.crop;
+            outBuffer->mTransform = mCore->mSharedBufferCache.transform &
                     ~static_cast<uint32_t>(
                     NATIVE_WINDOW_TRANSFORM_INVERSE_DISPLAY);
-            outBuffer->mScalingMode = mCore->mSingleBufferCache.scalingMode;
-            outBuffer->mDataSpace = mCore->mSingleBufferCache.dataspace;
+            outBuffer->mScalingMode = mCore->mSharedBufferCache.scalingMode;
+            outBuffer->mDataSpace = mCore->mSharedBufferCache.dataspace;
             outBuffer->mFrameNumber = mCore->mFrameCounter;
             outBuffer->mSlot = slot;
             outBuffer->mAcquireCalled = mSlots[slot].mAcquireCalled;
             outBuffer->mTransformToDisplayInverse =
-                    (mCore->mSingleBufferCache.transform &
+                    (mCore->mSharedBufferCache.transform &
                     NATIVE_WINDOW_TRANSFORM_INVERSE_DISPLAY) != 0;
             outBuffer->mSurfaceDamage = Region::INVALID_REGION;
             outBuffer->mQueuedBuffer = false;
             outBuffer->mIsStale = false;
-            outBuffer->mAutoRefresh = mCore->mSingleBufferMode &&
+            outBuffer->mAutoRefresh = mCore->mSharedBufferMode &&
                     mCore->mAutoRefresh;
         } else {
             slot = front->mSlot;
@@ -235,7 +235,7 @@ status_t BufferQueueConsumer::acquireBuffer(BufferItem* outBuffer,
         if (!outBuffer->mIsStale) {
             mSlots[slot].mAcquireCalled = true;
             // Don't decrease the queue count if the BufferItem wasn't
-            // previously in the queue. This happens in single buffer mode when
+            // previously in the queue. This happens in shared buffer mode when
             // the queue is empty and the BufferItem is created above.
             if (mCore->mQueue.empty()) {
                 mSlots[slot].mBufferState.acquireNotInQueue();
@@ -284,9 +284,8 @@ status_t BufferQueueConsumer::detachBuffer(int slot) {
         return NO_INIT;
     }
 
-    if (mCore->mSingleBufferMode || slot == mCore->mSingleBufferSlot) {
-        BQ_LOGE("detachBuffer: detachBuffer not allowed in single buffer"
-                "mode");
+    if (mCore->mSharedBufferMode || slot == mCore->mSharedBufferSlot) {
+        BQ_LOGE("detachBuffer: detachBuffer not allowed in shared buffer mode");
         return BAD_VALUE;
     }
 
@@ -324,9 +323,8 @@ status_t BufferQueueConsumer::attachBuffer(int* outSlot,
 
     Mutex::Autolock lock(mCore->mMutex);
 
-    if (mCore->mSingleBufferMode) {
-        BQ_LOGE("attachBuffer: cannot attach a buffer in single buffer"
-                "mode");
+    if (mCore->mSharedBufferMode) {
+        BQ_LOGE("attachBuffer: cannot attach a buffer in shared buffer mode");
         return BAD_VALUE;
     }
 
@@ -439,10 +437,10 @@ status_t BufferQueueConsumer::releaseBuffer(int slot, uint64_t frameNumber,
         mSlots[slot].mFence = releaseFence;
         mSlots[slot].mBufferState.release();
 
-        // After leaving single buffer mode, the shared buffer will
+        // After leaving shared buffer mode, the shared buffer will
         // still be around. Mark it as no longer shared if this
         // operation causes it to be free.
-        if (!mCore->mSingleBufferMode && mSlots[slot].mBufferState.isFree()) {
+        if (!mCore->mSharedBufferMode && mSlots[slot].mBufferState.isFree()) {
             mSlots[slot].mBufferState.mShared = false;
         }
         // Don't put the shared buffer on the free list.
@@ -507,7 +505,7 @@ status_t BufferQueueConsumer::disconnect() {
     mCore->mConsumerListener = NULL;
     mCore->mQueue.clear();
     mCore->freeAllBuffersLocked();
-    mCore->mSingleBufferSlot = BufferQueueCore::INVALID_BUFFER_SLOT;
+    mCore->mSharedBufferSlot = BufferQueueCore::INVALID_BUFFER_SLOT;
     mCore->mDequeueCondition.broadcast();
     return NO_ERROR;
 }

diff --git a/libs/gui/BufferQueueCore.cpp b/libs/gui/BufferQueueCore.cpp
index ba07362..cdece73 100644 (file)
--- a/libs/gui/BufferQueueCore.cpp
+++ b/libs/gui/BufferQueueCore.cpp
@@ -78,10 +78,10 @@ BufferQueueCore::BufferQueueCore(const sp<IGraphicBufferAlloc>& allocator) :
     mBufferAge(0),
     mGenerationNumber(0),
     mAsyncMode(false),
-    mSingleBufferMode(false),
+    mSharedBufferMode(false),
     mAutoRefresh(false),
-    mSingleBufferSlot(INVALID_BUFFER_SLOT),
-    mSingleBufferCache(Rect::INVALID_RECT, 0, NATIVE_WINDOW_SCALING_MODE_FREEZE,
+    mSharedBufferSlot(INVALID_BUFFER_SLOT),
+    mSharedBufferCache(Rect::INVALID_RECT, 0, NATIVE_WINDOW_SCALING_MODE_FREEZE,
             HAL_DATASPACE_UNKNOWN)
 {
     if (allocator == NULL) {

diff --git a/libs/gui/BufferQueueProducer.cpp b/libs/gui/BufferQueueProducer.cpp
index 4fd8b89..bb8d39b 100644 (file)
--- a/libs/gui/BufferQueueProducer.cpp
+++ b/libs/gui/BufferQueueProducer.cpp
@@ -272,11 +272,11 @@ status_t BufferQueueProducer::waitForFreeSlotThenRelock(FreeSlotCaller caller,
             BQ_LOGV("%s: queue size is %zu, waiting", callerString,
                     mCore->mQueue.size());
         } else {
-            // If in single buffer mode and a shared buffer exists, always
+            // If in shared buffer mode and a shared buffer exists, always
             // return it.
-            if (mCore->mSingleBufferMode && mCore->mSingleBufferSlot !=
+            if (mCore->mSharedBufferMode && mCore->mSharedBufferSlot !=
                     BufferQueueCore::INVALID_BUFFER_SLOT) {
-                *found = mCore->mSingleBufferSlot;
+                *found = mCore->mSharedBufferSlot;
             } else {
                 if (caller == FreeSlotCaller::Dequeue) {
                     // If we're calling this from dequeue, prefer free buffers
@@ -400,7 +400,7 @@ status_t BufferQueueProducer::dequeueBuffer(int *outSlot,
             // requested attributes, we free it and attempt to get another one.
             if (!mCore->mAllowAllocation) {
                 if (buffer->needsReallocation(width, height, format, usage)) {
-                    if (mCore->mSingleBufferSlot == found) {
+                    if (mCore->mSharedBufferSlot == found) {
                         BQ_LOGE("dequeueBuffer: cannot re-allocate a shared"
                                 "buffer");
                         return BAD_VALUE;
@@ -414,7 +414,7 @@ status_t BufferQueueProducer::dequeueBuffer(int *outSlot,
         }
 
         const sp<GraphicBuffer>& buffer(mSlots[found].mGraphicBuffer);
-        if (mCore->mSingleBufferSlot == found &&
+        if (mCore->mSharedBufferSlot == found &&
                 buffer->needsReallocation(width,  height, format, usage)) {
             BQ_LOGE("dequeueBuffer: cannot re-allocate a shared"
                     "buffer");
@@ -422,7 +422,7 @@ status_t BufferQueueProducer::dequeueBuffer(int *outSlot,
             return BAD_VALUE;
         }
 
-        if (mCore->mSingleBufferSlot != found) {
+        if (mCore->mSharedBufferSlot != found) {
             mCore->mActiveBuffers.insert(found);
         }
         *outSlot = found;
@@ -433,11 +433,11 @@ status_t BufferQueueProducer::dequeueBuffer(int *outSlot,
 
         mSlots[found].mBufferState.dequeue();
 
-        // If single buffer mode has just been enabled, cache the slot of the
+        // If shared buffer mode has just been enabled, cache the slot of the
         // first buffer that is dequeued and mark it as the shared buffer.
-        if (mCore->mSingleBufferMode && mCore->mSingleBufferSlot ==
+        if (mCore->mSharedBufferMode && mCore->mSharedBufferSlot ==
                 BufferQueueCore::INVALID_BUFFER_SLOT) {
-            mCore->mSingleBufferSlot = found;
+            mCore->mSharedBufferSlot = found;
             mSlots[found].mBufferState.mShared = true;
         }
 
@@ -550,8 +550,8 @@ status_t BufferQueueProducer::detachBuffer(int slot) {
         return NO_INIT;
     }
 
-    if (mCore->mSingleBufferMode || mCore->mSingleBufferSlot == slot) {
-        BQ_LOGE("detachBuffer: cannot detach a buffer in single buffer mode");
+    if (mCore->mSharedBufferMode || mCore->mSharedBufferSlot == slot) {
+        BQ_LOGE("detachBuffer: cannot detach a buffer in shared buffer mode");
         return BAD_VALUE;
     }
 
@@ -603,9 +603,9 @@ status_t BufferQueueProducer::detachNextBuffer(sp<GraphicBuffer>* outBuffer,
         return NO_INIT;
     }
 
-    if (mCore->mSingleBufferMode) {
-        BQ_LOGE("detachNextBuffer: cannot detach a buffer in single buffer"
-                "mode");
+    if (mCore->mSharedBufferMode) {
+        BQ_LOGE("detachNextBuffer: cannot detach a buffer in shared buffer "
+            "mode");
         return BAD_VALUE;
     }
 
@@ -653,8 +653,8 @@ status_t BufferQueueProducer::attachBuffer(int* outSlot,
         return NO_INIT;
     }
 
-    if (mCore->mSingleBufferMode) {
-        BQ_LOGE("attachBuffer: cannot attach a buffer in single buffer mode");
+    if (mCore->mSharedBufferMode) {
+        BQ_LOGE("attachBuffer: cannot attach a buffer in shared buffer mode");
         return BAD_VALUE;
     }
 
@@ -761,11 +761,11 @@ status_t BufferQueueProducer::queueBuffer(int slot,
             return BAD_VALUE;
         }
 
-        // If single buffer mode has just been enabled, cache the slot of the
+        // If shared buffer mode has just been enabled, cache the slot of the
         // first buffer that is queued and mark it as the shared buffer.
-        if (mCore->mSingleBufferMode && mCore->mSingleBufferSlot ==
+        if (mCore->mSharedBufferMode && mCore->mSharedBufferSlot ==
                 BufferQueueCore::INVALID_BUFFER_SLOT) {
-            mCore->mSingleBufferSlot = slot;
+            mCore->mSharedBufferSlot = slot;
             mSlots[slot].mBufferState.mShared = true;
         }
 
@@ -812,20 +812,20 @@ status_t BufferQueueProducer::queueBuffer(int slot,
         item.mFence = fence;
         item.mIsDroppable = mCore->mAsyncMode ||
                 mCore->mDequeueBufferCannotBlock ||
-                (mCore->mSingleBufferMode && mCore->mSingleBufferSlot == slot);
+                (mCore->mSharedBufferMode && mCore->mSharedBufferSlot == slot);
         item.mSurfaceDamage = surfaceDamage;
         item.mQueuedBuffer = true;
-        item.mAutoRefresh = mCore->mSingleBufferMode && mCore->mAutoRefresh;
+        item.mAutoRefresh = mCore->mSharedBufferMode && mCore->mAutoRefresh;
 
         mStickyTransform = stickyTransform;
 
         // Cache the shared buffer data so that the BufferItem can be recreated.
-        if (mCore->mSingleBufferMode) {
-            mCore->mSingleBufferCache.crop = crop;
-            mCore->mSingleBufferCache.transform = transform;
-            mCore->mSingleBufferCache.scalingMode = static_cast<uint32_t>(
+        if (mCore->mSharedBufferMode) {
+            mCore->mSharedBufferCache.crop = crop;
+            mCore->mSharedBufferCache.transform = transform;
+            mCore->mSharedBufferCache.scalingMode = static_cast<uint32_t>(
                     scalingMode);
-            mCore->mSingleBufferCache.dataspace = dataSpace;
+            mCore->mSharedBufferCache.dataspace = dataSpace;
         }
 
         if (mCore->mQueue.empty()) {
@@ -842,10 +842,10 @@ status_t BufferQueueProducer::queueBuffer(int slot,
                 if (!front->mIsStale) {
                     mSlots[front->mSlot].mBufferState.freeQueued();
 
-                    // After leaving single buffer mode, the shared buffer will
+                    // After leaving shared buffer mode, the shared buffer will
                     // still be around. Mark it as no longer shared if this
                     // operation causes it to be free.
-                    if (!mCore->mSingleBufferMode &&
+                    if (!mCore->mSharedBufferMode &&
                             mSlots[front->mSlot].mBufferState.isFree()) {
                         mSlots[front->mSlot].mBufferState.mShared = false;
                     }
@@ -930,8 +930,8 @@ status_t BufferQueueProducer::cancelBuffer(int slot, const sp<Fence>& fence) {
         return NO_INIT;
     }
 
-    if (mCore->mSingleBufferMode) {
-        BQ_LOGE("cancelBuffer: cannot cancel a buffer in single buffer mode");
+    if (mCore->mSharedBufferMode) {
+        BQ_LOGE("cancelBuffer: cannot cancel a buffer in shared buffer mode");
         return BAD_VALUE;
     }
 
@@ -950,9 +950,9 @@ status_t BufferQueueProducer::cancelBuffer(int slot, const sp<Fence>& fence) {
 
     mSlots[slot].mBufferState.cancel();
 
-    // After leaving single buffer mode, the shared buffer will still be around.
+    // After leaving shared buffer mode, the shared buffer will still be around.
     // Mark it as no longer shared if this operation causes it to be free.
-    if (!mCore->mSingleBufferMode && mSlots[slot].mBufferState.isFree()) {
+    if (!mCore->mSharedBufferMode && mSlots[slot].mBufferState.isFree()) {
         mSlots[slot].mBufferState.mShared = false;
     }
 
@@ -1149,7 +1149,7 @@ status_t BufferQueueProducer::disconnect(int api) {
                         token->unlinkToDeath(
                                 static_cast<IBinder::DeathRecipient*>(this));
                     }
-                    mCore->mSingleBufferSlot =
+                    mCore->mSharedBufferSlot =
                             BufferQueueCore::INVALID_BUFFER_SLOT;
                     mCore->mConnectedProducerListener = NULL;
                     mCore->mConnectedApi = BufferQueueCore::NO_CONNECTED_API;
@@ -1314,15 +1314,15 @@ uint64_t BufferQueueProducer::getNextFrameNumber() const {
     return nextFrameNumber;
 }
 
-status_t BufferQueueProducer::setSingleBufferMode(bool singleBufferMode) {
+status_t BufferQueueProducer::setSharedBufferMode(bool sharedBufferMode) {
     ATRACE_CALL();
-    BQ_LOGV("setSingleBufferMode: %d", singleBufferMode);
+    BQ_LOGV("setSharedBufferMode: %d", sharedBufferMode);
 
     Mutex::Autolock lock(mCore->mMutex);
-    if (!singleBufferMode) {
-        mCore->mSingleBufferSlot = BufferQueueCore::INVALID_BUFFER_SLOT;
+    if (!sharedBufferMode) {
+        mCore->mSharedBufferSlot = BufferQueueCore::INVALID_BUFFER_SLOT;
     }
-    mCore->mSingleBufferMode = singleBufferMode;
+    mCore->mSharedBufferMode = sharedBufferMode;
     return NO_ERROR;
 }
 

diff --git a/libs/gui/GLConsumer.cpp b/libs/gui/GLConsumer.cpp
index 149f5bd..7ef18a8 100644 (file)
--- a/libs/gui/GLConsumer.cpp
+++ b/libs/gui/GLConsumer.cpp
@@ -427,7 +427,7 @@ status_t GLConsumer::updateAndReleaseLocked(const BufferItem& item,
             slot, mSlots[slot].mGraphicBuffer->handle);
 
     // Hang onto the pointer so that it isn't freed in the call to
-    // releaseBufferLocked() if we're in single buffer mode and both buffers are
+    // releaseBufferLocked() if we're in shared buffer mode and both buffers are
     // the same.
     sp<EglImage> nextTextureImage = mEglSlots[slot].mEglImage;
 

diff --git a/libs/gui/IGraphicBufferProducer.cpp b/libs/gui/IGraphicBufferProducer.cpp
index c66694d..e574743 100644 (file)
--- a/libs/gui/IGraphicBufferProducer.cpp
+++ b/libs/gui/IGraphicBufferProducer.cpp
@@ -51,7 +51,7 @@ enum {
     SET_MAX_DEQUEUED_BUFFER_COUNT,
     SET_ASYNC_MODE,
     GET_NEXT_FRAME_NUMBER,
-    SET_SINGLE_BUFFER_MODE,
+    SET_SHARED_BUFFER_MODE,
     SET_AUTO_REFRESH,
     SET_DEQUEUE_TIMEOUT,
 };
@@ -343,12 +343,12 @@ public:
         return frameNumber;
     }
 
-    virtual status_t setSingleBufferMode(bool singleBufferMode) {
+    virtual status_t setSharedBufferMode(bool sharedBufferMode) {
         Parcel data, reply;
         data.writeInterfaceToken(
                 IGraphicBufferProducer::getInterfaceDescriptor());
-        data.writeInt32(singleBufferMode);
-        status_t result = remote()->transact(SET_SINGLE_BUFFER_MODE, data,
+        data.writeInt32(sharedBufferMode);
+        status_t result = remote()->transact(SET_SHARED_BUFFER_MODE, data,
                 &reply);
         if (result == NO_ERROR) {
             result = reply.readInt32();
@@ -568,10 +568,10 @@ status_t BnGraphicBufferProducer::onTransact(
             reply->writeUint64(frameNumber);
             return NO_ERROR;
         }
-        case SET_SINGLE_BUFFER_MODE: {
+        case SET_SHARED_BUFFER_MODE: {
             CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
-            bool singleBufferMode = data.readInt32();
-            status_t result = setSingleBufferMode(singleBufferMode);
+            bool sharedBufferMode = data.readInt32();
+            status_t result = setSharedBufferMode(sharedBufferMode);
             reply->writeInt32(result);
             return NO_ERROR;
         }

diff --git a/libs/gui/Surface.cpp b/libs/gui/Surface.cpp
index 8025ca5..76b62f1 100644 (file)
--- a/libs/gui/Surface.cpp
+++ b/libs/gui/Surface.cpp
@@ -45,7 +45,7 @@ Surface::Surface(
     : mGraphicBufferProducer(bufferProducer),
       mCrop(Rect::EMPTY_RECT),
       mGenerationNumber(0),
-      mSingleBufferMode(false),
+      mSharedBufferMode(false),
       mAutoRefresh(false),
       mSharedBufferSlot(BufferItem::INVALID_BUFFER_SLOT),
       mSharedBufferHasBeenQueued(false)
@@ -237,7 +237,7 @@ int Surface::dequeueBuffer(android_native_buffer_t** buffer, int* fenceFd) {
         reqFormat = mReqFormat;
         reqUsage = mReqUsage;
 
-        if (mSingleBufferMode && mAutoRefresh && mSharedBufferSlot !=
+        if (mSharedBufferMode && mAutoRefresh && mSharedBufferSlot !=
                 BufferItem::INVALID_BUFFER_SLOT) {
             sp<GraphicBuffer>& gbuf(mSlots[mSharedBufferSlot].buffer);
             if (gbuf != NULL) {
@@ -294,7 +294,7 @@ int Surface::dequeueBuffer(android_native_buffer_t** buffer, int* fenceFd) {
 
     *buffer = gbuf.get();
 
-    if (mSingleBufferMode && mAutoRefresh) {
+    if (mSharedBufferMode && mAutoRefresh) {
         mSharedBufferSlot = buf;
         mSharedBufferHasBeenQueued = false;
     } else if (mSharedBufferSlot == buf) {
@@ -326,7 +326,7 @@ int Surface::cancelBuffer(android_native_buffer_t* buffer,
     sp<Fence> fence(fenceFd >= 0 ? new Fence(fenceFd) : Fence::NO_FENCE);
     mGraphicBufferProducer->cancelBuffer(i, fence);
 
-    if (mSingleBufferMode && mAutoRefresh && mSharedBufferSlot == i) {
+    if (mSharedBufferMode && mAutoRefresh && mSharedBufferSlot == i) {
         mSharedBufferHasBeenQueued = true;
     }
 
@@ -476,7 +476,7 @@ int Surface::queueBuffer(android_native_buffer_t* buffer, int fenceFd) {
         mDirtyRegion = Region::INVALID_REGION;
     }
 
-    if (mSingleBufferMode && mAutoRefresh && mSharedBufferSlot == i) {
+    if (mSharedBufferMode && mAutoRefresh && mSharedBufferSlot == i) {
         mSharedBufferHasBeenQueued = true;
     }
 
@@ -600,8 +600,8 @@ int Surface::perform(int operation, va_list args)
     case NATIVE_WINDOW_SET_SURFACE_DAMAGE:
         res = dispatchSetSurfaceDamage(args);
         break;
-    case NATIVE_WINDOW_SET_SINGLE_BUFFER_MODE:
-        res = dispatchSetSingleBufferMode(args);
+    case NATIVE_WINDOW_SET_SHARED_BUFFER_MODE:
+        res = dispatchSetSharedBufferMode(args);
         break;
     case NATIVE_WINDOW_SET_AUTO_REFRESH:
         res = dispatchSetAutoRefresh(args);
@@ -716,9 +716,9 @@ int Surface::dispatchSetSurfaceDamage(va_list args) {
     return NO_ERROR;
 }
 
-int Surface::dispatchSetSingleBufferMode(va_list args) {
-    bool singleBufferMode = va_arg(args, int);
-    return setSingleBufferMode(singleBufferMode);
+int Surface::dispatchSetSharedBufferMode(va_list args) {
+    bool sharedBufferMode = va_arg(args, int);
+    return setSharedBufferMode(sharedBufferMode);
 }
 
 int Surface::dispatchSetAutoRefresh(va_list args) {
@@ -927,18 +927,18 @@ int Surface::setAsyncMode(bool async) {
     return err;
 }
 
-int Surface::setSingleBufferMode(bool singleBufferMode) {
+int Surface::setSharedBufferMode(bool sharedBufferMode) {
     ATRACE_CALL();
-    ALOGV("Surface::setSingleBufferMode (%d)", singleBufferMode);
+    ALOGV("Surface::setSharedBufferMode (%d)", sharedBufferMode);
     Mutex::Autolock lock(mMutex);
 
-    status_t err = mGraphicBufferProducer->setSingleBufferMode(
-            singleBufferMode);
+    status_t err = mGraphicBufferProducer->setSharedBufferMode(
+            sharedBufferMode);
     if (err == NO_ERROR) {
-        mSingleBufferMode = singleBufferMode;
+        mSharedBufferMode = sharedBufferMode;
     }
-    ALOGE_IF(err, "IGraphicBufferProducer::setSingleBufferMode(%d) returned"
-            "%s", singleBufferMode, strerror(-err));
+    ALOGE_IF(err, "IGraphicBufferProducer::setSharedBufferMode(%d) returned"
+            "%s", sharedBufferMode, strerror(-err));
 
     return err;
 }

diff --git a/libs/gui/tests/BufferQueue_test.cpp b/libs/gui/tests/BufferQueue_test.cpp
index 7790762..82df9a9 100644 (file)
--- a/libs/gui/tests/BufferQueue_test.cpp
+++ b/libs/gui/tests/BufferQueue_test.cpp
@@ -291,7 +291,7 @@ TEST_F(BufferQueueTest, SetMaxBufferCountWithLegalValues_Succeeds) {
     sp<DummyConsumer> dc(new DummyConsumer);
     mConsumer->consumerConnect(dc, false);
 
-    // Test single buffer mode
+    // Test shared buffer mode
     EXPECT_EQ(OK, mConsumer->setMaxAcquiredBufferCount(1));
 }
 
@@ -542,7 +542,7 @@ TEST_F(BufferQueueTest, TestGenerationNumbers) {
     ASSERT_EQ(OK, mConsumer->attachBuffer(&outSlot, buffer));
 }
 
-TEST_F(BufferQueueTest, TestSingleBufferModeWithoutAutoRefresh) {
+TEST_F(BufferQueueTest, TestSharedBufferModeWithoutAutoRefresh) {
     createBufferQueue();
     sp<DummyConsumer> dc(new DummyConsumer);
     ASSERT_EQ(OK, mConsumer->consumerConnect(dc, true));
@@ -550,21 +550,21 @@ TEST_F(BufferQueueTest, TestSingleBufferModeWithoutAutoRefresh) {
     ASSERT_EQ(OK, mProducer->connect(new DummyProducerListener,
             NATIVE_WINDOW_API_CPU, true, &output));
 
-    ASSERT_EQ(OK, mProducer->setSingleBufferMode(true));
+    ASSERT_EQ(OK, mProducer->setSharedBufferMode(true));
 
     // Get a buffer
-    int singleSlot;
+    int sharedSlot;
     sp<Fence> fence;
     sp<GraphicBuffer> buffer;
     ASSERT_EQ(IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION,
-            mProducer->dequeueBuffer(&singleSlot, &fence, 0, 0, 0, 0));
-    ASSERT_EQ(OK, mProducer->requestBuffer(singleSlot, &buffer));
+            mProducer->dequeueBuffer(&sharedSlot, &fence, 0, 0, 0, 0));
+    ASSERT_EQ(OK, mProducer->requestBuffer(sharedSlot, &buffer));
 
     // Queue the buffer
     IGraphicBufferProducer::QueueBufferInput input(0, false,
             HAL_DATASPACE_UNKNOWN, Rect(0, 0, 1, 1),
             NATIVE_WINDOW_SCALING_MODE_FREEZE, 0, Fence::NO_FENCE);
-    ASSERT_EQ(OK, mProducer->queueBuffer(singleSlot, input, &output));
+    ASSERT_EQ(OK, mProducer->queueBuffer(sharedSlot, input, &output));
 
     // Repeatedly queue and dequeue a buffer from the producer side, it should
     // always return the same one. And we won't run out of buffers because it's
@@ -572,14 +572,14 @@ TEST_F(BufferQueueTest, TestSingleBufferModeWithoutAutoRefresh) {
     int slot;
     for (int i = 0; i < 5; i++) {
         ASSERT_EQ(OK, mProducer->dequeueBuffer(&slot, &fence, 0, 0, 0, 0));
-        ASSERT_EQ(singleSlot, slot);
-        ASSERT_EQ(OK, mProducer->queueBuffer(singleSlot, input, &output));
+        ASSERT_EQ(sharedSlot, slot);
+        ASSERT_EQ(OK, mProducer->queueBuffer(sharedSlot, input, &output));
     }
 
     // acquire the buffer
     BufferItem item;
     ASSERT_EQ(OK, mConsumer->acquireBuffer(&item, 0));
-    ASSERT_EQ(singleSlot, item.mSlot);
+    ASSERT_EQ(sharedSlot, item.mSlot);
     testBufferItem(input, item);
     ASSERT_EQ(true, item.mQueuedBuffer);
     ASSERT_EQ(false, item.mAutoRefresh);
@@ -592,7 +592,7 @@ TEST_F(BufferQueueTest, TestSingleBufferModeWithoutAutoRefresh) {
             mConsumer->acquireBuffer(&item, 0));
 }
 
-TEST_F(BufferQueueTest, TestSingleBufferModeWithAutoRefresh) {
+TEST_F(BufferQueueTest, TestSharedBufferModeWithAutoRefresh) {
     createBufferQueue();
     sp<DummyConsumer> dc(new DummyConsumer);
     ASSERT_EQ(OK, mConsumer->consumerConnect(dc, true));
@@ -600,29 +600,29 @@ TEST_F(BufferQueueTest, TestSingleBufferModeWithAutoRefresh) {
     ASSERT_EQ(OK, mProducer->connect(new DummyProducerListener,
             NATIVE_WINDOW_API_CPU, true, &output));
 
-    ASSERT_EQ(OK, mProducer->setSingleBufferMode(true));
+    ASSERT_EQ(OK, mProducer->setSharedBufferMode(true));
     ASSERT_EQ(OK, mProducer->setAutoRefresh(true));
 
     // Get a buffer
-    int singleSlot;
+    int sharedSlot;
     sp<Fence> fence;
     sp<GraphicBuffer> buffer;
     ASSERT_EQ(IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION,
-            mProducer->dequeueBuffer(&singleSlot, &fence, 0, 0, 0, 0));
-    ASSERT_EQ(OK, mProducer->requestBuffer(singleSlot, &buffer));
+            mProducer->dequeueBuffer(&sharedSlot, &fence, 0, 0, 0, 0));
+    ASSERT_EQ(OK, mProducer->requestBuffer(sharedSlot, &buffer));
 
     // Queue the buffer
     IGraphicBufferProducer::QueueBufferInput input(0, false,
             HAL_DATASPACE_UNKNOWN, Rect(0, 0, 1, 1),
             NATIVE_WINDOW_SCALING_MODE_FREEZE, 0, Fence::NO_FENCE);
-    ASSERT_EQ(OK, mProducer->queueBuffer(singleSlot, input, &output));
+    ASSERT_EQ(OK, mProducer->queueBuffer(sharedSlot, input, &output));
 
     // Repeatedly acquire and release a buffer from the consumer side, it should
     // always return the same one.
     BufferItem item;
     for (int i = 0; i < 5; i++) {
         ASSERT_EQ(OK, mConsumer->acquireBuffer(&item, 0));
-        ASSERT_EQ(singleSlot, item.mSlot);
+        ASSERT_EQ(sharedSlot, item.mSlot);
         testBufferItem(input, item);
         ASSERT_EQ(i == 0, item.mQueuedBuffer);
         ASSERT_EQ(true, item.mAutoRefresh);
@@ -636,16 +636,16 @@ TEST_F(BufferQueueTest, TestSingleBufferModeWithAutoRefresh) {
     int slot;
     for (int i = 0; i < 5; i++) {
         ASSERT_EQ(OK, mProducer->dequeueBuffer(&slot, &fence, 0, 0, 0, 0));
-        ASSERT_EQ(singleSlot, slot);
-        ASSERT_EQ(OK, mProducer->queueBuffer(singleSlot, input, &output));
+        ASSERT_EQ(sharedSlot, slot);
+        ASSERT_EQ(OK, mProducer->queueBuffer(sharedSlot, input, &output));
     }
 
     // Repeatedly acquire and release a buffer from the consumer side, it should
     // always return the same one. First grabbing them from the queue and then
-    // when the queue is empty, returning the single buffer.
+    // when the queue is empty, returning the shared buffer.
     for (int i = 0; i < 10; i++) {
         ASSERT_EQ(OK, mConsumer->acquireBuffer(&item, 0));
-        ASSERT_EQ(singleSlot, item.mSlot);
+        ASSERT_EQ(sharedSlot, item.mSlot);
         ASSERT_EQ(0, item.mTimestamp);
         ASSERT_EQ(false, item.mIsAutoTimestamp);
         ASSERT_EQ(HAL_DATASPACE_UNKNOWN, item.mDataSpace);
@@ -661,7 +661,7 @@ TEST_F(BufferQueueTest, TestSingleBufferModeWithAutoRefresh) {
     }
 }
 
-TEST_F(BufferQueueTest, TestSingleBufferModeUsingAlreadyDequeuedBuffer) {
+TEST_F(BufferQueueTest, TestSharedBufferModeUsingAlreadyDequeuedBuffer) {
     createBufferQueue();
     sp<DummyConsumer> dc(new DummyConsumer);
     ASSERT_EQ(OK, mConsumer->consumerConnect(dc, true));
@@ -670,21 +670,21 @@ TEST_F(BufferQueueTest, TestSingleBufferModeUsingAlreadyDequeuedBuffer) {
             NATIVE_WINDOW_API_CPU, true, &output));
 
     // Dequeue a buffer
-    int singleSlot;
+    int sharedSlot;
     sp<Fence> fence;
     sp<GraphicBuffer> buffer;
     ASSERT_EQ(IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION,
-            mProducer->dequeueBuffer(&singleSlot, &fence, 0, 0, 0, 0));
-    ASSERT_EQ(OK, mProducer->requestBuffer(singleSlot, &buffer));
+            mProducer->dequeueBuffer(&sharedSlot, &fence, 0, 0, 0, 0));
+    ASSERT_EQ(OK, mProducer->requestBuffer(sharedSlot, &buffer));
 
-    // Enable single buffer mode
-    ASSERT_EQ(OK, mProducer->setSingleBufferMode(true));
+    // Enable shared buffer mode
+    ASSERT_EQ(OK, mProducer->setSharedBufferMode(true));
 
     // Queue the buffer
     IGraphicBufferProducer::QueueBufferInput input(0, false,
             HAL_DATASPACE_UNKNOWN, Rect(0, 0, 1, 1),
             NATIVE_WINDOW_SCALING_MODE_FREEZE, 0, Fence::NO_FENCE);
-    ASSERT_EQ(OK, mProducer->queueBuffer(singleSlot, input, &output));
+    ASSERT_EQ(OK, mProducer->queueBuffer(sharedSlot, input, &output));
 
     // Repeatedly queue and dequeue a buffer from the producer side, it should
     // always return the same one. And we won't run out of buffers because it's
@@ -692,14 +692,14 @@ TEST_F(BufferQueueTest, TestSingleBufferModeUsingAlreadyDequeuedBuffer) {
     int slot;
     for (int i = 0; i < 5; i++) {
         ASSERT_EQ(OK, mProducer->dequeueBuffer(&slot, &fence, 0, 0, 0, 0));
-        ASSERT_EQ(singleSlot, slot);
-        ASSERT_EQ(OK, mProducer->queueBuffer(singleSlot, input, &output));
+        ASSERT_EQ(sharedSlot, slot);
+        ASSERT_EQ(OK, mProducer->queueBuffer(sharedSlot, input, &output));
     }
 
     // acquire the buffer
     BufferItem item;
     ASSERT_EQ(OK, mConsumer->acquireBuffer(&item, 0));
-    ASSERT_EQ(singleSlot, item.mSlot);
+    ASSERT_EQ(sharedSlot, item.mSlot);
     testBufferItem(input, item);
     ASSERT_EQ(true, item.mQueuedBuffer);
     ASSERT_EQ(false, item.mAutoRefresh);

diff --git a/services/surfaceflinger/DisplayHardware/VirtualDisplaySurface.cpp b/services/surfaceflinger/DisplayHardware/VirtualDisplaySurface.cpp
index 1afed36..fc73979 100644 (file)
--- a/services/surfaceflinger/DisplayHardware/VirtualDisplaySurface.cpp
+++ b/services/surfaceflinger/DisplayHardware/VirtualDisplaySurface.cpp
@@ -592,8 +592,8 @@ uint64_t VirtualDisplaySurface::getNextFrameNumber() const {
     return 0;
 }
 
-status_t VirtualDisplaySurface::setSingleBufferMode(bool /*singleBufferMode*/) {
-    ALOGE("setSingleBufferMode not supported on VirtualDisplaySurface");
+status_t VirtualDisplaySurface::setSharedBufferMode(bool /*sharedBufferMode*/) {
+    ALOGE("setSharedBufferMode not supported on VirtualDisplaySurface");
     return INVALID_OPERATION;
 }
 

diff --git a/services/surfaceflinger/DisplayHardware/VirtualDisplaySurface.h b/services/surfaceflinger/DisplayHardware/VirtualDisplaySurface.h
index fe187c2..9fd845d 100644 (file)
--- a/services/surfaceflinger/DisplayHardware/VirtualDisplaySurface.h
+++ b/services/surfaceflinger/DisplayHardware/VirtualDisplaySurface.h
@@ -125,7 +125,7 @@ private:
     virtual status_t setGenerationNumber(uint32_t generationNumber);
     virtual String8 getConsumerName() const override;
     virtual uint64_t getNextFrameNumber() const override;
-    virtual status_t setSingleBufferMode(bool singleBufferMode) override;
+    virtual status_t setSharedBufferMode(bool sharedBufferMode) override;
     virtual status_t setAutoRefresh(bool autoRefresh) override;
     virtual status_t setDequeueTimeout(nsecs_t timeout) override;
 

diff --git a/services/surfaceflinger/Layer.cpp b/services/surfaceflinger/Layer.cpp
index 42d0810..3ebbffd 100644 (file)
--- a/services/surfaceflinger/Layer.cpp
+++ b/services/surfaceflinger/Layer.cpp
@@ -1799,7 +1799,7 @@ Region Layer::latchBuffer(bool& recomputeVisibleRegions)
 
         // This boolean is used to make sure that SurfaceFlinger's shadow copy
         // of the buffer queue isn't modified when the buffer queue is returning
-        // BufferItem's that weren't actually queued. This can happen in single
+        // BufferItem's that weren't actually queued. This can happen in shared
         // buffer mode.
         bool queuedBuffer = false;
         status_t updateResult = mSurfaceFlingerConsumer->updateTexImage(&r,

diff --git a/services/surfaceflinger/MonitoredProducer.cpp b/services/surfaceflinger/MonitoredProducer.cpp
index e161d9f..75559da 100644 (file)
--- a/services/surfaceflinger/MonitoredProducer.cpp
+++ b/services/surfaceflinger/MonitoredProducer.cpp
@@ -131,8 +131,8 @@ uint64_t MonitoredProducer::getNextFrameNumber() const {
     return mProducer->getNextFrameNumber();
 }
 
-status_t MonitoredProducer::setSingleBufferMode(bool singleBufferMode) {
-    return mProducer->setSingleBufferMode(singleBufferMode);
+status_t MonitoredProducer::setSharedBufferMode(bool sharedBufferMode) {
+    return mProducer->setSharedBufferMode(sharedBufferMode);
 }
 
 status_t MonitoredProducer::setAutoRefresh(bool autoRefresh) {

diff --git a/services/surfaceflinger/MonitoredProducer.h b/services/surfaceflinger/MonitoredProducer.h
index 35ce558..441cf50 100644 (file)
--- a/services/surfaceflinger/MonitoredProducer.h
+++ b/services/surfaceflinger/MonitoredProducer.h
@@ -60,7 +60,7 @@ public:
     virtual uint64_t getNextFrameNumber() const override;
     virtual status_t setDequeueTimeout(nsecs_t timeout) override;
     virtual IBinder* onAsBinder();
-    virtual status_t setSingleBufferMode(bool singleBufferMode) override;
+    virtual status_t setSharedBufferMode(bool sharedBufferMode) override;
     virtual status_t setAutoRefresh(bool autoRefresh) override;
 
 private: