1/*
2 * Copyright (C) 2013 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#include <stdio.h>
18#include <hardware/camera3.h>
19#include <hardware/gralloc.h>
20#include <system/graphics.h>
21#include <utils/Mutex.h>
22
23//#define LOG_NDEBUG 0
24#define LOG_TAG "Stream"
25#include <cutils/log.h>
26
27#define ATRACE_TAG (ATRACE_TAG_CAMERA | ATRACE_TAG_HAL)
28#include <utils/Trace.h>
29
30#include "Stream.h"
31
32namespace default_camera_hal {
33
34Stream::Stream(int id, camera3_stream_t *s)
35  : mReuse(false),
36    mId(id),
37    mStream(s),
38    mType(s->stream_type),
39    mWidth(s->width),
40    mHeight(s->height),
41    mFormat(s->format),
42    mUsage(0),
43    mMaxBuffers(0),
44    mRegistered(false),
45    mBuffers(0),
46    mNumBuffers(0)
47{
48}
49
50Stream::~Stream()
51{
52    android::Mutex::Autolock al(mLock);
53    unregisterBuffers_L();
54}
55
56void Stream::setUsage(uint32_t usage)
57{
58    android::Mutex::Autolock al(mLock);
59    if (usage != mUsage) {
60        mUsage = usage;
61        mStream->usage = usage;
62        unregisterBuffers_L();
63    }
64}
65
66void Stream::setMaxBuffers(uint32_t max_buffers)
67{
68    android::Mutex::Autolock al(mLock);
69    if (max_buffers != mMaxBuffers) {
70        mMaxBuffers = max_buffers;
71        mStream->max_buffers = max_buffers;
72        unregisterBuffers_L();
73    }
74}
75
76int Stream::getType()
77{
78    return mType;
79}
80
81bool Stream::isInputType()
82{
83    return mType == CAMERA3_STREAM_INPUT ||
84        mType == CAMERA3_STREAM_BIDIRECTIONAL;
85}
86
87bool Stream::isOutputType()
88{
89    return mType == CAMERA3_STREAM_OUTPUT ||
90        mType == CAMERA3_STREAM_BIDIRECTIONAL;
91}
92
93const char* Stream::typeToString(int type)
94{
95    switch (type) {
96    case CAMERA3_STREAM_INPUT:
97        return "CAMERA3_STREAM_INPUT";
98    case CAMERA3_STREAM_OUTPUT:
99        return "CAMERA3_STREAM_OUTPUT";
100    case CAMERA3_STREAM_BIDIRECTIONAL:
101        return "CAMERA3_STREAM_BIDIRECTIONAL";
102    }
103    return "Invalid stream type!";
104}
105
106const char* Stream::formatToString(int format)
107{
108    // See <system/graphics.h> for full list
109    switch (format) {
110    case HAL_PIXEL_FORMAT_BGRA_8888:
111        return "BGRA 8888";
112    case HAL_PIXEL_FORMAT_RGBA_8888:
113        return "RGBA 8888";
114    case HAL_PIXEL_FORMAT_RGBX_8888:
115        return "RGBX 8888";
116    case HAL_PIXEL_FORMAT_RGB_888:
117        return "RGB 888";
118    case HAL_PIXEL_FORMAT_RGB_565:
119        return "RGB 565";
120    case HAL_PIXEL_FORMAT_sRGB_A_8888:
121        return "sRGB A 8888";
122    case HAL_PIXEL_FORMAT_sRGB_X_8888:
123        return "sRGB B 8888";
124    case HAL_PIXEL_FORMAT_Y8:
125        return "Y8";
126    case HAL_PIXEL_FORMAT_Y16:
127        return "Y16";
128    case HAL_PIXEL_FORMAT_YV12:
129        return "YV12";
130    case HAL_PIXEL_FORMAT_YCbCr_422_SP:
131        return "NV16";
132    case HAL_PIXEL_FORMAT_YCrCb_420_SP:
133        return "NV21";
134    case HAL_PIXEL_FORMAT_YCbCr_422_I:
135        return "YUY2";
136    case HAL_PIXEL_FORMAT_RAW_SENSOR:
137        return "RAW SENSOR";
138    case HAL_PIXEL_FORMAT_BLOB:
139        return "BLOB";
140    case HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED:
141        return "IMPLEMENTATION DEFINED";
142    case HAL_PIXEL_FORMAT_YCbCr_420_888:
143        return "FLEXIBLE YCbCr 420 888";
144    }
145    return "Invalid stream format!";
146}
147
148bool Stream::isRegistered()
149{
150    return mRegistered;
151}
152
153bool Stream::isValidReuseStream(int id, camera3_stream_t *s)
154{
155    if (id != mId) {
156        ALOGE("%s:%d: Invalid camera id for reuse. Got %d expect %d",
157                __func__, mId, id, mId);
158        return false;
159    }
160    if (s != mStream) {
161        ALOGE("%s:%d: Invalid stream handle for reuse. Got %p expect %p",
162                __func__, mId, s, mStream);
163        return false;
164    }
165    if (s->stream_type != mType) {
166        ALOGE("%s:%d: Mismatched type in reused stream. Got %s(%d) "
167                "expect %s(%d)", __func__, mId, typeToString(s->stream_type),
168                s->stream_type, typeToString(mType), mType);
169        return false;
170    }
171    if (s->format != mFormat) {
172        ALOGE("%s:%d: Mismatched format in reused stream. Got %s(%d) "
173                "expect %s(%d)", __func__, mId, formatToString(s->format),
174                s->format, formatToString(mFormat), mFormat);
175        return false;
176    }
177    if (s->width != mWidth) {
178        ALOGE("%s:%d: Mismatched width in reused stream. Got %d expect %d",
179                __func__, mId, s->width, mWidth);
180        return false;
181    }
182    if (s->height != mHeight) {
183        ALOGE("%s:%d: Mismatched height in reused stream. Got %d expect %d",
184                __func__, mId, s->height, mHeight);
185        return false;
186    }
187    return true;
188}
189
190int Stream::registerBuffers(const camera3_stream_buffer_set_t *buf_set)
191{
192    ATRACE_CALL();
193    android::Mutex::Autolock al(mLock);
194
195    if (buf_set->stream != mStream) {
196        ALOGE("%s:%d: Buffer set for invalid stream. Got %p expect %p",
197                __func__, mId, buf_set->stream, mStream);
198        return -EINVAL;
199    }
200
201    mNumBuffers = buf_set->num_buffers;
202    mBuffers = new buffer_handle_t*[mNumBuffers];
203
204    for (unsigned int i = 0; i < mNumBuffers; i++) {
205        ALOGV("%s:%d: Registering buffer %p", __func__, mId,
206                buf_set->buffers[i]);
207        mBuffers[i] = buf_set->buffers[i];
208        // TODO: register buffers with hw, handle error cases
209    }
210    mRegistered = true;
211
212    return 0;
213}
214
215// This must only be called with mLock held
216void Stream::unregisterBuffers_L()
217{
218    mRegistered = false;
219    mNumBuffers = 0;
220    delete [] mBuffers;
221    // TODO: unregister buffers from hw
222}
223
224void Stream::dump(int fd)
225{
226    android::Mutex::Autolock al(mLock);
227
228    dprintf(fd, "Stream ID: %d (%p)\n", mId, mStream);
229    dprintf(fd, "Stream Type: %s (%d)\n", typeToString(mType), mType);
230    dprintf(fd, "Width: %"PRIu32" Height: %"PRIu32"\n", mWidth, mHeight);
231    dprintf(fd, "Stream Format: %s (%d)", formatToString(mFormat), mFormat);
232    // ToDo: prettyprint usage mask flags
233    dprintf(fd, "Gralloc Usage Mask: %#"PRIx32"\n", mUsage);
234    dprintf(fd, "Max Buffer Count: %"PRIu32"\n", mMaxBuffers);
235    dprintf(fd, "Buffers Registered: %s\n", mRegistered ? "true" : "false");
236    dprintf(fd, "Number of Buffers: %"PRIu32"\n", mNumBuffers);
237    for (uint32_t i = 0; i < mNumBuffers; i++) {
238        dprintf(fd, "Buffer %"PRIu32"/%"PRIu32": %p\n", i, mNumBuffers,
239                mBuffers[i]);
240    }
241}
242
243} // namespace default_camera_hal
244