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 
68 private:
69 
70     static const size_t kMaxOutputs = 4;
71 
72     // Whether HAL is in control for buffer management. Surface sharing behavior
73     // depends on this flag.
74     const bool mUseHalBufManager;
75 
76     // Pair of an output Surface and its unique ID
77     typedef std::pair<sp<Surface>, size_t> SurfaceUniqueId;
78 
79     // Map surfaceId -> (output surface, unique surface ID)
80     std::array<SurfaceUniqueId, kMaxOutputs> mSurfaceUniqueIds;
81 
82     size_t mNextUniqueSurfaceId = 0;
83 
84     ssize_t getNextSurfaceIdLocked();
85 
86     status_t revertPartialUpdateLocked(const KeyedVector<sp<Surface>, size_t> &removedSurfaces,
87             const KeyedVector<sp<Surface>, size_t> &attachedSurfaces);
88 
89     /**
90      * The Camera3StreamSplitter object this stream uses for stream
91      * sharing.
92      */
93     sp<Camera3StreamSplitter> mStreamSplitter;
94 
95     /**
96      * Initialize stream splitter.
97      */
98     status_t connectStreamSplitterLocked();
99 
100     /**
101      * Attach the output buffer to stream splitter.
102      * When camera service is doing buffer management, this method will be called
103      * before the buffer is handed out to HAL in request thread.
104      * When HAL is doing buffer management, this method will be called when
105      * the buffer is returned from HAL in hwbinder callback thread.
106      */
107     status_t attachBufferToSplitterLocked(ANativeWindowBuffer* anb,
108             const std::vector<size_t>& surface_ids);
109 
110     /**
111      * Internal Camera3Stream interface
112      */
113     virtual status_t getBufferLocked(camera3_stream_buffer *buffer,
114             const std::vector<size_t>& surface_ids);
115 
116     virtual status_t queueBufferToConsumer(sp<ANativeWindow>& consumer,
117             ANativeWindowBuffer* buffer, int anwReleaseFence,
118             const std::vector<size_t>& uniqueSurfaceIds);
119 
120     virtual status_t configureQueueLocked();
121 
122     virtual status_t disconnectLocked();
123 
124     virtual status_t getEndpointUsage(uint64_t *usage) const;
125 
126 }; // class Camera3SharedOutputStream
127 
128 } // namespace camera3
129 
130 } // namespace android
131 
132 #endif // ANDROID_SERVERS_CAMERA3_SHARED_OUTPUT_STREAM_H
133