1 /*
2  * Copyright (C) 2016-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 #ifndef ANDROID_SERVERS_CAMERA3_SHARED_OUTPUT_STREAM_H
18 #define ANDROID_SERVERS_CAMERA3_SHARED_OUTPUT_STREAM_H
19 
20 #include <array>
21 #include "Camera3StreamSplitter.h"
22 #include "Camera3OutputStream.h"
23 
24 namespace android {
25 
26 namespace camera3 {
27 
28 class Camera3SharedOutputStream :
29         public Camera3OutputStream {
30 public:
31     /**
32      * Set up a stream for formats that have 2 dimensions, with multiple
33      * surfaces. A valid stream set id needs to be set to support buffer
34      * sharing between multiple streams.
35      */
36     Camera3SharedOutputStream(int id, const std::vector<sp<Surface>>& surfaces,
37             uint32_t width, uint32_t height, int format,
38             uint64_t consumerUsage, android_dataspace dataSpace,
39             camera3_stream_rotation_t rotation, nsecs_t timestampOffset,
40             const String8& physicalCameraId,
41             int setId = CAMERA3_STREAM_SET_ID_INVALID,
42             bool useHalBufManager = false);
43 
44     virtual ~Camera3SharedOutputStream();
45 
46     virtual status_t notifyBufferReleased(ANativeWindowBuffer *buffer);
47 
48     virtual bool isConsumerConfigurationDeferred(size_t surface_id) const;
49 
50     virtual status_t setConsumers(const std::vector<sp<Surface>>& consumers);
51 
52     virtual ssize_t getSurfaceId(const sp<Surface> &surface);
53 
54     /**
55      * Query the unique surface IDs of current surfaceIds.
56      * When passing unique surface IDs in returnBuffer(), if the
57      * surfaceId has been removed from the stream, the output corresponding to
58      * the unique surface ID will be ignored and not delivered to client.
59      */
60     virtual status_t getUniqueSurfaceIds(const std::vector<size_t>& surfaceIds,
61             /*out*/std::vector<size_t>* outUniqueIds) override;
62 
63     virtual status_t updateStream(const std::vector<sp<Surface>> &outputSurfaces,
64             const std::vector<OutputStreamInfo> &outputInfo,
65             const std::vector<size_t> &removedSurfaceIds,
66             KeyedVector<sp<Surface>, size_t> *outputMap/*out*/);
67 
getOfflineProcessingSupport()68     virtual bool getOfflineProcessingSupport() const {
69         // As per Camera spec. shared streams currently do not support
70         // offline mode.
71         return false;
72     }
73 
74 private:
75 
76     static const size_t kMaxOutputs = 4;
77 
78     // Whether HAL is in control for buffer management. Surface sharing behavior
79     // depends on this flag.
80     const bool mUseHalBufManager;
81 
82     // Pair of an output Surface and its unique ID
83     typedef std::pair<sp<Surface>, size_t> SurfaceUniqueId;
84 
85     // Map surfaceId -> (output surface, unique surface ID)
86     std::array<SurfaceUniqueId, kMaxOutputs> mSurfaceUniqueIds;
87 
88     size_t mNextUniqueSurfaceId = 0;
89 
90     ssize_t getNextSurfaceIdLocked();
91 
92     status_t revertPartialUpdateLocked(const KeyedVector<sp<Surface>, size_t> &removedSurfaces,
93             const KeyedVector<sp<Surface>, size_t> &attachedSurfaces);
94 
95     /**
96      * The Camera3StreamSplitter object this stream uses for stream
97      * sharing.
98      */
99     sp<Camera3StreamSplitter> mStreamSplitter;
100 
101     /**
102      * Initialize stream splitter.
103      */
104     status_t connectStreamSplitterLocked();
105 
106     /**
107      * Attach the output buffer to stream splitter.
108      * When camera service is doing buffer management, this method will be called
109      * before the buffer is handed out to HAL in request thread.
110      * When HAL is doing buffer management, this method will be called when
111      * the buffer is returned from HAL in hwbinder callback thread.
112      */
113     status_t attachBufferToSplitterLocked(ANativeWindowBuffer* anb,
114             const std::vector<size_t>& surface_ids);
115 
116     /**
117      * Internal Camera3Stream interface
118      */
119     virtual status_t getBufferLocked(camera3_stream_buffer *buffer,
120             const std::vector<size_t>& surface_ids);
121 
122     virtual status_t queueBufferToConsumer(sp<ANativeWindow>& consumer,
123             ANativeWindowBuffer* buffer, int anwReleaseFence,
124             const std::vector<size_t>& uniqueSurfaceIds);
125 
126     virtual status_t configureQueueLocked();
127 
128     virtual status_t disconnectLocked();
129 
130     virtual status_t getEndpointUsage(uint64_t *usage) const;
131 
132 }; // class Camera3SharedOutputStream
133 
134 } // namespace camera3
135 
136 } // namespace android
137 
138 #endif // ANDROID_SERVERS_CAMERA3_SHARED_OUTPUT_STREAM_H
139