1 /*
2  * Copyright (C) 2018 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 #pragma once
18 
19 #include "BufferLayer.h"
20 
21 #include <utils/String8.h>
22 
23 namespace android {
24 
25 namespace frametimeline {
26 class SurfaceFrame;
27 }
28 
29 /*
30  * A new BufferQueue and a new BufferLayerConsumer are created when the
31  * BufferLayer is first referenced.
32  *
33  * This also implements onFrameAvailable(), which notifies SurfaceFlinger
34  * that new data has arrived.
35  */
36 class BufferQueueLayer : public BufferLayer {
37 public:
38     // Only call while mStateLock is held
39     explicit BufferQueueLayer(const LayerCreationArgs&);
40     ~BufferQueueLayer() override;
41 
42     // Implements Layer.
getType()43     const char* getType() const override { return "BufferQueueLayer"; }
44 
45     void onLayerDisplayed(const sp<Fence>& releaseFence) override;
46 
47     std::vector<OccupancyTracker::Segment> getOccupancyHistory(bool forceFlush) override;
48 
49     // If a buffer was replaced this frame, release the former buffer
50     void releasePendingBuffer(nsecs_t dequeueReadyTime) override;
51 
52     void setDefaultBufferSize(uint32_t w, uint32_t h) override;
53 
54     int32_t getQueuedFrameCount() const override;
55 
56     // Returns true if the next buffer should be presented at the expected present time
57     bool isBufferDue(nsecs_t expectedPresentTime) const override;
58 
59     // Implements BufferLayer.
60     bool fenceHasSignaled() const override;
61     bool framePresentTimeIsCurrent(nsecs_t expectedPresentTime) const override;
62 
63     status_t setDefaultBufferProperties(uint32_t w, uint32_t h, PixelFormat format);
64     sp<IGraphicBufferProducer> getProducer() const;
65 
66 protected:
67     void gatherBufferInfo() override;
68 
69     // -----------------------------------------------------------------------
70     // Interface implementation for BufferLayerConsumer::ContentsChangedListener
71     // -----------------------------------------------------------------------
72     class ContentsChangedListener : public BufferLayerConsumer::ContentsChangedListener {
73     public:
ContentsChangedListener(BufferQueueLayer * bufferQueueLayer)74         ContentsChangedListener(BufferQueueLayer* bufferQueueLayer)
75               : mBufferQueueLayer(bufferQueueLayer) {}
76         void abandon();
77 
78     protected:
79         void onFrameAvailable(const BufferItem& item) override;
80         void onFrameReplaced(const BufferItem& item) override;
81         void onSidebandStreamChanged() override;
82         void onFrameDequeued(const uint64_t bufferId) override;
83         void onFrameDetached(const uint64_t bufferId) override;
84         void onFrameCancelled(const uint64_t bufferId) override;
85 
86     private:
87         BufferQueueLayer* mBufferQueueLayer = nullptr;
88         Mutex mMutex;
89     };
90 
91 private:
92     uint64_t getFrameNumber(nsecs_t expectedPresentTime) const override;
93 
94     bool latchSidebandStream(bool& recomputeVisibleRegions) override;
95     void setTransformHint(ui::Transform::RotationFlags displayTransformHint) override;
96 
97     bool hasFrameUpdate() const override;
98 
99     status_t updateTexImage(bool& recomputeVisibleRegions, nsecs_t latchTime,
100                             nsecs_t expectedPresentTime) override;
101 
102     status_t updateActiveBuffer() override;
103     status_t updateFrameNumber(nsecs_t latchTime) override;
104     void setFrameTimelineInfoForBuffer(const FrameTimelineInfo& frameTimelineInfo) override;
105 
106     sp<Layer> createClone() override;
107 
108     void onFirstRef() override;
109 
110     void onFrameAvailable(const BufferItem& item);
111     void onFrameReplaced(const BufferItem& item);
112     void onSidebandStreamChanged();
113     void onFrameDequeued(const uint64_t bufferId);
114     void onFrameDetached(const uint64_t bufferId);
115     void onFrameCancelled(const uint64_t bufferId);
116 
117     // Temporary - Used only for LEGACY camera mode.
118     uint32_t getProducerStickyTransform() const;
119 
120     sp<BufferLayerConsumer> mConsumer;
121     sp<IGraphicBufferProducer> mProducer;
122 
123     bool mUpdateTexImageFailed{false};
124 
125     uint64_t mPreviousBufferId = 0;
126     uint64_t mPreviousReleasedFrameNumber = 0;
127 
128     // Local copy of the queued contents of the incoming BufferQueue
129     mutable Mutex mQueueItemLock;
130     Condition mQueueItemCondition;
131 
132     struct BufferData {
BufferDataBufferData133         BufferData(BufferItem item, std::shared_ptr<frametimeline::SurfaceFrame> surfaceFrame)
134               : item(item), surfaceFrame(surfaceFrame) {}
135         BufferItem item;
136         std::shared_ptr<frametimeline::SurfaceFrame> surfaceFrame;
137     };
138     std::vector<BufferData> mQueueItems;
139     std::atomic<uint64_t> mLastFrameNumberReceived{0};
140 
141     // thread-safe
142     std::atomic<int32_t> mQueuedFrames{0};
143 
144     sp<ContentsChangedListener> mContentsChangedListener;
145 
146     // The last vsync info received on this layer. This will be used when we get
147     // a buffer to correlate the buffer with the vsync id. Can only be accessed
148     // with the SF state lock held.
149     FrameTimelineInfo mFrameTimelineInfo;
150 };
151 
152 } // namespace android
153