1 /*
2  * Copyright (C) 2014-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_DUMMY_STREAM_H
18 #define ANDROID_SERVERS_CAMERA3_DUMMY_STREAM_H
19 
20 #include <utils/RefBase.h>
21 #include <gui/Surface.h>
22 
23 #include "Camera3Stream.h"
24 #include "Camera3IOStreamBase.h"
25 #include "Camera3OutputStreamInterface.h"
26 
27 namespace android {
28 namespace camera3 {
29 
30 /**
31  * A dummy output stream class, to be used as a placeholder when no valid
32  * streams are configured by the client.
33  * This is necessary because camera HAL v3.2 or older disallow configuring
34  * 0 output streams, while the public camera2 API allows for it.
35  */
36 class Camera3DummyStream :
37         public Camera3IOStreamBase,
38         public Camera3OutputStreamInterface {
39 
40   public:
41     /**
42      * Set up a dummy stream; doesn't actually connect to anything, and uses
43      * a default dummy format and size.
44      */
45     explicit Camera3DummyStream(int id);
46 
47     virtual ~Camera3DummyStream();
48 
49     /**
50      * Camera3Stream interface
51      */
52 
53     virtual void     dump(int fd, const Vector<String16> &args) const;
54 
55     status_t         setTransform(int transform);
56 
57     virtual status_t detachBuffer(sp<GraphicBuffer>* buffer, int* fenceFd);
58 
59     /**
60      * Drop buffers for stream of streamId if dropping is true. If dropping is false, do not
61      * drop buffers for stream of streamId.
62      */
63     virtual status_t dropBuffers(bool /*dropping*/) override;
64 
65     /**
66      * Query the physical camera id for the output stream.
67      */
68     virtual const String8& getPhysicalCameraId() const override;
69 
70     /**
71      * Return if this output stream is for video encoding.
72      */
73     bool isVideoStream() const;
74 
75     /**
76      * Return if the consumer configuration of this stream is deferred.
77      */
78     virtual bool isConsumerConfigurationDeferred(size_t surface_id) const;
79 
80     /**
81      * Set the consumer surfaces to the output stream.
82      */
83     virtual status_t setConsumers(const std::vector<sp<Surface>>& consumers);
84 
85     /**
86      * Query the output surface id.
87      */
getSurfaceId(const sp<Surface> &)88     virtual ssize_t getSurfaceId(const sp<Surface> &/*surface*/) { return 0; }
89 
getUniqueSurfaceIds(const std::vector<size_t> &,std::vector<size_t> *)90     virtual status_t getUniqueSurfaceIds(const std::vector<size_t>&,
91             /*out*/std::vector<size_t>*) { return INVALID_OPERATION; };
92 
93     /**
94      * Update the stream output surfaces.
95      */
96     virtual status_t updateStream(const std::vector<sp<Surface>> &outputSurfaces,
97             const std::vector<OutputStreamInfo> &outputInfo,
98             const std::vector<size_t> &removedSurfaceIds,
99             KeyedVector<sp<Surface>, size_t> *outputMap/*out*/);
100 
101   protected:
102 
103     /**
104      * Note that we release the lock briefly in this function
105      */
106     virtual status_t returnBufferCheckedLocked(
107             const camera3_stream_buffer &buffer,
108             nsecs_t timestamp,
109             bool output,
110             const std::vector<size_t>& surface_ids,
111             /*out*/
112             sp<Fence> *releaseFenceOut);
113 
114     virtual status_t disconnectLocked();
115 
116   private:
117 
118     // Default dummy parameters; 320x240 is a required size for all devices,
119     // otherwise act like a SurfaceView would.
120     static const int DUMMY_WIDTH = 320;
121     static const int DUMMY_HEIGHT = 240;
122     static const int DUMMY_FORMAT = HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED;
123     static const android_dataspace DUMMY_DATASPACE = HAL_DATASPACE_UNKNOWN;
124     static const camera3_stream_rotation_t DUMMY_ROTATION = CAMERA3_STREAM_ROTATION_0;
125     static const uint64_t DUMMY_USAGE = GRALLOC_USAGE_HW_COMPOSER;
126     static const String8 DUMMY_ID;
127 
128     /**
129      * Internal Camera3Stream interface
130      */
131     virtual status_t getBufferLocked(camera3_stream_buffer *buffer,
132             const std::vector<size_t>& surface_ids = std::vector<size_t>());
133     virtual status_t returnBufferLocked(
134             const camera3_stream_buffer &buffer,
135             nsecs_t timestamp, const std::vector<size_t>& surface_ids);
136 
137     virtual status_t configureQueueLocked();
138 
139     virtual status_t getEndpointUsage(uint64_t *usage) const;
140 
141 }; // class Camera3DummyStream
142 
143 } // namespace camera3
144 
145 } // namespace android
146 
147 #endif
148