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             camera_stream_rotation_t rotation, nsecs_t timestampOffset,
40             const std::string& physicalCameraId,
41             const std::unordered_set<int32_t> &sensorPixelModesUsed, IPCTransport transport,
42             int setId = CAMERA3_STREAM_SET_ID_INVALID,
43             bool useHalBufManager = false,
44             int64_t dynamicProfile = ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_STANDARD,
45             int64_t streamUseCase = ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_DEFAULT,
46             bool deviceTimeBaseIsRealtime = false,
47             int timestampBase = OutputConfiguration::TIMESTAMP_BASE_DEFAULT,
48             int mirrorMode = OutputConfiguration::MIRROR_MODE_AUTO,
49             int32_t colorSpace = ANDROID_REQUEST_AVAILABLE_COLOR_SPACE_PROFILES_MAP_UNSPECIFIED,
50             bool useReadoutTimestamp = false);
51 
52     virtual ~Camera3SharedOutputStream();
53 
54     void setHalBufferManager(bool enabled) override;
55 
56     virtual status_t notifyBufferReleased(ANativeWindowBuffer *buffer);
57 
58     virtual bool isConsumerConfigurationDeferred(size_t surface_id) const;
59 
60     virtual status_t setConsumers(const std::vector<sp<Surface>>& consumers);
61 
62     virtual ssize_t getSurfaceId(const sp<Surface> &surface);
63 
64     /**
65      * Query the unique surface IDs of current surfaceIds.
66      * When passing unique surface IDs in returnBuffer(), if the
67      * surfaceId has been removed from the stream, the output corresponding to
68      * the unique surface ID will be ignored and not delivered to client.
69      */
70     virtual status_t getUniqueSurfaceIds(const std::vector<size_t>& surfaceIds,
71             /*out*/std::vector<size_t>* outUniqueIds) override;
72 
73     virtual status_t updateStream(const std::vector<sp<Surface>> &outputSurfaces,
74             const std::vector<OutputStreamInfo> &outputInfo,
75             const std::vector<size_t> &removedSurfaceIds,
76             KeyedVector<sp<Surface>, size_t> *outputMap/*out*/);
77 
getOfflineProcessingSupport()78     virtual bool getOfflineProcessingSupport() const {
79         // As per Camera spec. shared streams currently do not support
80         // offline mode.
81         return false;
82     }
83 
84 private:
85 
86     static const size_t kMaxOutputs = 4;
87 
88     // Whether HAL is in control for buffer management. Surface sharing behavior
89     // depends on this flag.
90     bool mUseHalBufManager;
91 
92     // Pair of an output Surface and its unique ID
93     typedef std::pair<sp<Surface>, size_t> SurfaceUniqueId;
94 
95     // Map surfaceId -> (output surface, unique surface ID)
96     std::array<SurfaceUniqueId, kMaxOutputs> mSurfaceUniqueIds;
97 
98     size_t mNextUniqueSurfaceId = 0;
99 
100     ssize_t getNextSurfaceIdLocked();
101 
102     status_t revertPartialUpdateLocked(const KeyedVector<sp<Surface>, size_t> &removedSurfaces,
103             const KeyedVector<sp<Surface>, size_t> &attachedSurfaces);
104 
105     /**
106      * The Camera3StreamSplitter object this stream uses for stream
107      * sharing.
108      */
109     sp<Camera3StreamSplitter> mStreamSplitter;
110 
111     /**
112      * Initialize stream splitter.
113      */
114     status_t connectStreamSplitterLocked();
115 
116     /**
117      * Attach the output buffer to stream splitter.
118      * When camera service is doing buffer management, this method will be called
119      * before the buffer is handed out to HAL in request thread.
120      * When HAL is doing buffer management, this method will be called when
121      * the buffer is returned from HAL in hwbinder callback thread.
122      */
123     status_t attachBufferToSplitterLocked(ANativeWindowBuffer* anb,
124             const std::vector<size_t>& surface_ids);
125 
126     /**
127      * Internal Camera3Stream interface
128      */
129     virtual status_t getBufferLocked(camera_stream_buffer *buffer,
130             const std::vector<size_t>& surface_ids);
131 
132     virtual status_t queueBufferToConsumer(sp<ANativeWindow>& consumer,
133             ANativeWindowBuffer* buffer, int anwReleaseFence,
134             const std::vector<size_t>& uniqueSurfaceIds);
135 
136     virtual status_t configureQueueLocked();
137 
138     virtual status_t disconnectLocked();
139 
140     virtual status_t getEndpointUsage(uint64_t *usage);
141 
142 }; // class Camera3SharedOutputStream
143 
144 } // namespace camera3
145 
146 } // namespace android
147 
148 #endif // ANDROID_SERVERS_CAMERA3_SHARED_OUTPUT_STREAM_H
149