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 
90     /**
91      * Update the stream output surfaces.
92      */
93     virtual status_t updateStream(const std::vector<sp<Surface>> &outputSurfaces,
94             const std::vector<OutputStreamInfo> &outputInfo,
95             const std::vector<size_t> &removedSurfaceIds,
96             KeyedVector<sp<Surface>, size_t> *outputMap/*out*/);
97 
98   protected:
99 
100     /**
101      * Note that we release the lock briefly in this function
102      */
103     virtual status_t returnBufferCheckedLocked(
104             const camera3_stream_buffer &buffer,
105             nsecs_t timestamp,
106             bool output,
107             /*out*/
108             sp<Fence> *releaseFenceOut);
109 
110     virtual status_t disconnectLocked();
111 
112   private:
113 
114     // Default dummy parameters; 320x240 is a required size for all devices,
115     // otherwise act like a SurfaceView would.
116     static const int DUMMY_WIDTH = 320;
117     static const int DUMMY_HEIGHT = 240;
118     static const int DUMMY_FORMAT = HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED;
119     static const android_dataspace DUMMY_DATASPACE = HAL_DATASPACE_UNKNOWN;
120     static const camera3_stream_rotation_t DUMMY_ROTATION = CAMERA3_STREAM_ROTATION_0;
121     static const uint64_t DUMMY_USAGE = GRALLOC_USAGE_HW_COMPOSER;
122     static const String8 DUMMY_ID;
123 
124     /**
125      * Internal Camera3Stream interface
126      */
127     virtual status_t getBufferLocked(camera3_stream_buffer *buffer,
128             const std::vector<size_t>& surface_ids = std::vector<size_t>());
129     virtual status_t returnBufferLocked(
130             const camera3_stream_buffer &buffer,
131             nsecs_t timestamp);
132 
133     virtual status_t configureQueueLocked();
134 
135     virtual status_t getEndpointUsage(uint64_t *usage) const;
136 
137 }; // class Camera3DummyStream
138 
139 } // namespace camera3
140 
141 } // namespace android
142 
143 #endif
144