Camera2Client.cpp revision 160d4af9d933fe9461bb213e5876fc5c8c2178c2 
1/*
2 * Copyright (C) 2012 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#define LOG_TAG "Camera2Client"
18#define ATRACE_TAG ATRACE_TAG_CAMERA
19//#define LOG_NDEBUG 0
20
21#include <utils/Log.h>
22#include <utils/Trace.h>
23
24#include <cutils/properties.h>
25#include <gui/SurfaceTextureClient.h>
26#include <gui/Surface.h>
27#include <media/hardware/MetadataBufferType.h>
28
29#include <math.h>
30
31#include "Camera2Client.h"
32
33namespace android {
34
35#define ALOG1(...) ALOGD_IF(gLogLevel >= 1, __VA_ARGS__);
36#define ALOG2(...) ALOGD_IF(gLogLevel >= 2, __VA_ARGS__);
37
38static int getCallingPid() {
39    return IPCThreadState::self()->getCallingPid();
40}
41
42static int getCallingUid() {
43    return IPCThreadState::self()->getCallingUid();
44}
45
46// Interface used by CameraService
47
48Camera2Client::Camera2Client(const sp<CameraService>& cameraService,
49        const sp<ICameraClient>& cameraClient,
50        int cameraId,
51        int cameraFacing,
52        int clientPid):
53        Client(cameraService, cameraClient,
54                cameraId, cameraFacing, clientPid),
55        mState(DISCONNECTED),
56        mPreviewStreamId(NO_STREAM),
57        mPreviewRequest(NULL),
58        mCaptureStreamId(NO_STREAM),
59        mCaptureRequest(NULL),
60        mRecordingStreamId(NO_STREAM),
61        mRecordingRequest(NULL),
62        mRecordingHeapCount(kDefaultRecordingHeapCount)
63{
64    ATRACE_CALL();
65
66    mDevice = new Camera2Device(cameraId);
67}
68
69status_t Camera2Client::checkPid(const char* checkLocation) const {
70    int callingPid = getCallingPid();
71    if (callingPid == mClientPid) return NO_ERROR;
72
73    ALOGE("%s: attempt to use a locked camera from a different process"
74            " (old pid %d, new pid %d)", checkLocation, mClientPid, callingPid);
75    return PERMISSION_DENIED;
76}
77
78status_t Camera2Client::initialize(camera_module_t *module)
79{
80    ATRACE_CALL();
81    ALOGV("%s: E", __FUNCTION__);
82    status_t res;
83
84    res = mDevice->initialize(module);
85    if (res != OK) {
86        ALOGE("%s: Camera %d: unable to initialize device: %s (%d)",
87                __FUNCTION__, mCameraId, strerror(-res), res);
88        return NO_INIT;
89    }
90
91    res = buildDefaultParameters();
92    if (res != OK) {
93        ALOGE("%s: Camera %d: unable to build defaults: %s (%d)",
94                __FUNCTION__, mCameraId, strerror(-res), res);
95        return NO_INIT;
96    }
97
98    if (gLogLevel >= 1) {
99        LockedParameters::Key k(mParameters);
100        ALOGD("%s: Default parameters converted from camera %d:", __FUNCTION__,
101              mCameraId);
102        ALOGD("%s", k.mParameters.paramsFlattened.string());
103    }
104
105    mState = STOPPED;
106
107    return OK;
108}
109
110Camera2Client::~Camera2Client() {
111    ATRACE_CALL();
112    ALOGV("%s: Camera %d: Shutting down", __FUNCTION__, mCameraId);
113
114    mDestructionStarted = true;
115
116    // Rewrite mClientPid to allow shutdown by CameraService
117    mClientPid = getCallingPid();
118    disconnect();
119}
120
121status_t Camera2Client::dump(int fd, const Vector<String16>& args) {
122    String8 result;
123    result.appendFormat("Client2[%d] (%p) PID: %d, dump:\n",
124            mCameraId,
125            getCameraClient()->asBinder().get(),
126            mClientPid);
127    result.append("  State: ");
128#define CASE_APPEND_ENUM(x) case x: result.append(#x "\n"); break;
129
130    const Parameters& p = mParameters.unsafeUnlock();
131
132    result.append(getStateName(mState));
133
134    result.append("\n  Current parameters:\n");
135    result.appendFormat("    Preview size: %d x %d\n",
136            p.previewWidth, p.previewHeight);
137    result.appendFormat("    Preview FPS range: %d - %d\n",
138            p.previewFpsRange[0], p.previewFpsRange[1]);
139    result.appendFormat("    Preview HAL pixel format: 0x%x\n",
140            p.previewFormat);
141    result.appendFormat("    Preview transform: %x\n",
142            p.previewTransform);
143    result.appendFormat("    Picture size: %d x %d\n",
144            p.pictureWidth, p.pictureHeight);
145    result.appendFormat("    Jpeg thumbnail size: %d x %d\n",
146            p.jpegThumbSize[0], p.jpegThumbSize[1]);
147    result.appendFormat("    Jpeg quality: %d, thumbnail quality: %d\n",
148            p.jpegQuality, p.jpegThumbQuality);
149    result.appendFormat("    Jpeg rotation: %d\n", p.jpegRotation);
150    result.appendFormat("    GPS tags %s\n",
151            p.gpsEnabled ? "enabled" : "disabled");
152    if (p.gpsEnabled) {
153        result.appendFormat("    GPS lat x long x alt: %f x %f x %f\n",
154                p.gpsCoordinates[0], p.gpsCoordinates[1],
155                p.gpsCoordinates[2]);
156        result.appendFormat("    GPS timestamp: %lld\n",
157                p.gpsTimestamp);
158        result.appendFormat("    GPS processing method: %s\n",
159                p.gpsProcessingMethod.string());
160    }
161
162    result.append("    White balance mode: ");
163    switch (p.wbMode) {
164        CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_AUTO)
165        CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_INCANDESCENT)
166        CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_FLUORESCENT)
167        CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_WARM_FLUORESCENT)
168        CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_DAYLIGHT)
169        CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_CLOUDY_DAYLIGHT)
170        CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_TWILIGHT)
171        CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_SHADE)
172        default: result.append("UNKNOWN\n");
173    }
174
175    result.append("    Effect mode: ");
176    switch (p.effectMode) {
177        CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_OFF)
178        CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MONO)
179        CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_NEGATIVE)
180        CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_SOLARIZE)
181        CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_SEPIA)
182        CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_POSTERIZE)
183        CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_WHITEBOARD)
184        CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_BLACKBOARD)
185        CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_AQUA)
186        default: result.append("UNKNOWN\n");
187    }
188
189    result.append("    Antibanding mode: ");
190    switch (p.antibandingMode) {
191        CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_AUTO)
192        CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_OFF)
193        CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_50HZ)
194        CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_60HZ)
195        default: result.append("UNKNOWN\n");
196    }
197
198    result.append("    Scene mode: ");
199    switch (p.sceneMode) {
200        case ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED:
201            result.append("AUTO\n"); break;
202        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_ACTION)
203        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_PORTRAIT)
204        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_LANDSCAPE)
205        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_NIGHT)
206        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_NIGHT_PORTRAIT)
207        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_THEATRE)
208        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_BEACH)
209        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SNOW)
210        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SUNSET)
211        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_STEADYPHOTO)
212        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_FIREWORKS)
213        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SPORTS)
214        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_PARTY)
215        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_CANDLELIGHT)
216        CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_BARCODE)
217        default: result.append("UNKNOWN\n");
218    }
219
220    result.append("    Flash mode: ");
221    switch (p.flashMode) {
222        CASE_APPEND_ENUM(Parameters::FLASH_MODE_OFF)
223        CASE_APPEND_ENUM(Parameters::FLASH_MODE_AUTO)
224        CASE_APPEND_ENUM(Parameters::FLASH_MODE_ON)
225        CASE_APPEND_ENUM(Parameters::FLASH_MODE_TORCH)
226        CASE_APPEND_ENUM(Parameters::FLASH_MODE_RED_EYE)
227        CASE_APPEND_ENUM(Parameters::FLASH_MODE_INVALID)
228        default: result.append("UNKNOWN\n");
229    }
230
231    result.append("    Focus mode: ");
232    switch (p.focusMode) {
233        CASE_APPEND_ENUM(Parameters::FOCUS_MODE_AUTO)
234        CASE_APPEND_ENUM(Parameters::FOCUS_MODE_MACRO)
235        CASE_APPEND_ENUM(Parameters::FOCUS_MODE_CONTINUOUS_VIDEO)
236        CASE_APPEND_ENUM(Parameters::FOCUS_MODE_CONTINUOUS_PICTURE)
237        CASE_APPEND_ENUM(Parameters::FOCUS_MODE_EDOF)
238        CASE_APPEND_ENUM(Parameters::FOCUS_MODE_INFINITY)
239        CASE_APPEND_ENUM(Parameters::FOCUS_MODE_FIXED)
240        CASE_APPEND_ENUM(Parameters::FOCUS_MODE_INVALID)
241        default: result.append("UNKNOWN\n");
242    }
243
244    result.append("    Focusing areas:\n");
245    for (size_t i = 0; i < p.focusingAreas.size(); i++) {
246        result.appendFormat("      [ (%d, %d, %d, %d), weight %d ]\n",
247                p.focusingAreas[i].left,
248                p.focusingAreas[i].top,
249                p.focusingAreas[i].right,
250                p.focusingAreas[i].bottom,
251                p.focusingAreas[i].weight);
252    }
253
254    result.appendFormat("    Exposure compensation index: %d\n",
255            p.exposureCompensation);
256
257    result.appendFormat("    AE lock %s, AWB lock %s\n",
258            p.autoExposureLock ? "enabled" : "disabled",
259            p.autoWhiteBalanceLock ? "enabled" : "disabled" );
260
261    result.appendFormat("    Metering areas:\n");
262    for (size_t i = 0; i < p.meteringAreas.size(); i++) {
263        result.appendFormat("      [ (%d, %d, %d, %d), weight %d ]\n",
264                p.meteringAreas[i].left,
265                p.meteringAreas[i].top,
266                p.meteringAreas[i].right,
267                p.meteringAreas[i].bottom,
268                p.meteringAreas[i].weight);
269    }
270
271    result.appendFormat("    Zoom index: %d\n", p.zoom);
272    result.appendFormat("    Video size: %d x %d\n", p.videoWidth,
273            p.videoHeight);
274
275    result.appendFormat("    Recording hint is %s\n",
276            p.recordingHint ? "set" : "not set");
277
278    result.appendFormat("    Video stabilization is %s\n",
279            p.videoStabilization ? "enabled" : "disabled");
280
281    result.append("  Current streams:\n");
282    result.appendFormat("    Preview stream ID: %d\n", mPreviewStreamId);
283    result.appendFormat("    Capture stream ID: %d\n", mCaptureStreamId);
284    result.appendFormat("    Recording stream ID: %d\n", mRecordingStreamId);
285
286    result.append("  Current requests:\n");
287    if (mPreviewRequest != NULL) {
288        result.append("    Preview request:\n");
289        write(fd, result.string(), result.size());
290        dump_indented_camera_metadata(mPreviewRequest, fd, 2, 6);
291    } else {
292        result.append("    Preview request: undefined\n");
293        write(fd, result.string(), result.size());
294    }
295
296    if (mCaptureRequest != NULL) {
297        result = "    Capture request:\n";
298        write(fd, result.string(), result.size());
299        dump_indented_camera_metadata(mCaptureRequest, fd, 2, 6);
300    } else {
301        result = "    Capture request: undefined\n";
302        write(fd, result.string(), result.size());
303    }
304
305    if (mRecordingRequest != NULL) {
306        result = "    Recording request:\n";
307        write(fd, result.string(), result.size());
308        dump_indented_camera_metadata(mRecordingRequest, fd, 2, 6);
309    } else {
310        result = "    Recording request: undefined\n";
311        write(fd, result.string(), result.size());
312    }
313
314    result = "  Device dump:\n";
315    write(fd, result.string(), result.size());
316
317    status_t res = mDevice->dump(fd, args);
318    if (res != OK) {
319        result = String8::format("   Error dumping device: %s (%d)",
320                strerror(-res), res);
321        write(fd, result.string(), result.size());
322    }
323
324#undef CASE_APPEND_ENUM
325    return NO_ERROR;
326}
327
328const char* Camera2Client::getStateName(State state) {
329#define CASE_ENUM_TO_CHAR(x) case x: return(#x); break;
330    switch(state) {
331        CASE_ENUM_TO_CHAR(DISCONNECTED)
332        CASE_ENUM_TO_CHAR(STOPPED)
333        CASE_ENUM_TO_CHAR(WAITING_FOR_PREVIEW_WINDOW)
334        CASE_ENUM_TO_CHAR(PREVIEW)
335        CASE_ENUM_TO_CHAR(RECORD)
336        CASE_ENUM_TO_CHAR(STILL_CAPTURE)
337        CASE_ENUM_TO_CHAR(VIDEO_SNAPSHOT)
338        default:
339            return "Unknown state!";
340            break;
341    }
342#undef CASE_ENUM_TO_CHAR
343}
344
345// ICamera interface
346
347void Camera2Client::disconnect() {
348    ATRACE_CALL();
349    ALOGV("%s: E", __FUNCTION__);
350    Mutex::Autolock icl(mICameraLock);
351    status_t res;
352    if ( (res = checkPid(__FUNCTION__) ) != OK) return;
353
354    if (mDevice == 0) return;
355
356    stopPreviewL();
357
358    mDevice->waitUntilDrained();
359
360    if (mPreviewStreamId != NO_STREAM) {
361        mDevice->deleteStream(mPreviewStreamId);
362        mPreviewStreamId = NO_STREAM;
363    }
364
365    if (mCaptureStreamId != NO_STREAM) {
366        mDevice->deleteStream(mCaptureStreamId);
367        mCaptureStreamId = NO_STREAM;
368    }
369
370    if (mRecordingStreamId != NO_STREAM) {
371        mDevice->deleteStream(mRecordingStreamId);
372        mRecordingStreamId = NO_STREAM;
373    }
374
375    mDevice.clear();
376    mState = DISCONNECTED;
377
378    CameraService::Client::disconnect();
379}
380
381status_t Camera2Client::connect(const sp<ICameraClient>& client) {
382    ATRACE_CALL();
383    ALOGV("%s: E", __FUNCTION__);
384    Mutex::Autolock icl(mICameraLock);
385
386    if (mClientPid != 0 && getCallingPid() != mClientPid) {
387        ALOGE("%s: Camera %d: Connection attempt from pid %d; "
388                "current locked to pid %d", __FUNCTION__,
389                mCameraId, getCallingPid(), mClientPid);
390        return BAD_VALUE;
391    }
392
393    mClientPid = getCallingPid();
394    mCameraClient = client;
395
396    return OK;
397}
398
399status_t Camera2Client::lock() {
400    ATRACE_CALL();
401    ALOGV("%s: E", __FUNCTION__);
402    Mutex::Autolock icl(mICameraLock);
403    ALOGV("%s: Camera %d: Lock call from pid %d; current client pid %d",
404            __FUNCTION__, mCameraId, getCallingPid(), mClientPid);
405
406    if (mClientPid == 0) {
407        mClientPid = getCallingPid();
408        return OK;
409    }
410
411    if (mClientPid != getCallingPid()) {
412        ALOGE("%s: Camera %d: Lock call from pid %d; currently locked to pid %d",
413                __FUNCTION__, mCameraId, getCallingPid(), mClientPid);
414        return EBUSY;
415    }
416
417    return OK;
418}
419
420status_t Camera2Client::unlock() {
421    ATRACE_CALL();
422    ALOGV("%s: E", __FUNCTION__);
423    Mutex::Autolock icl(mICameraLock);
424    ALOGV("%s: Camera %d: Unlock call from pid %d; current client pid %d",
425            __FUNCTION__, mCameraId, getCallingPid(), mClientPid);
426
427    // TODO: Check for uninterruptable conditions
428
429    if (mClientPid == getCallingPid()) {
430        mClientPid = 0;
431        mCameraClient.clear();
432        return OK;
433    }
434
435    ALOGE("%s: Camera %d: Unlock call from pid %d; currently locked to pid %d",
436            __FUNCTION__, mCameraId, getCallingPid(), mClientPid);
437    return EBUSY;
438}
439
440status_t Camera2Client::setPreviewDisplay(
441        const sp<Surface>& surface) {
442    ATRACE_CALL();
443    ALOGV("%s: E", __FUNCTION__);
444    Mutex::Autolock icl(mICameraLock);
445    status_t res;
446    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
447
448    sp<IBinder> binder;
449    sp<ANativeWindow> window;
450    if (surface != 0) {
451        binder = surface->asBinder();
452        window = surface;
453    }
454
455    return setPreviewWindowL(binder,window);
456}
457
458status_t Camera2Client::setPreviewTexture(
459        const sp<ISurfaceTexture>& surfaceTexture) {
460    ATRACE_CALL();
461    ALOGV("%s: E", __FUNCTION__);
462    Mutex::Autolock icl(mICameraLock);
463    status_t res;
464    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
465
466    sp<IBinder> binder;
467    sp<ANativeWindow> window;
468    if (surfaceTexture != 0) {
469        binder = surfaceTexture->asBinder();
470        window = new SurfaceTextureClient(surfaceTexture);
471    }
472    return setPreviewWindowL(binder, window);
473}
474
475status_t Camera2Client::setPreviewWindowL(const sp<IBinder>& binder,
476        sp<ANativeWindow> window) {
477    ATRACE_CALL();
478    status_t res;
479
480    if (binder == mPreviewSurface) {
481        ALOGV("%s: Camera %d: New window is same as old window",
482                __FUNCTION__, mCameraId);
483        return NO_ERROR;
484    }
485
486    switch (mState) {
487        case DISCONNECTED:
488        case RECORD:
489        case STILL_CAPTURE:
490        case VIDEO_SNAPSHOT:
491            ALOGE("%s: Camera %d: Cannot set preview display while in state %s",
492                    __FUNCTION__, mCameraId, getStateName(mState));
493            return INVALID_OPERATION;
494        case STOPPED:
495        case WAITING_FOR_PREVIEW_WINDOW:
496            // OK
497            break;
498        case PREVIEW:
499            // Already running preview - need to stop and create a new stream
500            // TODO: Optimize this so that we don't wait for old stream to drain
501            // before spinning up new stream
502            mDevice->setStreamingRequest(NULL);
503            mState = WAITING_FOR_PREVIEW_WINDOW;
504            break;
505    }
506
507    if (mPreviewStreamId != NO_STREAM) {
508        res = mDevice->waitUntilDrained();
509        if (res != OK) {
510            ALOGE("%s: Error waiting for preview to drain: %s (%d)",
511                    __FUNCTION__, strerror(-res), res);
512            return res;
513        }
514        res = mDevice->deleteStream(mPreviewStreamId);
515        if (res != OK) {
516            ALOGE("%s: Unable to delete old preview stream: %s (%d)",
517                    __FUNCTION__, strerror(-res), res);
518            return res;
519        }
520        mPreviewStreamId = NO_STREAM;
521    }
522
523    mPreviewSurface = binder;
524    mPreviewWindow = window;
525
526    if (mState == WAITING_FOR_PREVIEW_WINDOW) {
527        return startPreviewL();
528    }
529
530    return OK;
531}
532
533void Camera2Client::setPreviewCallbackFlag(int flag) {
534    ATRACE_CALL();
535    Mutex::Autolock icl(mICameraLock);
536    status_t res;
537    if ( (res = checkPid(__FUNCTION__) ) != OK) return;
538}
539
540status_t Camera2Client::startPreview() {
541    ATRACE_CALL();
542    ALOGV("%s: E", __FUNCTION__);
543    Mutex::Autolock icl(mICameraLock);
544    status_t res;
545    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
546    return startPreviewL();
547}
548
549status_t Camera2Client::startPreviewL() {
550    ATRACE_CALL();
551    status_t res;
552    if (mState >= PREVIEW) {
553        ALOGE("%s: Can't start preview in state %s",
554                __FUNCTION__, getStateName(mState));
555        return INVALID_OPERATION;
556    }
557
558    if (mPreviewWindow == 0) {
559        mState = WAITING_FOR_PREVIEW_WINDOW;
560        return OK;
561    }
562    mState = STOPPED;
563
564    LockedParameters::Key k(mParameters);
565
566    res = updatePreviewStream(k.mParameters);
567    if (res != OK) {
568        ALOGE("%s: Camera %d: Unable to update preview stream: %s (%d)",
569                __FUNCTION__, mCameraId, strerror(-res), res);
570        return res;
571    }
572
573    if (mPreviewRequest == NULL) {
574        res = updatePreviewRequest(k.mParameters);
575        if (res != OK) {
576            ALOGE("%s: Camera %d: Unable to create preview request: %s (%d)",
577                    __FUNCTION__, mCameraId, strerror(-res), res);
578            return res;
579        }
580    }
581
582    res = updateEntry(mPreviewRequest,
583            ANDROID_REQUEST_OUTPUT_STREAMS,
584            &mPreviewStreamId, 1);
585    if (res != OK) {
586        ALOGE("%s: Camera %d: Unable to set up preview request: %s (%d)",
587                __FUNCTION__, mCameraId, strerror(-res), res);
588        return res;
589    }
590    res = sort_camera_metadata(mPreviewRequest);
591    if (res != OK) {
592        ALOGE("%s: Camera %d: Error sorting preview request: %s (%d)",
593                __FUNCTION__, mCameraId, strerror(-res), res);
594        return res;
595    }
596
597    res = mDevice->setStreamingRequest(mPreviewRequest);
598    if (res != OK) {
599        ALOGE("%s: Camera %d: Unable to set preview request to start preview: "
600                "%s (%d)",
601                __FUNCTION__, mCameraId, strerror(-res), res);
602        return res;
603    }
604    mState = PREVIEW;
605
606    return OK;
607}
608
609void Camera2Client::stopPreview() {
610    ATRACE_CALL();
611    ALOGV("%s: E", __FUNCTION__);
612    Mutex::Autolock icl(mICameraLock);
613    status_t res;
614    if ( (res = checkPid(__FUNCTION__) ) != OK) return;
615    stopPreviewL();
616}
617
618void Camera2Client::stopPreviewL() {
619    ATRACE_CALL();
620    switch (mState) {
621        case DISCONNECTED:
622            ALOGE("%s: Camera %d: Call before initialized",
623                    __FUNCTION__, mCameraId);
624            break;
625        case STOPPED:
626            break;
627        case STILL_CAPTURE:
628            ALOGE("%s: Camera %d: Cannot stop preview during still capture.",
629                    __FUNCTION__, mCameraId);
630            break;
631        case RECORD:
632            // TODO: Handle record stop here
633        case PREVIEW:
634            mDevice->setStreamingRequest(NULL);
635            mDevice->waitUntilDrained();
636        case WAITING_FOR_PREVIEW_WINDOW:
637            mState = STOPPED;
638            break;
639        default:
640            ALOGE("%s: Camera %d: Unknown state %d", __FUNCTION__, mCameraId,
641                    mState);
642    }
643}
644
645bool Camera2Client::previewEnabled() {
646    ATRACE_CALL();
647    Mutex::Autolock icl(mICameraLock);
648    status_t res;
649    if ( (res = checkPid(__FUNCTION__) ) != OK) return false;
650
651    return mState == PREVIEW;
652}
653
654status_t Camera2Client::storeMetaDataInBuffers(bool enabled) {
655    ATRACE_CALL();
656    Mutex::Autolock icl(mICameraLock);
657    status_t res;
658    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
659
660    switch (mState) {
661        case RECORD:
662        case VIDEO_SNAPSHOT:
663            ALOGE("%s: Camera %d: Can't be called in state %s",
664                    __FUNCTION__, mCameraId, getStateName(mState));
665            return INVALID_OPERATION;
666        default:
667            // OK
668            break;
669    }
670    LockedParameters::Key k(mParameters);
671
672    k.mParameters.storeMetadataInBuffers = enabled;
673
674    return OK;
675}
676
677status_t Camera2Client::startRecording() {
678    ATRACE_CALL();
679    ALOGV("%s: E", __FUNCTION__);
680    Mutex::Autolock icl(mICameraLock);
681    status_t res;
682    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
683
684    switch (mState) {
685        case STOPPED:
686            res = startPreviewL();
687            if (res != OK) return res;
688            break;
689        case PREVIEW:
690            // Ready to go
691            break;
692        case RECORD:
693        case VIDEO_SNAPSHOT:
694            // OK to call this when recording is already on
695            return OK;
696            break;
697        default:
698            ALOGE("%s: Camera %d: Can't start recording in state %s",
699                    __FUNCTION__, mCameraId, getStateName(mState));
700            return INVALID_OPERATION;
701    };
702
703    LockedParameters::Key k(mParameters);
704
705    if (!k.mParameters.storeMetadataInBuffers) {
706        ALOGE("%s: Camera %d: Recording only supported in metadata mode, but "
707                "non-metadata recording mode requested!", __FUNCTION__,
708                mCameraId);
709        return INVALID_OPERATION;
710    }
711
712    res = updateRecordingStream(k.mParameters);
713    if (res != OK) {
714        ALOGE("%s: Camera %d: Unable to update recording stream: %s (%d)",
715                __FUNCTION__, mCameraId, strerror(-res), res);
716        return res;
717    }
718
719    if (mRecordingRequest == NULL) {
720        res = updateRecordingRequest(k.mParameters);
721        if (res != OK) {
722            ALOGE("%s: Camera %d: Unable to create recording request: %s (%d)",
723                    __FUNCTION__, mCameraId, strerror(-res), res);
724            return res;
725        }
726    }
727
728    uint8_t outputStreams[2] = { mPreviewStreamId, mRecordingStreamId };
729    res = updateEntry(mRecordingRequest,
730            ANDROID_REQUEST_OUTPUT_STREAMS,
731            outputStreams, 2);
732    if (res != OK) {
733        ALOGE("%s: Camera %d: Unable to set up recording request: %s (%d)",
734                __FUNCTION__, mCameraId, strerror(-res), res);
735        return res;
736    }
737    res = sort_camera_metadata(mRecordingRequest);
738    if (res != OK) {
739        ALOGE("%s: Camera %d: Error sorting recording request: %s (%d)",
740                __FUNCTION__, mCameraId, strerror(-res), res);
741        return res;
742    }
743
744    res = mDevice->setStreamingRequest(mRecordingRequest);
745    if (res != OK) {
746        ALOGE("%s: Camera %d: Unable to set recording request to start "
747                "recording: %s (%d)", __FUNCTION__, mCameraId,
748                strerror(-res), res);
749        return res;
750    }
751    mState = RECORD;
752
753    return OK;
754}
755
756void Camera2Client::stopRecording() {
757    ATRACE_CALL();
758    ALOGV("%s: E", __FUNCTION__);
759    Mutex::Autolock icl(mICameraLock);
760    status_t res;
761    if ( (res = checkPid(__FUNCTION__) ) != OK) return;
762
763    switch (mState) {
764        case RECORD:
765            // OK to stop
766            break;
767        case STOPPED:
768        case PREVIEW:
769        case STILL_CAPTURE:
770        case VIDEO_SNAPSHOT:
771        default:
772            ALOGE("%s: Camera %d: Can't stop recording in state %s",
773                    __FUNCTION__, mCameraId, getStateName(mState));
774            return;
775    };
776
777    // Back to preview. Since record can only be reached through preview,
778    // all preview stream setup should be up to date.
779    res = mDevice->setStreamingRequest(mPreviewRequest);
780    if (res != OK) {
781        ALOGE("%s: Camera %d: Unable to switch back to preview request: "
782                "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res);
783        return;
784    }
785
786    // TODO: Should recording heap be freed? Can't do it yet since requests
787    // could still be in flight.
788
789    mState = PREVIEW;
790}
791
792bool Camera2Client::recordingEnabled() {
793    ATRACE_CALL();
794    Mutex::Autolock icl(mICameraLock);
795    if ( checkPid(__FUNCTION__) != OK) return false;
796
797    return (mState == RECORD || mState == VIDEO_SNAPSHOT);
798}
799
800void Camera2Client::releaseRecordingFrame(const sp<IMemory>& mem) {
801    ATRACE_CALL();
802    Mutex::Autolock icl(mICameraLock);
803    status_t res;
804    if ( checkPid(__FUNCTION__) != OK) return;
805    // Make sure this is for the current heap
806    ssize_t offset;
807    size_t size;
808    sp<IMemoryHeap> heap = mem->getMemory(&offset, &size);
809    if (heap->getHeapID() != mRecordingHeap->mHeap->getHeapID()) {
810        ALOGW("%s: Camera %d: Mismatched heap ID, ignoring release "
811                "(got %x, expected %x)", __FUNCTION__, mCameraId,
812                heap->getHeapID(), mRecordingHeap->mHeap->getHeapID());
813        return;
814    }
815    uint8_t *data = (uint8_t*)heap->getBase() + offset;
816    uint32_t type = *(uint32_t*)data;
817    if (type != kMetadataBufferTypeGrallocSource) {
818        ALOGE("%s: Camera %d: Recording frame type invalid (got %x, expected %x)",
819                __FUNCTION__, mCameraId, type, kMetadataBufferTypeGrallocSource);
820        return;
821    }
822    buffer_handle_t imgBuffer = *(buffer_handle_t*)(data + 4);
823    ALOGV("%s: Camera %d: Freeing buffer_handle_t %p", __FUNCTION__, mCameraId,
824            imgBuffer);
825    res = mRecordingConsumer->freeBuffer(imgBuffer);
826    if (res != OK) {
827        ALOGE("%s: Camera %d: Unable to free recording frame (buffer_handle_t: %p):"
828                "%s (%d)",
829                __FUNCTION__, mCameraId, imgBuffer, strerror(-res), res);
830        return;
831    }
832
833    mRecordingHeapFree++;
834}
835
836status_t Camera2Client::autoFocus() {
837    ATRACE_CALL();
838    Mutex::Autolock icl(mICameraLock);
839    status_t res;
840    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
841
842    return OK;
843}
844
845status_t Camera2Client::cancelAutoFocus() {
846    ATRACE_CALL();
847    Mutex::Autolock icl(mICameraLock);
848    status_t res;
849    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
850
851    return OK;
852}
853
854status_t Camera2Client::takePicture(int msgType) {
855    ATRACE_CALL();
856    Mutex::Autolock icl(mICameraLock);
857    status_t res;
858    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
859
860    switch (mState) {
861        case DISCONNECTED:
862        case STOPPED:
863        case WAITING_FOR_PREVIEW_WINDOW:
864            ALOGE("%s: Camera %d: Cannot take picture without preview enabled",
865                    __FUNCTION__, mCameraId);
866            return INVALID_OPERATION;
867        case PREVIEW:
868        case RECORD:
869            // Good to go for takePicture
870            break;
871        case STILL_CAPTURE:
872        case VIDEO_SNAPSHOT:
873            ALOGE("%s: Camera %d: Already taking a picture",
874                    __FUNCTION__, mCameraId);
875            return INVALID_OPERATION;
876    }
877
878    LockedParameters::Key k(mParameters);
879
880    res = updateCaptureStream(k.mParameters);
881    if (res != OK) {
882        ALOGE("%s: Camera %d: Can't set up still image stream: %s (%d)",
883                __FUNCTION__, mCameraId, strerror(-res), res);
884        return res;
885    }
886
887    if (mCaptureRequest == NULL) {
888        res = updateCaptureRequest(k.mParameters);
889        if (res != OK) {
890            ALOGE("%s: Camera %d: Can't create still image capture request: "
891                    "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res);
892            return res;
893        }
894    }
895
896    camera_metadata_entry_t outputStreams;
897    if (mState == PREVIEW) {
898        uint8_t streamIds[2] = { mPreviewStreamId, mCaptureStreamId };
899        res = updateEntry(mCaptureRequest, ANDROID_REQUEST_OUTPUT_STREAMS,
900                &streamIds, 2);
901    } else if (mState == RECORD) {
902        uint8_t streamIds[3] = { mPreviewStreamId, mRecordingStreamId,
903                                 mCaptureStreamId };
904        res = updateEntry(mCaptureRequest, ANDROID_REQUEST_OUTPUT_STREAMS,
905                &streamIds, 3);
906    }
907
908    if (res != OK) {
909        ALOGE("%s: Camera %d: Unable to set up still image capture request: "
910                "%s (%d)",
911                __FUNCTION__, mCameraId, strerror(-res), res);
912        return res;
913    }
914    res = sort_camera_metadata(mCaptureRequest);
915    if (res != OK) {
916        ALOGE("%s: Camera %d: Unable to sort capture request: %s (%d)",
917                __FUNCTION__, mCameraId, strerror(-res), res);
918        return res;
919    }
920
921    camera_metadata_t *captureCopy = clone_camera_metadata(mCaptureRequest);
922    if (captureCopy == NULL) {
923        ALOGE("%s: Camera %d: Unable to copy capture request for HAL device",
924                __FUNCTION__, mCameraId);
925        return NO_MEMORY;
926    }
927
928    if (mState == PREVIEW) {
929        res = mDevice->setStreamingRequest(NULL);
930        if (res != OK) {
931            ALOGE("%s: Camera %d: Unable to stop preview for still capture: "
932                    "%s (%d)",
933                    __FUNCTION__, mCameraId, strerror(-res), res);
934            return res;
935        }
936    }
937    // TODO: Capture should be atomic with setStreamingRequest here
938    res = mDevice->capture(captureCopy);
939    if (res != OK) {
940        ALOGE("%s: Camera %d: Unable to submit still image capture request: "
941                "%s (%d)",
942                __FUNCTION__, mCameraId, strerror(-res), res);
943        return res;
944    }
945
946    switch (mState) {
947        case PREVIEW:
948            mState = STILL_CAPTURE;
949            break;
950        case RECORD:
951            mState = VIDEO_SNAPSHOT;
952            break;
953        default:
954            ALOGE("%s: Camera %d: Unknown state for still capture!",
955                    __FUNCTION__, mCameraId);
956            return INVALID_OPERATION;
957    }
958
959    return OK;
960}
961
962status_t Camera2Client::setParameters(const String8& params) {
963    ATRACE_CALL();
964    ALOGV("%s: E", __FUNCTION__);
965    Mutex::Autolock icl(mICameraLock);
966    status_t res;
967    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
968
969    LockedParameters::Key k(mParameters);
970
971    CameraParameters newParams(params);
972
973    // TODO: Currently ignoring any changes to supposedly read-only
974    // parameters such as supported preview sizes, etc. Should probably
975    // produce an error if they're changed.
976
977    /** Extract and verify new parameters */
978
979    size_t i;
980
981    // PREVIEW_SIZE
982    int previewWidth, previewHeight;
983    newParams.getPreviewSize(&previewWidth, &previewHeight);
984
985    if (previewWidth != k.mParameters.previewWidth ||
986            previewHeight != k.mParameters.previewHeight) {
987        if (mState >= PREVIEW) {
988            ALOGE("%s: Preview size cannot be updated when preview "
989                    "is active! (Currently %d x %d, requested %d x %d",
990                    __FUNCTION__,
991                    k.mParameters.previewWidth, k.mParameters.previewHeight,
992                    previewWidth, previewHeight);
993            return BAD_VALUE;
994        }
995        camera_metadata_entry_t availablePreviewSizes =
996            staticInfo(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES);
997        for (i = 0; i < availablePreviewSizes.count; i += 2 ) {
998            if (availablePreviewSizes.data.i32[i] == previewWidth &&
999                    availablePreviewSizes.data.i32[i+1] == previewHeight) break;
1000        }
1001        if (i == availablePreviewSizes.count) {
1002            ALOGE("%s: Requested preview size %d x %d is not supported",
1003                    __FUNCTION__, previewWidth, previewHeight);
1004            return BAD_VALUE;
1005        }
1006    }
1007
1008    // PREVIEW_FPS_RANGE
1009    int previewFpsRange[2];
1010    int previewFps = 0;
1011    bool fpsRangeChanged = false;
1012    newParams.getPreviewFpsRange(&previewFpsRange[0], &previewFpsRange[1]);
1013    if (previewFpsRange[0] != k.mParameters.previewFpsRange[0] ||
1014            previewFpsRange[1] != k.mParameters.previewFpsRange[1]) {
1015        fpsRangeChanged = true;
1016        camera_metadata_entry_t availablePreviewFpsRanges =
1017            staticInfo(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES, 2);
1018        for (i = 0; i < availablePreviewFpsRanges.count; i += 2) {
1019            if ((availablePreviewFpsRanges.data.i32[i] ==
1020                    previewFpsRange[0]) &&
1021                (availablePreviewFpsRanges.data.i32[i+1] ==
1022                    previewFpsRange[1]) ) {
1023                break;
1024            }
1025        }
1026        if (i == availablePreviewFpsRanges.count) {
1027            ALOGE("%s: Requested preview FPS range %d - %d is not supported",
1028                __FUNCTION__, previewFpsRange[0], previewFpsRange[1]);
1029            return BAD_VALUE;
1030        }
1031        previewFps = previewFpsRange[0];
1032    }
1033
1034    // PREVIEW_FORMAT
1035    int previewFormat = formatStringToEnum(newParams.getPreviewFormat());
1036    if (previewFormat != k.mParameters.previewFormat) {
1037        if (mState >= PREVIEW) {
1038            ALOGE("%s: Preview format cannot be updated when preview "
1039                    "is active!", __FUNCTION__);
1040            return BAD_VALUE;
1041        }
1042        camera_metadata_entry_t availableFormats =
1043            staticInfo(ANDROID_SCALER_AVAILABLE_FORMATS);
1044        for (i = 0; i < availableFormats.count; i++) {
1045            if (availableFormats.data.i32[i] == previewFormat) break;
1046        }
1047        if (i == availableFormats.count) {
1048            ALOGE("%s: Requested preview format %s (0x%x) is not supported",
1049                    __FUNCTION__, newParams.getPreviewFormat(), previewFormat);
1050            return BAD_VALUE;
1051        }
1052    }
1053
1054    // PREVIEW_FRAME_RATE
1055    // Deprecated, only use if the preview fps range is unchanged this time.
1056    // The single-value FPS is the same as the minimum of the range.
1057    if (!fpsRangeChanged) {
1058        previewFps = newParams.getPreviewFrameRate();
1059        if (previewFps != k.mParameters.previewFps) {
1060            camera_metadata_entry_t availableFrameRates =
1061                staticInfo(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES);
1062            for (i = 0; i < availableFrameRates.count; i+=2) {
1063                if (availableFrameRates.data.i32[i] == previewFps) break;
1064            }
1065            if (i == availableFrameRates.count) {
1066                ALOGE("%s: Requested preview frame rate %d is not supported",
1067                        __FUNCTION__, previewFps);
1068                return BAD_VALUE;
1069            }
1070            previewFpsRange[0] = availableFrameRates.data.i32[i];
1071            previewFpsRange[1] = availableFrameRates.data.i32[i+1];
1072        }
1073    }
1074
1075    // PICTURE_SIZE
1076    int pictureWidth, pictureHeight;
1077    newParams.getPictureSize(&pictureWidth, &pictureHeight);
1078    if (pictureWidth == k.mParameters.pictureWidth ||
1079            pictureHeight == k.mParameters.pictureHeight) {
1080        camera_metadata_entry_t availablePictureSizes =
1081            staticInfo(ANDROID_SCALER_AVAILABLE_JPEG_SIZES);
1082        for (i = 0; i < availablePictureSizes.count; i+=2) {
1083            if (availablePictureSizes.data.i32[i] == pictureWidth &&
1084                    availablePictureSizes.data.i32[i+1] == pictureHeight) break;
1085        }
1086        if (i == availablePictureSizes.count) {
1087            ALOGE("%s: Requested picture size %d x %d is not supported",
1088                    __FUNCTION__, pictureWidth, pictureHeight);
1089            return BAD_VALUE;
1090        }
1091    }
1092
1093    // JPEG_THUMBNAIL_WIDTH/HEIGHT
1094    int jpegThumbSize[2];
1095    jpegThumbSize[0] =
1096            newParams.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH);
1097    jpegThumbSize[1] =
1098            newParams.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT);
1099    if (jpegThumbSize[0] != k.mParameters.jpegThumbSize[0] ||
1100            jpegThumbSize[1] != k.mParameters.jpegThumbSize[1]) {
1101        camera_metadata_entry_t availableJpegThumbSizes =
1102            staticInfo(ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES);
1103        for (i = 0; i < availableJpegThumbSizes.count; i+=2) {
1104            if (availableJpegThumbSizes.data.i32[i] == jpegThumbSize[0] &&
1105                    availableJpegThumbSizes.data.i32[i+1] == jpegThumbSize[1]) {
1106                break;
1107            }
1108        }
1109        if (i == availableJpegThumbSizes.count) {
1110            ALOGE("%s: Requested JPEG thumbnail size %d x %d is not supported",
1111                    __FUNCTION__, jpegThumbSize[0], jpegThumbSize[1]);
1112            return BAD_VALUE;
1113        }
1114    }
1115
1116    // JPEG_THUMBNAIL_QUALITY
1117    int jpegThumbQuality =
1118            newParams.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY);
1119    if (jpegThumbQuality < 0 || jpegThumbQuality > 100) {
1120        ALOGE("%s: Requested JPEG thumbnail quality %d is not supported",
1121                __FUNCTION__, jpegThumbQuality);
1122        return BAD_VALUE;
1123    }
1124
1125    // JPEG_QUALITY
1126    int jpegQuality =
1127            newParams.getInt(CameraParameters::KEY_JPEG_QUALITY);
1128    if (jpegQuality < 0 || jpegQuality > 100) {
1129        ALOGE("%s: Requested JPEG quality %d is not supported",
1130                __FUNCTION__, jpegQuality);
1131        return BAD_VALUE;
1132    }
1133
1134    // ROTATION
1135    int jpegRotation =
1136            newParams.getInt(CameraParameters::KEY_ROTATION);
1137    if (jpegRotation != 0 &&
1138            jpegRotation != 90 &&
1139            jpegRotation != 180 &&
1140            jpegRotation != 270) {
1141        ALOGE("%s: Requested picture rotation angle %d is not supported",
1142                __FUNCTION__, jpegRotation);
1143        return BAD_VALUE;
1144    }
1145
1146    // GPS
1147    bool gpsEnabled = false;
1148    double gpsCoordinates[3] = {0,0,0};
1149    int64_t gpsTimestamp = 0;
1150    String8 gpsProcessingMethod;
1151    const char *gpsLatStr =
1152            newParams.get(CameraParameters::KEY_GPS_LATITUDE);
1153    if (gpsLatStr != NULL) {
1154        const char *gpsLongStr =
1155                newParams.get(CameraParameters::KEY_GPS_LONGITUDE);
1156        const char *gpsAltitudeStr =
1157                newParams.get(CameraParameters::KEY_GPS_ALTITUDE);
1158        const char *gpsTimeStr =
1159                newParams.get(CameraParameters::KEY_GPS_TIMESTAMP);
1160        const char *gpsProcMethodStr =
1161                newParams.get(CameraParameters::KEY_GPS_PROCESSING_METHOD);
1162        if (gpsLongStr == NULL ||
1163                gpsAltitudeStr == NULL ||
1164                gpsTimeStr == NULL ||
1165                gpsProcMethodStr == NULL) {
1166            ALOGE("%s: Incomplete set of GPS parameters provided",
1167                    __FUNCTION__);
1168            return BAD_VALUE;
1169        }
1170        char *endPtr;
1171        errno = 0;
1172        gpsCoordinates[0] = strtod(gpsLatStr, &endPtr);
1173        if (errno || endPtr == gpsLatStr) {
1174            ALOGE("%s: Malformed GPS latitude: %s", __FUNCTION__, gpsLatStr);
1175            return BAD_VALUE;
1176        }
1177        errno = 0;
1178        gpsCoordinates[1] = strtod(gpsLongStr, &endPtr);
1179        if (errno || endPtr == gpsLongStr) {
1180            ALOGE("%s: Malformed GPS longitude: %s", __FUNCTION__, gpsLongStr);
1181            return BAD_VALUE;
1182        }
1183        errno = 0;
1184        gpsCoordinates[2] = strtod(gpsAltitudeStr, &endPtr);
1185        if (errno || endPtr == gpsAltitudeStr) {
1186            ALOGE("%s: Malformed GPS altitude: %s", __FUNCTION__,
1187                    gpsAltitudeStr);
1188            return BAD_VALUE;
1189        }
1190        errno = 0;
1191        gpsTimestamp = strtoll(gpsTimeStr, &endPtr, 10);
1192        if (errno || endPtr == gpsTimeStr) {
1193            ALOGE("%s: Malformed GPS timestamp: %s", __FUNCTION__, gpsTimeStr);
1194            return BAD_VALUE;
1195        }
1196        gpsProcessingMethod = gpsProcMethodStr;
1197
1198        gpsEnabled = true;
1199    }
1200
1201    // WHITE_BALANCE
1202    int wbMode = wbModeStringToEnum(
1203        newParams.get(CameraParameters::KEY_WHITE_BALANCE) );
1204    if (wbMode != k.mParameters.wbMode) {
1205        camera_metadata_entry_t availableWbModes =
1206            staticInfo(ANDROID_CONTROL_AWB_AVAILABLE_MODES);
1207        for (i = 0; i < availableWbModes.count; i++) {
1208            if (wbMode == availableWbModes.data.u8[i]) break;
1209        }
1210        if (i == availableWbModes.count) {
1211            ALOGE("%s: Requested white balance mode %s is not supported",
1212                    __FUNCTION__,
1213                    newParams.get(CameraParameters::KEY_WHITE_BALANCE));
1214            return BAD_VALUE;
1215        }
1216    }
1217
1218    // EFFECT
1219    int effectMode = effectModeStringToEnum(
1220        newParams.get(CameraParameters::KEY_EFFECT) );
1221    if (effectMode != k.mParameters.effectMode) {
1222        camera_metadata_entry_t availableEffectModes =
1223            staticInfo(ANDROID_CONTROL_AVAILABLE_EFFECTS);
1224        for (i = 0; i < availableEffectModes.count; i++) {
1225            if (effectMode == availableEffectModes.data.u8[i]) break;
1226        }
1227        if (i == availableEffectModes.count) {
1228            ALOGE("%s: Requested effect mode \"%s\" is not supported",
1229                    __FUNCTION__,
1230                    newParams.get(CameraParameters::KEY_EFFECT) );
1231            return BAD_VALUE;
1232        }
1233    }
1234
1235    // ANTIBANDING
1236    int antibandingMode = abModeStringToEnum(
1237        newParams.get(CameraParameters::KEY_ANTIBANDING) );
1238    if (antibandingMode != k.mParameters.antibandingMode) {
1239        camera_metadata_entry_t availableAbModes =
1240            staticInfo(ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES);
1241        for (i = 0; i < availableAbModes.count; i++) {
1242            if (antibandingMode == availableAbModes.data.u8[i]) break;
1243        }
1244        if (i == availableAbModes.count) {
1245            ALOGE("%s: Requested antibanding mode \"%s\" is not supported",
1246                    __FUNCTION__,
1247                    newParams.get(CameraParameters::KEY_ANTIBANDING));
1248            return BAD_VALUE;
1249        }
1250    }
1251
1252    // SCENE_MODE
1253    int sceneMode = sceneModeStringToEnum(
1254        newParams.get(CameraParameters::KEY_SCENE_MODE) );
1255    if (sceneMode != k.mParameters.sceneMode) {
1256        camera_metadata_entry_t availableSceneModes =
1257            staticInfo(ANDROID_CONTROL_AVAILABLE_SCENE_MODES);
1258        for (i = 0; i < availableSceneModes.count; i++) {
1259            if (sceneMode == availableSceneModes.data.u8[i]) break;
1260        }
1261        if (i == availableSceneModes.count) {
1262            ALOGE("%s: Requested scene mode \"%s\" is not supported",
1263                    __FUNCTION__,
1264                    newParams.get(CameraParameters::KEY_SCENE_MODE));
1265            return BAD_VALUE;
1266        }
1267    }
1268
1269    // FLASH_MODE
1270    Parameters::flashMode_t flashMode = flashModeStringToEnum(
1271        newParams.get(CameraParameters::KEY_FLASH_MODE) );
1272    if (flashMode != k.mParameters.flashMode) {
1273        camera_metadata_entry_t flashAvailable =
1274            staticInfo(ANDROID_FLASH_AVAILABLE, 1, 1);
1275        if (!flashAvailable.data.u8[0] &&
1276                flashMode != Parameters::FLASH_MODE_OFF) {
1277            ALOGE("%s: Requested flash mode \"%s\" is not supported: "
1278                    "No flash on device", __FUNCTION__,
1279                    newParams.get(CameraParameters::KEY_FLASH_MODE));
1280            return BAD_VALUE;
1281        } else if (flashMode == Parameters::FLASH_MODE_RED_EYE) {
1282            camera_metadata_entry_t availableAeModes =
1283                staticInfo(ANDROID_CONTROL_AE_AVAILABLE_MODES);
1284            for (i = 0; i < availableAeModes.count; i++) {
1285                if (flashMode == availableAeModes.data.u8[i]) break;
1286            }
1287            if (i == availableAeModes.count) {
1288                ALOGE("%s: Requested flash mode \"%s\" is not supported",
1289                        __FUNCTION__,
1290                        newParams.get(CameraParameters::KEY_FLASH_MODE));
1291                return BAD_VALUE;
1292            }
1293        } else if (flashMode == -1) {
1294            ALOGE("%s: Requested flash mode \"%s\" is unknown",
1295                    __FUNCTION__,
1296                    newParams.get(CameraParameters::KEY_FLASH_MODE));
1297            return BAD_VALUE;
1298        }
1299    }
1300
1301    // FOCUS_MODE
1302    Parameters::focusMode_t focusMode = focusModeStringToEnum(
1303        newParams.get(CameraParameters::KEY_FOCUS_MODE));
1304    if (focusMode != k.mParameters.focusMode) {
1305        if (focusMode != Parameters::FOCUS_MODE_FIXED) {
1306            camera_metadata_entry_t minFocusDistance =
1307                staticInfo(ANDROID_LENS_MINIMUM_FOCUS_DISTANCE);
1308            if (minFocusDistance.data.f[0] == 0) {
1309                ALOGE("%s: Requested focus mode \"%s\" is not available: "
1310                        "fixed focus lens",
1311                        __FUNCTION__,
1312                        newParams.get(CameraParameters::KEY_FOCUS_MODE));
1313                return BAD_VALUE;
1314            } else if (focusMode != Parameters::FOCUS_MODE_INFINITY) {
1315                camera_metadata_entry_t availableFocusModes =
1316                    staticInfo(ANDROID_CONTROL_AF_AVAILABLE_MODES);
1317                for (i = 0; i < availableFocusModes.count; i++) {
1318                    if (focusMode == availableFocusModes.data.u8[i]) break;
1319                }
1320                if (i == availableFocusModes.count) {
1321                    ALOGE("%s: Requested focus mode \"%s\" is not supported",
1322                            __FUNCTION__,
1323                            newParams.get(CameraParameters::KEY_FOCUS_MODE));
1324                    return BAD_VALUE;
1325                }
1326            }
1327        }
1328    }
1329
1330    // FOCUS_AREAS
1331    Vector<Parameters::Area> focusingAreas;
1332    res = parseAreas(newParams.get(CameraParameters::KEY_FOCUS_AREAS),
1333            &focusingAreas);
1334    size_t max3aRegions =
1335        (size_t)staticInfo(ANDROID_CONTROL_MAX_REGIONS, 1, 1).data.i32[0];
1336    if (res == OK) res = validateAreas(focusingAreas, max3aRegions);
1337    if (res != OK) {
1338        ALOGE("%s: Requested focus areas are malformed: %s",
1339                __FUNCTION__, newParams.get(CameraParameters::KEY_FOCUS_AREAS));
1340        return BAD_VALUE;
1341    }
1342
1343    // EXPOSURE_COMPENSATION
1344    int exposureCompensation =
1345        newParams.getInt(CameraParameters::KEY_EXPOSURE_COMPENSATION);
1346    camera_metadata_entry_t exposureCompensationRange =
1347        staticInfo(ANDROID_CONTROL_AE_EXP_COMPENSATION_RANGE);
1348    if (exposureCompensation < exposureCompensationRange.data.i32[0] ||
1349            exposureCompensation > exposureCompensationRange.data.i32[1]) {
1350        ALOGE("%s: Requested exposure compensation index is out of bounds: %d",
1351                __FUNCTION__, exposureCompensation);
1352        return BAD_VALUE;
1353    }
1354
1355    // AUTO_EXPOSURE_LOCK (always supported)
1356    bool autoExposureLock = boolFromString(
1357        newParams.get(CameraParameters::KEY_AUTO_EXPOSURE_LOCK));
1358
1359    // AUTO_WHITEBALANCE_LOCK (always supported)
1360    bool autoWhiteBalanceLock = boolFromString(
1361        newParams.get(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK));
1362
1363    // METERING_AREAS
1364    Vector<Parameters::Area> meteringAreas;
1365    res = parseAreas(newParams.get(CameraParameters::KEY_METERING_AREAS),
1366            &meteringAreas);
1367    if (res == OK) res = validateAreas(focusingAreas, max3aRegions);
1368    if (res != OK) {
1369        ALOGE("%s: Requested metering areas are malformed: %s",
1370                __FUNCTION__,
1371                newParams.get(CameraParameters::KEY_METERING_AREAS));
1372        return BAD_VALUE;
1373    }
1374
1375    // ZOOM
1376    int zoom = newParams.getInt(CameraParameters::KEY_ZOOM);
1377    if (zoom < 0 || zoom > (int)NUM_ZOOM_STEPS) {
1378        ALOGE("%s: Requested zoom level %d is not supported",
1379                __FUNCTION__, zoom);
1380        return BAD_VALUE;
1381    }
1382
1383    // VIDEO_SIZE
1384    int videoWidth, videoHeight;
1385    newParams.getVideoSize(&videoWidth, &videoHeight);
1386    if (videoWidth != k.mParameters.videoWidth ||
1387            videoHeight != k.mParameters.videoHeight) {
1388        if (mState == RECORD) {
1389            ALOGE("%s: Video size cannot be updated when recording is active!",
1390                    __FUNCTION__);
1391            return BAD_VALUE;
1392        }
1393        camera_metadata_entry_t availableVideoSizes =
1394            staticInfo(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES);
1395        for (i = 0; i < availableVideoSizes.count; i += 2 ) {
1396            if (availableVideoSizes.data.i32[i] == videoWidth &&
1397                    availableVideoSizes.data.i32[i+1] == videoHeight)  break;
1398        }
1399        if (i == availableVideoSizes.count) {
1400            ALOGE("%s: Requested video size %d x %d is not supported",
1401                    __FUNCTION__, videoWidth, videoHeight);
1402            return BAD_VALUE;
1403        }
1404    }
1405
1406    // RECORDING_HINT (always supported)
1407    bool recordingHint = boolFromString(
1408        newParams.get(CameraParameters::KEY_RECORDING_HINT) );
1409
1410    // VIDEO_STABILIZATION
1411    bool videoStabilization = boolFromString(
1412        newParams.get(CameraParameters::KEY_VIDEO_STABILIZATION) );
1413    camera_metadata_entry_t availableVideoStabilizationModes =
1414        staticInfo(ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES);
1415    if (videoStabilization && availableVideoStabilizationModes.count == 1) {
1416        ALOGE("%s: Video stabilization not supported", __FUNCTION__);
1417    }
1418
1419    /** Update internal parameters */
1420
1421    k.mParameters.previewWidth = previewWidth;
1422    k.mParameters.previewHeight = previewHeight;
1423    k.mParameters.previewFpsRange[0] = previewFpsRange[0];
1424    k.mParameters.previewFpsRange[1] = previewFpsRange[1];
1425    k.mParameters.previewFps = previewFps;
1426    k.mParameters.previewFormat = previewFormat;
1427
1428    k.mParameters.pictureWidth = pictureWidth;
1429    k.mParameters.pictureHeight = pictureHeight;
1430
1431    k.mParameters.jpegThumbSize[0] = jpegThumbSize[0];
1432    k.mParameters.jpegThumbSize[1] = jpegThumbSize[1];
1433    k.mParameters.jpegQuality = jpegQuality;
1434    k.mParameters.jpegThumbQuality = jpegThumbQuality;
1435
1436    k.mParameters.gpsEnabled = gpsEnabled;
1437    k.mParameters.gpsCoordinates[0] = gpsCoordinates[0];
1438    k.mParameters.gpsCoordinates[1] = gpsCoordinates[1];
1439    k.mParameters.gpsCoordinates[2] = gpsCoordinates[2];
1440    k.mParameters.gpsTimestamp = gpsTimestamp;
1441    k.mParameters.gpsProcessingMethod = gpsProcessingMethod;
1442
1443    k.mParameters.wbMode = wbMode;
1444    k.mParameters.effectMode = effectMode;
1445    k.mParameters.antibandingMode = antibandingMode;
1446    k.mParameters.sceneMode = sceneMode;
1447
1448    k.mParameters.flashMode = flashMode;
1449    k.mParameters.focusMode = focusMode;
1450
1451    k.mParameters.focusingAreas = focusingAreas;
1452    k.mParameters.exposureCompensation = exposureCompensation;
1453    k.mParameters.autoExposureLock = autoExposureLock;
1454    k.mParameters.autoWhiteBalanceLock = autoWhiteBalanceLock;
1455    k.mParameters.meteringAreas = meteringAreas;
1456    k.mParameters.zoom = zoom;
1457
1458    k.mParameters.videoWidth = videoWidth;
1459    k.mParameters.videoHeight = videoHeight;
1460
1461    k.mParameters.recordingHint = recordingHint;
1462    k.mParameters.videoStabilization = videoStabilization;
1463
1464    res = updatePreviewRequest(k.mParameters);
1465    if (res != OK) {
1466        ALOGE("%s: Camera %d: Unable to update preview request: %s (%d)",
1467                __FUNCTION__, mCameraId, strerror(-res), res);
1468        return res;
1469    }
1470    res = updateCaptureRequest(k.mParameters);
1471    if (res != OK) {
1472        ALOGE("%s: Camera %d: Unable to update capture request: %s (%d)",
1473                __FUNCTION__, mCameraId, strerror(-res), res);
1474        return res;
1475    }
1476
1477    res = updateRecordingRequest(k.mParameters);
1478    if (res != OK) {
1479        ALOGE("%s: Camera %d: Unable to update recording request: %s (%d)",
1480                __FUNCTION__, mCameraId, strerror(-res), res);
1481        return res;
1482    }
1483
1484    if (mState == PREVIEW) {
1485        res = mDevice->setStreamingRequest(mPreviewRequest);
1486        if (res != OK) {
1487            ALOGE("%s: Camera %d: Error streaming new preview request: %s (%d)",
1488                    __FUNCTION__, mCameraId, strerror(-res), res);
1489            return res;
1490        }
1491    } else if (mState == RECORD || mState == VIDEO_SNAPSHOT) {
1492        res = mDevice->setStreamingRequest(mRecordingRequest);
1493        if (res != OK) {
1494            ALOGE("%s: Camera %d: Error streaming new record request: %s (%d)",
1495                    __FUNCTION__, mCameraId, strerror(-res), res);
1496            return res;
1497        }
1498    }
1499
1500    k.mParameters.paramsFlattened = params;
1501
1502    return OK;
1503}
1504
1505String8 Camera2Client::getParameters() const {
1506    ATRACE_CALL();
1507    Mutex::Autolock icl(mICameraLock);
1508    if ( checkPid(__FUNCTION__) != OK) return String8();
1509
1510    LockedParameters::ReadKey k(mParameters);
1511
1512    // TODO: Deal with focus distances
1513    return k.mParameters.paramsFlattened;
1514}
1515
1516status_t Camera2Client::sendCommand(int32_t cmd, int32_t arg1, int32_t arg2) {
1517    ATRACE_CALL();
1518    Mutex::Autolock icl(mICameraLock);
1519    status_t res;
1520    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
1521
1522    ALOGV("%s: Camera %d: Command %d (%d, %d)", __FUNCTION__, mCameraId,
1523            cmd, arg1, arg2);
1524
1525    switch (cmd) {
1526        case CAMERA_CMD_START_SMOOTH_ZOOM:
1527            return commandStartSmoothZoomL();
1528        case CAMERA_CMD_STOP_SMOOTH_ZOOM:
1529            return commandStopSmoothZoomL();
1530        case CAMERA_CMD_SET_DISPLAY_ORIENTATION:
1531            return commandSetDisplayOrientationL(arg1);
1532        case CAMERA_CMD_ENABLE_SHUTTER_SOUND:
1533            return commandEnableShutterSoundL(arg1 == 1);
1534        case CAMERA_CMD_PLAY_RECORDING_SOUND:
1535            return commandPlayRecordingSoundL();
1536        case CAMERA_CMD_START_FACE_DETECTION:
1537            return commandStartFaceDetectionL(arg1);
1538        case CAMERA_CMD_STOP_FACE_DETECTION:
1539            return commandStopFaceDetectionL();
1540        case CAMERA_CMD_ENABLE_FOCUS_MOVE_MSG:
1541            return commandEnableFocusMoveMsgL(arg1 == 1);
1542        case CAMERA_CMD_PING:
1543            return commandPingL();
1544        case CAMERA_CMD_SET_VIDEO_BUFFER_COUNT:
1545            return commandSetVideoBufferCountL(arg1);
1546        default:
1547            ALOGE("%s: Unknown command %d (arguments %d, %d)",
1548                    __FUNCTION__, cmd, arg1, arg2);
1549            return BAD_VALUE;
1550    }
1551}
1552
1553status_t Camera2Client::commandStartSmoothZoomL() {
1554    ALOGE("%s: Unimplemented!", __FUNCTION__);
1555    return OK;
1556}
1557
1558status_t Camera2Client::commandStopSmoothZoomL() {
1559    ALOGE("%s: Unimplemented!", __FUNCTION__);
1560    return OK;
1561}
1562
1563status_t Camera2Client::commandSetDisplayOrientationL(int degrees) {
1564    LockedParameters::Key k(mParameters);
1565    int transform = degToTransform(degrees,
1566            mCameraFacing == CAMERA_FACING_FRONT);
1567    if (transform == -1) {
1568        ALOGE("%s: Camera %d: Error setting %d as display orientation value",
1569                __FUNCTION__, mCameraId, degrees);
1570        return BAD_VALUE;
1571    }
1572    if (transform != k.mParameters.previewTransform &&
1573            mPreviewStreamId != NO_STREAM) {
1574        mDevice->setStreamTransform(mPreviewStreamId, transform);
1575    }
1576    k.mParameters.previewTransform = transform;
1577    return OK;
1578}
1579
1580status_t Camera2Client::commandEnableShutterSoundL(bool enable) {
1581    LockedParameters::Key k(mParameters);
1582    if (enable) {
1583        k.mParameters.playShutterSound = true;
1584        return OK;
1585    }
1586
1587    // Disabling shutter sound may not be allowed. In that case only
1588    // allow the mediaserver process to disable the sound.
1589    char value[PROPERTY_VALUE_MAX];
1590    property_get("ro.camera.sound.forced", value, "0");
1591    if (strncmp(value, "0", 2) != 0) {
1592        // Disabling shutter sound is not allowed. Deny if the current
1593        // process is not mediaserver.
1594        if (getCallingPid() != getpid()) {
1595            ALOGE("Failed to disable shutter sound. Permission denied (pid %d)",
1596                    getCallingPid());
1597            return PERMISSION_DENIED;
1598        }
1599    }
1600
1601    k.mParameters.playShutterSound = false;
1602    return OK;
1603}
1604
1605status_t Camera2Client::commandPlayRecordingSoundL() {
1606    mCameraService->playSound(CameraService::SOUND_RECORDING);
1607    return OK;
1608}
1609
1610status_t Camera2Client::commandStartFaceDetectionL(int type) {
1611    ALOGE("%s: Unimplemented!", __FUNCTION__);
1612    return OK;
1613}
1614
1615status_t Camera2Client::commandStopFaceDetectionL() {
1616    ALOGE("%s: Unimplemented!", __FUNCTION__);
1617    return OK;
1618}
1619
1620status_t Camera2Client::commandEnableFocusMoveMsgL(bool enable) {
1621    ALOGE("%s: Unimplemented!", __FUNCTION__);
1622    return OK;
1623}
1624
1625status_t Camera2Client::commandPingL() {
1626    // Always ping back if access is proper and device is alive
1627    if (mState != DISCONNECTED) {
1628        return OK;
1629    } else {
1630        return NO_INIT;
1631    }
1632}
1633
1634status_t Camera2Client::commandSetVideoBufferCountL(size_t count) {
1635    if (recordingEnabled()) {
1636        ALOGE("%s: Camera %d: Error setting video buffer count after "
1637                "recording was started", __FUNCTION__, mCameraId);
1638        return INVALID_OPERATION;
1639    }
1640
1641    // 32 is the current upper limit on the video buffer count for BufferQueue
1642    if (count > 32) {
1643        ALOGE("%s: Camera %d: Error setting %d as video buffer count value",
1644                __FUNCTION__, mCameraId, count);
1645        return BAD_VALUE;
1646    }
1647
1648    // Need to reallocate memory for heap
1649    if (mRecordingHeapCount != count) {
1650        if  (mRecordingHeap != 0) {
1651            mRecordingHeap.clear();
1652            mRecordingHeap = NULL;
1653        }
1654        mRecordingHeapCount = count;
1655    }
1656
1657    return OK;
1658}
1659
1660/** Device-related methods */
1661
1662void Camera2Client::notifyError(int errorCode, int arg1, int arg2) {
1663    ALOGE("Error condition %d reported by HAL, arguments %d, %d", errorCode, arg1, arg2);
1664}
1665
1666void Camera2Client::notifyShutter(int frameNumber, nsecs_t timestamp) {
1667    ALOGV("%s: Shutter notification for frame %d at time %lld", __FUNCTION__,
1668            frameNumber, timestamp);
1669}
1670
1671void Camera2Client::notifyAutoFocus(uint8_t newState, int triggerId) {
1672    ALOGV("%s: Autofocus state now %d, last trigger %d",
1673            __FUNCTION__, newState, triggerId);
1674}
1675
1676void Camera2Client::notifyAutoExposure(uint8_t newState, int triggerId) {
1677    ALOGV("%s: Autoexposure state now %d, last trigger %d",
1678            __FUNCTION__, newState, triggerId);
1679}
1680
1681void Camera2Client::notifyAutoWhitebalance(uint8_t newState, int triggerId) {
1682    ALOGV("%s: Auto-whitebalance state now %d, last trigger %d",
1683            __FUNCTION__, newState, triggerId);
1684}
1685
1686void Camera2Client::onCaptureAvailable() {
1687    ATRACE_CALL();
1688    status_t res;
1689    sp<ICameraClient> currentClient;
1690    ALOGV("%s: Camera %d: Still capture available", __FUNCTION__, mCameraId);
1691
1692    CpuConsumer::LockedBuffer imgBuffer;
1693    {
1694        Mutex::Autolock icl(mICameraLock);
1695
1696        // TODO: Signal errors here upstream
1697        if (mState != STILL_CAPTURE && mState != VIDEO_SNAPSHOT) {
1698            ALOGE("%s: Camera %d: Still image produced unexpectedly!",
1699                    __FUNCTION__, mCameraId);
1700            return;
1701        }
1702
1703        res = mCaptureConsumer->lockNextBuffer(&imgBuffer);
1704        if (res != OK) {
1705            ALOGE("%s: Camera %d: Error receiving still image buffer: %s (%d)",
1706                    __FUNCTION__, mCameraId, strerror(-res), res);
1707            return;
1708        }
1709
1710        if (imgBuffer.format != HAL_PIXEL_FORMAT_BLOB) {
1711            ALOGE("%s: Camera %d: Unexpected format for still image: "
1712                    "%x, expected %x", __FUNCTION__, mCameraId,
1713                    imgBuffer.format,
1714                    HAL_PIXEL_FORMAT_BLOB);
1715            mCaptureConsumer->unlockBuffer(imgBuffer);
1716            return;
1717        }
1718
1719        // TODO: Optimize this to avoid memcopy
1720        void* captureMemory = mCaptureHeap->mHeap->getBase();
1721        size_t size = mCaptureHeap->mHeap->getSize();
1722        memcpy(captureMemory, imgBuffer.data, size);
1723
1724        mCaptureConsumer->unlockBuffer(imgBuffer);
1725
1726        currentClient = mCameraClient;
1727        switch (mState) {
1728            case STILL_CAPTURE:
1729                mState = STOPPED;
1730                break;
1731            case VIDEO_SNAPSHOT:
1732                mState = RECORD;
1733                break;
1734            default:
1735                ALOGE("%s: Camera %d: Unexpected state %d", __FUNCTION__,
1736                        mCameraId, mState);
1737                break;
1738        }
1739    }
1740    // Call outside mICameraLock to allow re-entrancy from notification
1741    if (currentClient != 0) {
1742        currentClient->dataCallback(CAMERA_MSG_COMPRESSED_IMAGE,
1743                mCaptureHeap->mBuffers[0], NULL);
1744    }
1745}
1746
1747void Camera2Client::onRecordingFrameAvailable() {
1748    ATRACE_CALL();
1749    status_t res;
1750    sp<ICameraClient> currentClient;
1751    size_t heapIdx = 0;
1752    nsecs_t timestamp;
1753    {
1754        Mutex::Autolock icl(mICameraLock);
1755        // TODO: Signal errors here upstream
1756        bool discardData = false;
1757        if (mState != RECORD && mState != VIDEO_SNAPSHOT) {
1758            ALOGV("%s: Camera %d: Discarding recording image buffers received after "
1759                    "recording done",
1760                    __FUNCTION__, mCameraId);
1761            discardData = true;
1762        }
1763
1764        buffer_handle_t imgBuffer;
1765        res = mRecordingConsumer->getNextBuffer(&imgBuffer, &timestamp);
1766        if (res != OK) {
1767            ALOGE("%s: Camera %d: Error receiving recording buffer: %s (%d)",
1768                    __FUNCTION__, mCameraId, strerror(-res), res);
1769            return;
1770        }
1771
1772        if (discardData) {
1773            mRecordingConsumer->freeBuffer(imgBuffer);
1774            return;
1775        }
1776
1777        if (mRecordingHeap == 0) {
1778            const size_t bufferSize = 4 + sizeof(buffer_handle_t);
1779            ALOGV("%s: Camera %d: Creating recording heap with %d buffers of "
1780                    "size %d bytes", __FUNCTION__, mCameraId,
1781                    mRecordingHeapCount, bufferSize);
1782            if (mRecordingHeap != 0) {
1783                ALOGV("%s: Camera %d: Previous heap has size %d "
1784                        "(new will be %d) bytes", __FUNCTION__, mCameraId,
1785                        mRecordingHeap->mHeap->getSize(),
1786                        bufferSize * mRecordingHeapCount);
1787            }
1788            // Need to allocate memory for heap
1789            mRecordingHeap.clear();
1790
1791            mRecordingHeap = new Camera2Heap(bufferSize, mRecordingHeapCount,
1792                    "Camera2Client::RecordingHeap");
1793            if (mRecordingHeap->mHeap->getSize() == 0) {
1794                ALOGE("%s: Camera %d: Unable to allocate memory for recording",
1795                        __FUNCTION__, mCameraId);
1796                mRecordingConsumer->freeBuffer(imgBuffer);
1797                return;
1798            }
1799            mRecordingHeapHead = 0;
1800            mRecordingHeapFree = mRecordingHeapCount;
1801        }
1802
1803        if ( mRecordingHeapFree == 0) {
1804            ALOGE("%s: Camera %d: No free recording buffers, dropping frame",
1805                    __FUNCTION__, mCameraId);
1806            mRecordingConsumer->freeBuffer(imgBuffer);
1807            return;
1808        }
1809        heapIdx = mRecordingHeapHead;
1810        mRecordingHeapHead = (mRecordingHeapHead + 1) % mRecordingHeapCount;
1811        mRecordingHeapFree--;
1812
1813        ALOGV("%s: Camera %d: Timestamp %lld",
1814                __FUNCTION__, mCameraId, timestamp);
1815
1816        ssize_t offset;
1817        size_t size;
1818        sp<IMemoryHeap> heap =
1819                mRecordingHeap->mBuffers[heapIdx]->getMemory(&offset,
1820                        &size);
1821
1822        uint8_t *data = (uint8_t*)heap->getBase() + offset;
1823        uint32_t type = kMetadataBufferTypeGrallocSource;
1824        memcpy(data, &type, 4);
1825        memcpy(data + 4, &imgBuffer, sizeof(buffer_handle_t));
1826        ALOGV("%s: Camera %d: Sending out buffer_handle_t %p",
1827                __FUNCTION__, mCameraId, imgBuffer);
1828        currentClient = mCameraClient;
1829    }
1830    // Call outside mICameraLock to allow re-entrancy from notification
1831    if (currentClient != 0) {
1832        currentClient->dataCallbackTimestamp(timestamp,
1833                CAMERA_MSG_VIDEO_FRAME,
1834                mRecordingHeap->mBuffers[heapIdx]);
1835    }
1836}
1837
1838camera_metadata_entry_t Camera2Client::staticInfo(uint32_t tag,
1839        size_t minCount, size_t maxCount) {
1840    status_t res;
1841    camera_metadata_entry_t entry;
1842    res = find_camera_metadata_entry(mDevice->info(),
1843            tag,
1844            &entry);
1845    if (CC_UNLIKELY( res != OK )) {
1846        const char* tagSection = get_camera_metadata_section_name(tag);
1847        if (tagSection == NULL) tagSection = "<unknown>";
1848        const char* tagName = get_camera_metadata_tag_name(tag);
1849        if (tagName == NULL) tagName = "<unknown>";
1850
1851        ALOGE("Error finding static metadata entry '%s.%s' (%x): %s (%d)",
1852                tagSection, tagName, tag, strerror(-res), res);
1853        entry.count = 0;
1854        entry.data.u8 = NULL;
1855    } else if (CC_UNLIKELY(
1856            (minCount != 0 && entry.count < minCount) ||
1857            (maxCount != 0 && entry.count > maxCount) ) ) {
1858        const char* tagSection = get_camera_metadata_section_name(tag);
1859        if (tagSection == NULL) tagSection = "<unknown>";
1860        const char* tagName = get_camera_metadata_tag_name(tag);
1861        if (tagName == NULL) tagName = "<unknown>";
1862        ALOGE("Malformed static metadata entry '%s.%s' (%x):"
1863                "Expected between %d and %d values, but got %d values",
1864                tagSection, tagName, tag, minCount, maxCount, entry.count);
1865        entry.count = 0;
1866        entry.data.u8 = NULL;
1867    }
1868
1869    return entry;
1870}
1871
1872/** Utility methods */
1873
1874
1875status_t Camera2Client::buildDefaultParameters() {
1876    ATRACE_CALL();
1877    LockedParameters::Key k(mParameters);
1878
1879    status_t res;
1880    CameraParameters params;
1881
1882    camera_metadata_entry_t availableProcessedSizes =
1883        staticInfo(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES, 2);
1884    if (!availableProcessedSizes.count) return NO_INIT;
1885
1886    // TODO: Pick more intelligently
1887    k.mParameters.previewWidth = availableProcessedSizes.data.i32[0];
1888    k.mParameters.previewHeight = availableProcessedSizes.data.i32[1];
1889    k.mParameters.videoWidth = k.mParameters.previewWidth;
1890    k.mParameters.videoHeight = k.mParameters.previewHeight;
1891
1892    params.setPreviewSize(k.mParameters.previewWidth, k.mParameters.previewHeight);
1893    params.setVideoSize(k.mParameters.videoWidth, k.mParameters.videoHeight);
1894    params.set(CameraParameters::KEY_PREFERRED_PREVIEW_SIZE_FOR_VIDEO,
1895            String8::format("%dx%d",
1896                    k.mParameters.previewWidth, k.mParameters.previewHeight));
1897    {
1898        String8 supportedPreviewSizes;
1899        for (size_t i=0; i < availableProcessedSizes.count; i += 2) {
1900            if (i != 0) supportedPreviewSizes += ",";
1901            supportedPreviewSizes += String8::format("%dx%d",
1902                    availableProcessedSizes.data.i32[i],
1903                    availableProcessedSizes.data.i32[i+1]);
1904        }
1905        params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES,
1906                supportedPreviewSizes);
1907        params.set(CameraParameters::KEY_SUPPORTED_VIDEO_SIZES,
1908                supportedPreviewSizes);
1909    }
1910
1911    camera_metadata_entry_t availableFpsRanges =
1912        staticInfo(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES, 2);
1913    if (!availableFpsRanges.count) return NO_INIT;
1914
1915    k.mParameters.previewFpsRange[0] = availableFpsRanges.data.i32[0];
1916    k.mParameters.previewFpsRange[1] = availableFpsRanges.data.i32[1];
1917
1918    params.set(CameraParameters::KEY_PREVIEW_FPS_RANGE,
1919            String8::format("%d,%d",
1920                    k.mParameters.previewFpsRange[0],
1921                    k.mParameters.previewFpsRange[1]));
1922
1923    {
1924        String8 supportedPreviewFpsRange;
1925        for (size_t i=0; i < availableFpsRanges.count; i += 2) {
1926            if (i != 0) supportedPreviewFpsRange += ",";
1927            supportedPreviewFpsRange += String8::format("(%d,%d)",
1928                    availableFpsRanges.data.i32[i],
1929                    availableFpsRanges.data.i32[i+1]);
1930        }
1931        params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE,
1932                supportedPreviewFpsRange);
1933    }
1934
1935    k.mParameters.previewFormat = HAL_PIXEL_FORMAT_YCrCb_420_SP;
1936    params.set(CameraParameters::KEY_PREVIEW_FORMAT,
1937            formatEnumToString(k.mParameters.previewFormat)); // NV21
1938
1939    k.mParameters.previewTransform = degToTransform(0,
1940            mCameraFacing == CAMERA_FACING_FRONT);
1941
1942    camera_metadata_entry_t availableFormats =
1943        staticInfo(ANDROID_SCALER_AVAILABLE_FORMATS);
1944
1945    {
1946        String8 supportedPreviewFormats;
1947        bool addComma = false;
1948        for (size_t i=0; i < availableFormats.count; i++) {
1949            if (addComma) supportedPreviewFormats += ",";
1950            addComma = true;
1951            switch (availableFormats.data.i32[i]) {
1952            case HAL_PIXEL_FORMAT_YCbCr_422_SP:
1953                supportedPreviewFormats +=
1954                    CameraParameters::PIXEL_FORMAT_YUV422SP;
1955                break;
1956            case HAL_PIXEL_FORMAT_YCrCb_420_SP:
1957                supportedPreviewFormats +=
1958                    CameraParameters::PIXEL_FORMAT_YUV420SP;
1959                break;
1960            case HAL_PIXEL_FORMAT_YCbCr_422_I:
1961                supportedPreviewFormats +=
1962                    CameraParameters::PIXEL_FORMAT_YUV422I;
1963                break;
1964            case HAL_PIXEL_FORMAT_YV12:
1965                supportedPreviewFormats +=
1966                    CameraParameters::PIXEL_FORMAT_YUV420P;
1967                break;
1968            case HAL_PIXEL_FORMAT_RGB_565:
1969                supportedPreviewFormats +=
1970                    CameraParameters::PIXEL_FORMAT_RGB565;
1971                break;
1972            case HAL_PIXEL_FORMAT_RGBA_8888:
1973                supportedPreviewFormats +=
1974                    CameraParameters::PIXEL_FORMAT_RGBA8888;
1975                break;
1976            // Not advertizing JPEG, RAW_SENSOR, etc, for preview formats
1977            case HAL_PIXEL_FORMAT_RAW_SENSOR:
1978            case HAL_PIXEL_FORMAT_BLOB:
1979                addComma = false;
1980                break;
1981
1982            default:
1983                ALOGW("%s: Camera %d: Unknown preview format: %x",
1984                        __FUNCTION__, mCameraId, availableFormats.data.i32[i]);
1985                addComma = false;
1986                break;
1987            }
1988        }
1989        params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS,
1990                supportedPreviewFormats);
1991    }
1992
1993    // PREVIEW_FRAME_RATE / SUPPORTED_PREVIEW_FRAME_RATES are deprecated, but
1994    // still have to do something sane for them
1995
1996    params.set(CameraParameters::KEY_PREVIEW_FRAME_RATE,
1997            k.mParameters.previewFpsRange[0]);
1998
1999    {
2000        String8 supportedPreviewFrameRates;
2001        for (size_t i=0; i < availableFpsRanges.count; i += 2) {
2002            if (i != 0) supportedPreviewFrameRates += ",";
2003            supportedPreviewFrameRates += String8::format("%d",
2004                    availableFpsRanges.data.i32[i]);
2005        }
2006        params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES,
2007                supportedPreviewFrameRates);
2008    }
2009
2010    camera_metadata_entry_t availableJpegSizes =
2011        staticInfo(ANDROID_SCALER_AVAILABLE_JPEG_SIZES, 2);
2012    if (!availableJpegSizes.count) return NO_INIT;
2013
2014    // TODO: Pick maximum
2015    k.mParameters.pictureWidth = availableJpegSizes.data.i32[0];
2016    k.mParameters.pictureHeight = availableJpegSizes.data.i32[1];
2017
2018    params.setPictureSize(k.mParameters.pictureWidth,
2019            k.mParameters.pictureHeight);
2020
2021    {
2022        String8 supportedPictureSizes;
2023        for (size_t i=0; i < availableJpegSizes.count; i += 2) {
2024            if (i != 0) supportedPictureSizes += ",";
2025            supportedPictureSizes += String8::format("%dx%d",
2026                    availableJpegSizes.data.i32[i],
2027                    availableJpegSizes.data.i32[i+1]);
2028        }
2029        params.set(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES,
2030                supportedPictureSizes);
2031    }
2032
2033    params.setPictureFormat(CameraParameters::PIXEL_FORMAT_JPEG);
2034    params.set(CameraParameters::KEY_SUPPORTED_PICTURE_FORMATS,
2035            CameraParameters::PIXEL_FORMAT_JPEG);
2036
2037    camera_metadata_entry_t availableJpegThumbnailSizes =
2038        staticInfo(ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES, 2);
2039    if (!availableJpegThumbnailSizes.count) return NO_INIT;
2040
2041    // TODO: Pick default thumbnail size sensibly
2042    k.mParameters.jpegThumbSize[0] = availableJpegThumbnailSizes.data.i32[0];
2043    k.mParameters.jpegThumbSize[1] = availableJpegThumbnailSizes.data.i32[1];
2044
2045    params.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH,
2046            k.mParameters.jpegThumbSize[0]);
2047    params.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT,
2048            k.mParameters.jpegThumbSize[1]);
2049
2050    {
2051        String8 supportedJpegThumbSizes;
2052        for (size_t i=0; i < availableJpegThumbnailSizes.count; i += 2) {
2053            if (i != 0) supportedJpegThumbSizes += ",";
2054            supportedJpegThumbSizes += String8::format("%dx%d",
2055                    availableJpegThumbnailSizes.data.i32[i],
2056                    availableJpegThumbnailSizes.data.i32[i+1]);
2057        }
2058        params.set(CameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES,
2059                supportedJpegThumbSizes);
2060    }
2061
2062    k.mParameters.jpegThumbQuality = 90;
2063    params.set(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY,
2064            k.mParameters.jpegThumbQuality);
2065    k.mParameters.jpegQuality = 90;
2066    params.set(CameraParameters::KEY_JPEG_QUALITY,
2067            k.mParameters.jpegQuality);
2068    k.mParameters.jpegRotation = 0;
2069    params.set(CameraParameters::KEY_ROTATION,
2070            k.mParameters.jpegRotation);
2071
2072    k.mParameters.gpsEnabled = false;
2073    k.mParameters.gpsProcessingMethod = "unknown";
2074    // GPS fields in CameraParameters are not set by implementation
2075
2076    k.mParameters.wbMode = ANDROID_CONTROL_AWB_AUTO;
2077    params.set(CameraParameters::KEY_WHITE_BALANCE,
2078            CameraParameters::WHITE_BALANCE_AUTO);
2079
2080    camera_metadata_entry_t availableWhiteBalanceModes =
2081        staticInfo(ANDROID_CONTROL_AWB_AVAILABLE_MODES);
2082    {
2083        String8 supportedWhiteBalance;
2084        bool addComma = false;
2085        for (size_t i=0; i < availableWhiteBalanceModes.count; i++) {
2086            if (addComma) supportedWhiteBalance += ",";
2087            addComma = true;
2088            switch (availableWhiteBalanceModes.data.u8[i]) {
2089            case ANDROID_CONTROL_AWB_AUTO:
2090                supportedWhiteBalance +=
2091                    CameraParameters::WHITE_BALANCE_AUTO;
2092                break;
2093            case ANDROID_CONTROL_AWB_INCANDESCENT:
2094                supportedWhiteBalance +=
2095                    CameraParameters::WHITE_BALANCE_INCANDESCENT;
2096                break;
2097            case ANDROID_CONTROL_AWB_FLUORESCENT:
2098                supportedWhiteBalance +=
2099                    CameraParameters::WHITE_BALANCE_FLUORESCENT;
2100                break;
2101            case ANDROID_CONTROL_AWB_WARM_FLUORESCENT:
2102                supportedWhiteBalance +=
2103                    CameraParameters::WHITE_BALANCE_WARM_FLUORESCENT;
2104                break;
2105            case ANDROID_CONTROL_AWB_DAYLIGHT:
2106                supportedWhiteBalance +=
2107                    CameraParameters::WHITE_BALANCE_DAYLIGHT;
2108                break;
2109            case ANDROID_CONTROL_AWB_CLOUDY_DAYLIGHT:
2110                supportedWhiteBalance +=
2111                    CameraParameters::WHITE_BALANCE_CLOUDY_DAYLIGHT;
2112                break;
2113            case ANDROID_CONTROL_AWB_TWILIGHT:
2114                supportedWhiteBalance +=
2115                    CameraParameters::WHITE_BALANCE_TWILIGHT;
2116                break;
2117            case ANDROID_CONTROL_AWB_SHADE:
2118                supportedWhiteBalance +=
2119                    CameraParameters::WHITE_BALANCE_SHADE;
2120                break;
2121            // Skipping values not mappable to v1 API
2122            case ANDROID_CONTROL_AWB_OFF:
2123                addComma = false;
2124                break;
2125            default:
2126                ALOGW("%s: Camera %d: Unknown white balance value: %d",
2127                        __FUNCTION__, mCameraId,
2128                        availableWhiteBalanceModes.data.u8[i]);
2129                addComma = false;
2130                break;
2131            }
2132        }
2133        params.set(CameraParameters::KEY_SUPPORTED_WHITE_BALANCE,
2134                supportedWhiteBalance);
2135    }
2136
2137    k.mParameters.effectMode = ANDROID_CONTROL_EFFECT_OFF;
2138    params.set(CameraParameters::KEY_EFFECT,
2139            CameraParameters::EFFECT_NONE);
2140
2141    camera_metadata_entry_t availableEffects =
2142        staticInfo(ANDROID_CONTROL_AVAILABLE_EFFECTS);
2143    if (!availableEffects.count) return NO_INIT;
2144    {
2145        String8 supportedEffects;
2146        bool addComma = false;
2147        for (size_t i=0; i < availableEffects.count; i++) {
2148            if (addComma) supportedEffects += ",";
2149            addComma = true;
2150            switch (availableEffects.data.u8[i]) {
2151                case ANDROID_CONTROL_EFFECT_OFF:
2152                    supportedEffects +=
2153                        CameraParameters::EFFECT_NONE;
2154                    break;
2155                case ANDROID_CONTROL_EFFECT_MONO:
2156                    supportedEffects +=
2157                        CameraParameters::EFFECT_MONO;
2158                    break;
2159                case ANDROID_CONTROL_EFFECT_NEGATIVE:
2160                    supportedEffects +=
2161                        CameraParameters::EFFECT_NEGATIVE;
2162                    break;
2163                case ANDROID_CONTROL_EFFECT_SOLARIZE:
2164                    supportedEffects +=
2165                        CameraParameters::EFFECT_SOLARIZE;
2166                    break;
2167                case ANDROID_CONTROL_EFFECT_SEPIA:
2168                    supportedEffects +=
2169                        CameraParameters::EFFECT_SEPIA;
2170                    break;
2171                case ANDROID_CONTROL_EFFECT_POSTERIZE:
2172                    supportedEffects +=
2173                        CameraParameters::EFFECT_POSTERIZE;
2174                    break;
2175                case ANDROID_CONTROL_EFFECT_WHITEBOARD:
2176                    supportedEffects +=
2177                        CameraParameters::EFFECT_WHITEBOARD;
2178                    break;
2179                case ANDROID_CONTROL_EFFECT_BLACKBOARD:
2180                    supportedEffects +=
2181                        CameraParameters::EFFECT_BLACKBOARD;
2182                    break;
2183                case ANDROID_CONTROL_EFFECT_AQUA:
2184                    supportedEffects +=
2185                        CameraParameters::EFFECT_AQUA;
2186                    break;
2187                default:
2188                    ALOGW("%s: Camera %d: Unknown effect value: %d",
2189                        __FUNCTION__, mCameraId, availableEffects.data.u8[i]);
2190                    addComma = false;
2191                    break;
2192            }
2193        }
2194        params.set(CameraParameters::KEY_SUPPORTED_EFFECTS, supportedEffects);
2195    }
2196
2197    k.mParameters.antibandingMode = ANDROID_CONTROL_AE_ANTIBANDING_AUTO;
2198    params.set(CameraParameters::KEY_ANTIBANDING,
2199            CameraParameters::ANTIBANDING_AUTO);
2200
2201    camera_metadata_entry_t availableAntibandingModes =
2202        staticInfo(ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES);
2203    if (!availableAntibandingModes.count) return NO_INIT;
2204    {
2205        String8 supportedAntibanding;
2206        bool addComma = false;
2207        for (size_t i=0; i < availableAntibandingModes.count; i++) {
2208            if (addComma) supportedAntibanding += ",";
2209            addComma = true;
2210            switch (availableAntibandingModes.data.u8[i]) {
2211                case ANDROID_CONTROL_AE_ANTIBANDING_OFF:
2212                    supportedAntibanding +=
2213                        CameraParameters::ANTIBANDING_OFF;
2214                    break;
2215                case ANDROID_CONTROL_AE_ANTIBANDING_50HZ:
2216                    supportedAntibanding +=
2217                        CameraParameters::ANTIBANDING_50HZ;
2218                    break;
2219                case ANDROID_CONTROL_AE_ANTIBANDING_60HZ:
2220                    supportedAntibanding +=
2221                        CameraParameters::ANTIBANDING_60HZ;
2222                    break;
2223                case ANDROID_CONTROL_AE_ANTIBANDING_AUTO:
2224                    supportedAntibanding +=
2225                        CameraParameters::ANTIBANDING_AUTO;
2226                    break;
2227                default:
2228                    ALOGW("%s: Camera %d: Unknown antibanding value: %d",
2229                        __FUNCTION__, mCameraId,
2230                            availableAntibandingModes.data.u8[i]);
2231                    addComma = false;
2232                    break;
2233            }
2234        }
2235        params.set(CameraParameters::KEY_SUPPORTED_ANTIBANDING,
2236                supportedAntibanding);
2237    }
2238
2239    k.mParameters.sceneMode = ANDROID_CONTROL_OFF;
2240    params.set(CameraParameters::KEY_SCENE_MODE,
2241            CameraParameters::SCENE_MODE_AUTO);
2242
2243    camera_metadata_entry_t availableSceneModes =
2244        staticInfo(ANDROID_CONTROL_AVAILABLE_SCENE_MODES);
2245    if (!availableSceneModes.count) return NO_INIT;
2246    {
2247        String8 supportedSceneModes(CameraParameters::SCENE_MODE_AUTO);
2248        bool addComma = true;
2249        bool noSceneModes = false;
2250        for (size_t i=0; i < availableSceneModes.count; i++) {
2251            if (addComma) supportedSceneModes += ",";
2252            addComma = true;
2253            switch (availableSceneModes.data.u8[i]) {
2254                case ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED:
2255                    noSceneModes = true;
2256                    break;
2257                case ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY:
2258                    // Not in old API
2259                    addComma = false;
2260                    break;
2261                case ANDROID_CONTROL_SCENE_MODE_ACTION:
2262                    supportedSceneModes +=
2263                        CameraParameters::SCENE_MODE_ACTION;
2264                    break;
2265                case ANDROID_CONTROL_SCENE_MODE_PORTRAIT:
2266                    supportedSceneModes +=
2267                        CameraParameters::SCENE_MODE_PORTRAIT;
2268                    break;
2269                case ANDROID_CONTROL_SCENE_MODE_LANDSCAPE:
2270                    supportedSceneModes +=
2271                        CameraParameters::SCENE_MODE_LANDSCAPE;
2272                    break;
2273                case ANDROID_CONTROL_SCENE_MODE_NIGHT:
2274                    supportedSceneModes +=
2275                        CameraParameters::SCENE_MODE_NIGHT;
2276                    break;
2277                case ANDROID_CONTROL_SCENE_MODE_NIGHT_PORTRAIT:
2278                    supportedSceneModes +=
2279                        CameraParameters::SCENE_MODE_NIGHT_PORTRAIT;
2280                    break;
2281                case ANDROID_CONTROL_SCENE_MODE_THEATRE:
2282                    supportedSceneModes +=
2283                        CameraParameters::SCENE_MODE_THEATRE;
2284                    break;
2285                case ANDROID_CONTROL_SCENE_MODE_BEACH:
2286                    supportedSceneModes +=
2287                        CameraParameters::SCENE_MODE_BEACH;
2288                    break;
2289                case ANDROID_CONTROL_SCENE_MODE_SNOW:
2290                    supportedSceneModes +=
2291                        CameraParameters::SCENE_MODE_SNOW;
2292                    break;
2293                case ANDROID_CONTROL_SCENE_MODE_SUNSET:
2294                    supportedSceneModes +=
2295                        CameraParameters::SCENE_MODE_SUNSET;
2296                    break;
2297                case ANDROID_CONTROL_SCENE_MODE_STEADYPHOTO:
2298                    supportedSceneModes +=
2299                        CameraParameters::SCENE_MODE_STEADYPHOTO;
2300                    break;
2301                case ANDROID_CONTROL_SCENE_MODE_FIREWORKS:
2302                    supportedSceneModes +=
2303                        CameraParameters::SCENE_MODE_FIREWORKS;
2304                    break;
2305                case ANDROID_CONTROL_SCENE_MODE_SPORTS:
2306                    supportedSceneModes +=
2307                        CameraParameters::SCENE_MODE_SPORTS;
2308                    break;
2309                case ANDROID_CONTROL_SCENE_MODE_PARTY:
2310                    supportedSceneModes +=
2311                        CameraParameters::SCENE_MODE_PARTY;
2312                    break;
2313                case ANDROID_CONTROL_SCENE_MODE_CANDLELIGHT:
2314                    supportedSceneModes +=
2315                        CameraParameters::SCENE_MODE_CANDLELIGHT;
2316                    break;
2317                case ANDROID_CONTROL_SCENE_MODE_BARCODE:
2318                    supportedSceneModes +=
2319                        CameraParameters::SCENE_MODE_BARCODE;
2320                    break;
2321                default:
2322                    ALOGW("%s: Camera %d: Unknown scene mode value: %d",
2323                        __FUNCTION__, mCameraId,
2324                            availableSceneModes.data.u8[i]);
2325                    addComma = false;
2326                    break;
2327            }
2328        }
2329        if (!noSceneModes) {
2330            params.set(CameraParameters::KEY_SUPPORTED_SCENE_MODES,
2331                    supportedSceneModes);
2332        }
2333    }
2334
2335    camera_metadata_entry_t flashAvailable =
2336        staticInfo(ANDROID_FLASH_AVAILABLE, 1, 1);
2337    if (!flashAvailable.count) return NO_INIT;
2338
2339    camera_metadata_entry_t availableAeModes =
2340        staticInfo(ANDROID_CONTROL_AE_AVAILABLE_MODES);
2341    if (!availableAeModes.count) return NO_INIT;
2342
2343    if (flashAvailable.data.u8[0]) {
2344        k.mParameters.flashMode = Parameters::FLASH_MODE_AUTO;
2345        params.set(CameraParameters::KEY_FLASH_MODE,
2346                CameraParameters::FLASH_MODE_AUTO);
2347
2348        String8 supportedFlashModes(CameraParameters::FLASH_MODE_OFF);
2349        supportedFlashModes = supportedFlashModes +
2350            "," + CameraParameters::FLASH_MODE_AUTO +
2351            "," + CameraParameters::FLASH_MODE_ON +
2352            "," + CameraParameters::FLASH_MODE_TORCH;
2353        for (size_t i=0; i < availableAeModes.count; i++) {
2354            if (availableAeModes.data.u8[i] ==
2355                    ANDROID_CONTROL_AE_ON_AUTO_FLASH_REDEYE) {
2356                supportedFlashModes = supportedFlashModes + "," +
2357                    CameraParameters::FLASH_MODE_RED_EYE;
2358                break;
2359            }
2360        }
2361        params.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES,
2362                supportedFlashModes);
2363    } else {
2364        k.mParameters.flashMode = Parameters::FLASH_MODE_OFF;
2365        params.set(CameraParameters::KEY_FLASH_MODE,
2366                CameraParameters::FLASH_MODE_OFF);
2367        params.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES,
2368                CameraParameters::FLASH_MODE_OFF);
2369    }
2370
2371    camera_metadata_entry_t minFocusDistance =
2372        staticInfo(ANDROID_LENS_MINIMUM_FOCUS_DISTANCE, 1, 1);
2373    if (!minFocusDistance.count) return NO_INIT;
2374
2375    camera_metadata_entry_t availableAfModes =
2376        staticInfo(ANDROID_CONTROL_AF_AVAILABLE_MODES);
2377    if (!availableAfModes.count) return NO_INIT;
2378
2379    if (minFocusDistance.data.f[0] == 0) {
2380        // Fixed-focus lens
2381        k.mParameters.focusMode = Parameters::FOCUS_MODE_FIXED;
2382        params.set(CameraParameters::KEY_FOCUS_MODE,
2383                CameraParameters::FOCUS_MODE_FIXED);
2384        params.set(CameraParameters::KEY_SUPPORTED_FOCUS_MODES,
2385                CameraParameters::FOCUS_MODE_FIXED);
2386    } else {
2387        k.mParameters.focusMode = Parameters::FOCUS_MODE_AUTO;
2388        params.set(CameraParameters::KEY_FOCUS_MODE,
2389                CameraParameters::FOCUS_MODE_AUTO);
2390        String8 supportedFocusModes(CameraParameters::FOCUS_MODE_FIXED);
2391        supportedFocusModes = supportedFocusModes + "," +
2392            CameraParameters::FOCUS_MODE_INFINITY;
2393        bool addComma = true;
2394
2395        for (size_t i=0; i < availableAfModes.count; i++) {
2396            if (addComma) supportedFocusModes += ",";
2397            addComma = true;
2398            switch (availableAfModes.data.u8[i]) {
2399                case ANDROID_CONTROL_AF_AUTO:
2400                    supportedFocusModes +=
2401                        CameraParameters::FOCUS_MODE_AUTO;
2402                    break;
2403                case ANDROID_CONTROL_AF_MACRO:
2404                    supportedFocusModes +=
2405                        CameraParameters::FOCUS_MODE_MACRO;
2406                    break;
2407                case ANDROID_CONTROL_AF_CONTINUOUS_VIDEO:
2408                    supportedFocusModes +=
2409                        CameraParameters::FOCUS_MODE_CONTINUOUS_VIDEO;
2410                    break;
2411                case ANDROID_CONTROL_AF_CONTINUOUS_PICTURE:
2412                    supportedFocusModes +=
2413                        CameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE;
2414                    break;
2415                case ANDROID_CONTROL_AF_EDOF:
2416                    supportedFocusModes +=
2417                        CameraParameters::FOCUS_MODE_EDOF;
2418                    break;
2419                // Not supported in old API
2420                case ANDROID_CONTROL_AF_OFF:
2421                    addComma = false;
2422                    break;
2423                default:
2424                    ALOGW("%s: Camera %d: Unknown AF mode value: %d",
2425                        __FUNCTION__, mCameraId, availableAfModes.data.u8[i]);
2426                    addComma = false;
2427                    break;
2428            }
2429        }
2430        params.set(CameraParameters::KEY_SUPPORTED_FOCUS_MODES,
2431                supportedFocusModes);
2432    }
2433
2434    camera_metadata_entry_t max3aRegions =
2435        staticInfo(ANDROID_CONTROL_MAX_REGIONS, 1, 1);
2436    if (!max3aRegions.count) return NO_INIT;
2437
2438    params.set(CameraParameters::KEY_MAX_NUM_FOCUS_AREAS,
2439            max3aRegions.data.i32[0]);
2440    params.set(CameraParameters::KEY_FOCUS_AREAS,
2441            "(0,0,0,0,0)");
2442    k.mParameters.focusingAreas.clear();
2443    k.mParameters.focusingAreas.add(Parameters::Area(0,0,0,0,0));
2444
2445    camera_metadata_entry_t availableFocalLengths =
2446        staticInfo(ANDROID_LENS_AVAILABLE_FOCAL_LENGTHS);
2447    if (!availableFocalLengths.count) return NO_INIT;
2448
2449    float minFocalLength = availableFocalLengths.data.f[0];
2450    params.setFloat(CameraParameters::KEY_FOCAL_LENGTH, minFocalLength);
2451
2452    camera_metadata_entry_t sensorSize =
2453        staticInfo(ANDROID_SENSOR_PHYSICAL_SIZE, 2, 2);
2454    if (!sensorSize.count) return NO_INIT;
2455
2456    // The fields of view here assume infinity focus, maximum wide angle
2457    float horizFov = 180 / M_PI *
2458            2 * atanf(sensorSize.data.f[0] / (2 * minFocalLength));
2459    float vertFov  = 180 / M_PI *
2460            2 * atanf(sensorSize.data.f[1] / (2 * minFocalLength));
2461    params.setFloat(CameraParameters::KEY_HORIZONTAL_VIEW_ANGLE, horizFov);
2462    params.setFloat(CameraParameters::KEY_VERTICAL_VIEW_ANGLE, vertFov);
2463
2464    k.mParameters.exposureCompensation = 0;
2465    params.set(CameraParameters::KEY_EXPOSURE_COMPENSATION,
2466                k.mParameters.exposureCompensation);
2467
2468    camera_metadata_entry_t exposureCompensationRange =
2469        staticInfo(ANDROID_CONTROL_AE_EXP_COMPENSATION_RANGE, 2, 2);
2470    if (!exposureCompensationRange.count) return NO_INIT;
2471
2472    params.set(CameraParameters::KEY_MAX_EXPOSURE_COMPENSATION,
2473            exposureCompensationRange.data.i32[1]);
2474    params.set(CameraParameters::KEY_MIN_EXPOSURE_COMPENSATION,
2475            exposureCompensationRange.data.i32[0]);
2476
2477    camera_metadata_entry_t exposureCompensationStep =
2478        staticInfo(ANDROID_CONTROL_AE_EXP_COMPENSATION_STEP, 1, 1);
2479    if (!exposureCompensationStep.count) return NO_INIT;
2480
2481    params.setFloat(CameraParameters::KEY_EXPOSURE_COMPENSATION_STEP,
2482            (float)exposureCompensationStep.data.r[0].numerator /
2483            exposureCompensationStep.data.r[0].denominator);
2484
2485    k.mParameters.autoExposureLock = false;
2486    params.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK,
2487            CameraParameters::FALSE);
2488    params.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK_SUPPORTED,
2489            CameraParameters::TRUE);
2490
2491    k.mParameters.autoWhiteBalanceLock = false;
2492    params.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK,
2493            CameraParameters::FALSE);
2494    params.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK_SUPPORTED,
2495            CameraParameters::TRUE);
2496
2497    k.mParameters.meteringAreas.add(Parameters::Area(0, 0, 0, 0, 0));
2498    params.set(CameraParameters::KEY_MAX_NUM_METERING_AREAS,
2499            max3aRegions.data.i32[0]);
2500    params.set(CameraParameters::KEY_METERING_AREAS,
2501            "(0,0,0,0,0)");
2502
2503    k.mParameters.zoom = 0;
2504    params.set(CameraParameters::KEY_ZOOM, k.mParameters.zoom);
2505    params.set(CameraParameters::KEY_MAX_ZOOM, NUM_ZOOM_STEPS - 1);
2506
2507    camera_metadata_entry_t maxDigitalZoom =
2508        staticInfo(ANDROID_SCALER_AVAILABLE_MAX_ZOOM, 1, 1);
2509    if (!maxDigitalZoom.count) return NO_INIT;
2510
2511    {
2512        String8 zoomRatios;
2513        float zoom = 1.f;
2514        float zoomIncrement = (maxDigitalZoom.data.f[0] - zoom) /
2515                (NUM_ZOOM_STEPS-1);
2516        bool addComma = false;
2517        for (size_t i=0; i < NUM_ZOOM_STEPS; i++) {
2518            if (addComma) zoomRatios += ",";
2519            addComma = true;
2520            zoomRatios += String8::format("%d", static_cast<int>(zoom * 100));
2521            zoom += zoomIncrement;
2522        }
2523        params.set(CameraParameters::KEY_ZOOM_RATIOS, zoomRatios);
2524    }
2525
2526    params.set(CameraParameters::KEY_ZOOM_SUPPORTED,
2527            CameraParameters::TRUE);
2528    params.set(CameraParameters::KEY_SMOOTH_ZOOM_SUPPORTED,
2529            CameraParameters::TRUE);
2530
2531    params.set(CameraParameters::KEY_FOCUS_DISTANCES,
2532            "Infinity,Infinity,Infinity");
2533
2534    camera_metadata_entry_t maxFacesDetected =
2535        staticInfo(ANDROID_STATS_MAX_FACE_COUNT, 1, 1);
2536    params.set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_HW,
2537            maxFacesDetected.data.i32[0]);
2538    params.set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_SW,
2539            0);
2540
2541    params.set(CameraParameters::KEY_VIDEO_FRAME_FORMAT,
2542            CameraParameters::PIXEL_FORMAT_ANDROID_OPAQUE);
2543
2544    params.set(CameraParameters::KEY_RECORDING_HINT,
2545            CameraParameters::FALSE);
2546
2547    params.set(CameraParameters::KEY_VIDEO_SNAPSHOT_SUPPORTED,
2548            CameraParameters::TRUE);
2549
2550    params.set(CameraParameters::KEY_VIDEO_STABILIZATION,
2551            CameraParameters::FALSE);
2552
2553    camera_metadata_entry_t availableVideoStabilizationModes =
2554        staticInfo(ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES);
2555    if (!availableVideoStabilizationModes.count) return NO_INIT;
2556
2557    if (availableVideoStabilizationModes.count > 1) {
2558        params.set(CameraParameters::KEY_VIDEO_STABILIZATION_SUPPORTED,
2559                CameraParameters::TRUE);
2560    } else {
2561        params.set(CameraParameters::KEY_VIDEO_STABILIZATION_SUPPORTED,
2562                CameraParameters::FALSE);
2563    }
2564
2565    // Set up initial state for non-Camera.Parameters state variables
2566
2567    k.mParameters.storeMetadataInBuffers = true;
2568    k.mParameters.playShutterSound = true;
2569
2570    k.mParameters.paramsFlattened = params.flatten();
2571
2572    return OK;
2573}
2574
2575status_t Camera2Client::updatePreviewStream(const Parameters &params) {
2576    ATRACE_CALL();
2577    status_t res;
2578
2579    if (mPreviewStreamId != NO_STREAM) {
2580        // Check if stream parameters have to change
2581        uint32_t currentWidth, currentHeight;
2582        res = mDevice->getStreamInfo(mPreviewStreamId,
2583                &currentWidth, &currentHeight, 0);
2584        if (res != OK) {
2585            ALOGE("%s: Camera %d: Error querying preview stream info: "
2586                    "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res);
2587            return res;
2588        }
2589        if (currentWidth != (uint32_t)params.previewWidth ||
2590                currentHeight != (uint32_t)params.previewHeight) {
2591            ALOGV("%s: Camera %d: Preview size switch: %d x %d -> %d x %d",
2592                    __FUNCTION__, mCameraId, currentWidth, currentHeight,
2593                    params.previewWidth, params.previewHeight);
2594            res = mDevice->waitUntilDrained();
2595            if (res != OK) {
2596                ALOGE("%s: Camera %d: Error waiting for preview to drain: "
2597                        "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res);
2598                return res;
2599            }
2600            res = mDevice->deleteStream(mPreviewStreamId);
2601            if (res != OK) {
2602                ALOGE("%s: Camera %d: Unable to delete old output stream "
2603                        "for preview: %s (%d)", __FUNCTION__, mCameraId,
2604                        strerror(-res), res);
2605                return res;
2606            }
2607            mPreviewStreamId = NO_STREAM;
2608        }
2609    }
2610
2611    if (mPreviewStreamId == NO_STREAM) {
2612        res = mDevice->createStream(mPreviewWindow,
2613                params.previewWidth, params.previewHeight,
2614                CAMERA2_HAL_PIXEL_FORMAT_OPAQUE, 0,
2615                &mPreviewStreamId);
2616        if (res != OK) {
2617            ALOGE("%s: Camera %d: Unable to create preview stream: %s (%d)",
2618                    __FUNCTION__, mCameraId, strerror(-res), res);
2619            return res;
2620        }
2621    }
2622
2623    res = mDevice->setStreamTransform(mPreviewStreamId,
2624            params.previewTransform);
2625    if (res != OK) {
2626        ALOGE("%s: Camera %d: Unable to set preview stream transform: "
2627                "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res);
2628        return res;
2629    }
2630
2631    return OK;
2632}
2633
2634status_t Camera2Client::updatePreviewRequest(const Parameters &params) {
2635    ATRACE_CALL();
2636    status_t res;
2637    if (mPreviewRequest == NULL) {
2638        res = mDevice->createDefaultRequest(CAMERA2_TEMPLATE_PREVIEW,
2639                &mPreviewRequest);
2640        if (res != OK) {
2641            ALOGE("%s: Camera %d: Unable to create default preview request: "
2642                    "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res);
2643            return res;
2644        }
2645    }
2646
2647    res = updateRequestCommon(mPreviewRequest, params);
2648    if (res != OK) {
2649        ALOGE("%s: Camera %d: Unable to update common entries of preview "
2650                "request: %s (%d)", __FUNCTION__, mCameraId,
2651                strerror(-res), res);
2652        return res;
2653    }
2654
2655    return OK;
2656}
2657
2658status_t Camera2Client::updateCaptureStream(const Parameters &params) {
2659    ATRACE_CALL();
2660    status_t res;
2661    // Find out buffer size for JPEG
2662    camera_metadata_entry_t maxJpegSize =
2663            staticInfo(ANDROID_JPEG_MAX_SIZE);
2664    if (maxJpegSize.count == 0) {
2665        ALOGE("%s: Camera %d: Can't find ANDROID_JPEG_MAX_SIZE!",
2666                __FUNCTION__, mCameraId);
2667        return INVALID_OPERATION;
2668    }
2669
2670    if (mCaptureConsumer == 0) {
2671        // Create CPU buffer queue endpoint
2672        mCaptureConsumer = new CpuConsumer(1);
2673        mCaptureConsumer->setFrameAvailableListener(new CaptureWaiter(this));
2674        mCaptureConsumer->setName(String8("Camera2Client::CaptureConsumer"));
2675        mCaptureWindow = new SurfaceTextureClient(
2676            mCaptureConsumer->getProducerInterface());
2677        // Create memory for API consumption
2678        mCaptureHeap = new Camera2Heap(maxJpegSize.data.i32[0], 1,
2679                                       "Camera2Client::CaptureHeap");
2680        if (mCaptureHeap->mHeap->getSize() == 0) {
2681            ALOGE("%s: Camera %d: Unable to allocate memory for capture",
2682                    __FUNCTION__, mCameraId);
2683            return NO_MEMORY;
2684        }
2685    }
2686
2687    if (mCaptureStreamId != NO_STREAM) {
2688        // Check if stream parameters have to change
2689        uint32_t currentWidth, currentHeight;
2690        res = mDevice->getStreamInfo(mCaptureStreamId,
2691                &currentWidth, &currentHeight, 0);
2692        if (res != OK) {
2693            ALOGE("%s: Camera %d: Error querying capture output stream info: "
2694                    "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res);
2695            return res;
2696        }
2697        if (currentWidth != (uint32_t)params.pictureWidth ||
2698                currentHeight != (uint32_t)params.pictureHeight) {
2699            res = mDevice->deleteStream(mCaptureStreamId);
2700            if (res != OK) {
2701                ALOGE("%s: Camera %d: Unable to delete old output stream "
2702                        "for capture: %s (%d)", __FUNCTION__, mCameraId,
2703                        strerror(-res), res);
2704                return res;
2705            }
2706            mCaptureStreamId = NO_STREAM;
2707        }
2708    }
2709
2710    if (mCaptureStreamId == NO_STREAM) {
2711        // Create stream for HAL production
2712        res = mDevice->createStream(mCaptureWindow,
2713                params.pictureWidth, params.pictureHeight,
2714                HAL_PIXEL_FORMAT_BLOB, maxJpegSize.data.i32[0],
2715                &mCaptureStreamId);
2716        if (res != OK) {
2717            ALOGE("%s: Camera %d: Can't create output stream for capture: "
2718                    "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res);
2719            return res;
2720        }
2721
2722    }
2723    return OK;
2724}
2725
2726status_t Camera2Client::updateCaptureRequest(const Parameters &params) {
2727    ATRACE_CALL();
2728    status_t res;
2729    if (mCaptureRequest == NULL) {
2730        res = mDevice->createDefaultRequest(CAMERA2_TEMPLATE_STILL_CAPTURE,
2731                &mCaptureRequest);
2732        if (res != OK) {
2733            ALOGE("%s: Camera %d: Unable to create default still image request:"
2734                    " %s (%d)", __FUNCTION__, mCameraId, strerror(-res), res);
2735            return res;
2736        }
2737    }
2738
2739    res = updateRequestCommon(mCaptureRequest, params);
2740    if (res != OK) {
2741        ALOGE("%s: Camera %d: Unable to update common entries of capture "
2742                "request: %s (%d)", __FUNCTION__, mCameraId,
2743                strerror(-res), res);
2744        return res;
2745    }
2746
2747    res = updateEntry(mCaptureRequest,
2748            ANDROID_JPEG_THUMBNAIL_SIZE,
2749            params.jpegThumbSize, 2);
2750    if (res != OK) return res;
2751    res = updateEntry(mCaptureRequest,
2752            ANDROID_JPEG_THUMBNAIL_QUALITY,
2753            &params.jpegThumbQuality, 1);
2754    if (res != OK) return res;
2755    res = updateEntry(mCaptureRequest,
2756            ANDROID_JPEG_QUALITY,
2757            &params.jpegQuality, 1);
2758    if (res != OK) return res;
2759    res = updateEntry(mCaptureRequest,
2760            ANDROID_JPEG_ORIENTATION,
2761            &params.jpegRotation, 1);
2762    if (res != OK) return res;
2763
2764    if (params.gpsEnabled) {
2765        res = updateEntry(mCaptureRequest,
2766                ANDROID_JPEG_GPS_COORDINATES,
2767                params.gpsCoordinates, 3);
2768        if (res != OK) return res;
2769        res = updateEntry(mCaptureRequest,
2770                ANDROID_JPEG_GPS_TIMESTAMP,
2771                &params.gpsTimestamp, 1);
2772        if (res != OK) return res;
2773        res = updateEntry(mCaptureRequest,
2774                ANDROID_JPEG_GPS_PROCESSING_METHOD,
2775                params.gpsProcessingMethod.string(),
2776                params.gpsProcessingMethod.size());
2777        if (res != OK) return res;
2778    } else {
2779        res = deleteEntry(mCaptureRequest,
2780                ANDROID_JPEG_GPS_COORDINATES);
2781        if (res != OK) return res;
2782        res = deleteEntry(mCaptureRequest,
2783                ANDROID_JPEG_GPS_TIMESTAMP);
2784        if (res != OK) return res;
2785        res = deleteEntry(mCaptureRequest,
2786                ANDROID_JPEG_GPS_PROCESSING_METHOD);
2787        if (res != OK) return res;
2788    }
2789
2790    return OK;
2791}
2792
2793status_t Camera2Client::updateRecordingRequest(const Parameters &params) {
2794    ATRACE_CALL();
2795    status_t res;
2796    if (mRecordingRequest == NULL) {
2797        res = mDevice->createDefaultRequest(CAMERA2_TEMPLATE_VIDEO_RECORD,
2798                &mRecordingRequest);
2799        if (res != OK) {
2800            ALOGE("%s: Camera %d: Unable to create default recording request:"
2801                    " %s (%d)", __FUNCTION__, mCameraId, strerror(-res), res);
2802            return res;
2803        }
2804    }
2805
2806    res = updateRequestCommon(mRecordingRequest, params);
2807    if (res != OK) {
2808        ALOGE("%s: Camera %d: Unable to update common entries of recording "
2809                "request: %s (%d)", __FUNCTION__, mCameraId,
2810                strerror(-res), res);
2811        return res;
2812    }
2813
2814    return OK;
2815}
2816
2817status_t Camera2Client::updateRecordingStream(const Parameters &params) {
2818    status_t res;
2819
2820    if (mRecordingConsumer == 0) {
2821        // Create CPU buffer queue endpoint
2822        mRecordingConsumer = new MediaConsumer(mRecordingHeapCount);
2823        mRecordingConsumer->setFrameAvailableListener(new RecordingWaiter(this));
2824        mRecordingConsumer->setName(String8("Camera2Client::RecordingConsumer"));
2825        mRecordingWindow = new SurfaceTextureClient(
2826            mRecordingConsumer->getProducerInterface());
2827        // Allocate memory later, since we don't know buffer size until receipt
2828    }
2829
2830    if (mRecordingStreamId != NO_STREAM) {
2831        // Check if stream parameters have to change
2832        uint32_t currentWidth, currentHeight;
2833        res = mDevice->getStreamInfo(mRecordingStreamId,
2834                &currentWidth, &currentHeight, 0);
2835        if (res != OK) {
2836            ALOGE("%s: Camera %d: Error querying recording output stream info: "
2837                    "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res);
2838            return res;
2839        }
2840        if (currentWidth != (uint32_t)params.videoWidth ||
2841                currentHeight != (uint32_t)params.videoHeight) {
2842            // TODO: Should wait to be sure previous recording has finished
2843            res = mDevice->deleteStream(mRecordingStreamId);
2844            if (res != OK) {
2845                ALOGE("%s: Camera %d: Unable to delete old output stream "
2846                        "for recording: %s (%d)", __FUNCTION__, mCameraId,
2847                        strerror(-res), res);
2848                return res;
2849            }
2850            mRecordingStreamId = NO_STREAM;
2851        }
2852    }
2853
2854    if (mRecordingStreamId == NO_STREAM) {
2855        res = mDevice->createStream(mRecordingWindow,
2856                params.videoWidth, params.videoHeight,
2857                CAMERA2_HAL_PIXEL_FORMAT_OPAQUE, 0, &mRecordingStreamId);
2858        if (res != OK) {
2859            ALOGE("%s: Camera %d: Can't create output stream for recording: "
2860                    "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res);
2861            return res;
2862        }
2863    }
2864
2865    return OK;
2866}
2867
2868status_t Camera2Client::updateRequestCommon(camera_metadata_t *request,
2869        const Parameters &params) {
2870    ATRACE_CALL();
2871    status_t res;
2872    res = updateEntry(request,
2873            ANDROID_CONTROL_AE_TARGET_FPS_RANGE, params.previewFpsRange, 2);
2874    if (res != OK) return res;
2875
2876    uint8_t wbMode = params.autoWhiteBalanceLock ?
2877            ANDROID_CONTROL_AWB_LOCKED : params.wbMode;
2878    res = updateEntry(request,
2879            ANDROID_CONTROL_AWB_MODE, &wbMode, 1);
2880    if (res != OK) return res;
2881    res = updateEntry(request,
2882            ANDROID_CONTROL_EFFECT_MODE, &params.effectMode, 1);
2883    if (res != OK) return res;
2884    res = updateEntry(request,
2885            ANDROID_CONTROL_AE_ANTIBANDING_MODE,
2886            &params.antibandingMode, 1);
2887    if (res != OK) return res;
2888
2889    uint8_t controlMode =
2890            (params.sceneMode == ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED) ?
2891            ANDROID_CONTROL_AUTO : ANDROID_CONTROL_USE_SCENE_MODE;
2892    res = updateEntry(request,
2893            ANDROID_CONTROL_MODE, &controlMode, 1);
2894    if (res != OK) return res;
2895    if (controlMode == ANDROID_CONTROL_USE_SCENE_MODE) {
2896        res = updateEntry(request,
2897                ANDROID_CONTROL_SCENE_MODE,
2898                &params.sceneMode, 1);
2899        if (res != OK) return res;
2900    }
2901
2902    uint8_t flashMode = ANDROID_FLASH_OFF;
2903    uint8_t aeMode;
2904    switch (params.flashMode) {
2905        case Parameters::FLASH_MODE_OFF:
2906            aeMode = ANDROID_CONTROL_AE_ON; break;
2907        case Parameters::FLASH_MODE_AUTO:
2908            aeMode = ANDROID_CONTROL_AE_ON_AUTO_FLASH; break;
2909        case Parameters::FLASH_MODE_ON:
2910            aeMode = ANDROID_CONTROL_AE_ON_ALWAYS_FLASH; break;
2911        case Parameters::FLASH_MODE_TORCH:
2912            aeMode = ANDROID_CONTROL_AE_ON;
2913            flashMode = ANDROID_FLASH_TORCH;
2914            break;
2915        case Parameters::FLASH_MODE_RED_EYE:
2916            aeMode = ANDROID_CONTROL_AE_ON_AUTO_FLASH_REDEYE; break;
2917        default:
2918            ALOGE("%s: Camera %d: Unknown flash mode %d", __FUNCTION__,
2919                    mCameraId, params.flashMode);
2920            return BAD_VALUE;
2921    }
2922    if (params.autoExposureLock) aeMode = ANDROID_CONTROL_AE_LOCKED;
2923
2924    res = updateEntry(request,
2925            ANDROID_FLASH_MODE, &flashMode, 1);
2926    if (res != OK) return res;
2927    res = updateEntry(request,
2928            ANDROID_CONTROL_AE_MODE, &aeMode, 1);
2929    if (res != OK) return res;
2930
2931    float focusDistance = 0; // infinity focus in diopters
2932    uint8_t focusMode;
2933    switch (params.focusMode) {
2934        case Parameters::FOCUS_MODE_AUTO:
2935        case Parameters::FOCUS_MODE_MACRO:
2936        case Parameters::FOCUS_MODE_CONTINUOUS_VIDEO:
2937        case Parameters::FOCUS_MODE_CONTINUOUS_PICTURE:
2938        case Parameters::FOCUS_MODE_EDOF:
2939            focusMode = params.focusMode;
2940            break;
2941        case Parameters::FOCUS_MODE_INFINITY:
2942        case Parameters::FOCUS_MODE_FIXED:
2943            focusMode = ANDROID_CONTROL_AF_OFF;
2944            break;
2945        default:
2946            ALOGE("%s: Camera %d: Unknown focus mode %d", __FUNCTION__,
2947                    mCameraId, params.focusMode);
2948            return BAD_VALUE;
2949    }
2950    res = updateEntry(request,
2951            ANDROID_LENS_FOCUS_DISTANCE, &focusDistance, 1);
2952    if (res != OK) return res;
2953    res = updateEntry(request,
2954            ANDROID_CONTROL_AF_MODE, &focusMode, 1);
2955    if (res != OK) return res;
2956
2957    size_t focusingAreasSize = params.focusingAreas.size() * 5;
2958    int32_t *focusingAreas = new int32_t[focusingAreasSize];
2959    for (size_t i = 0; i < focusingAreasSize; i += 5) {
2960        focusingAreas[i + 0] = params.focusingAreas[i].left;
2961        focusingAreas[i + 1] = params.focusingAreas[i].top;
2962        focusingAreas[i + 2] = params.focusingAreas[i].right;
2963        focusingAreas[i + 3] = params.focusingAreas[i].bottom;
2964        focusingAreas[i + 4] = params.focusingAreas[i].weight;
2965    }
2966    res = updateEntry(request,
2967            ANDROID_CONTROL_AF_REGIONS, focusingAreas,focusingAreasSize);
2968    if (res != OK) return res;
2969    delete[] focusingAreas;
2970
2971    res = updateEntry(request,
2972            ANDROID_CONTROL_AE_EXP_COMPENSATION,
2973            &params.exposureCompensation, 1);
2974    if (res != OK) return res;
2975
2976    size_t meteringAreasSize = params.meteringAreas.size() * 5;
2977    int32_t *meteringAreas = new int32_t[meteringAreasSize];
2978    for (size_t i = 0; i < meteringAreasSize; i += 5) {
2979        meteringAreas[i + 0] = params.meteringAreas[i].left;
2980        meteringAreas[i + 1] = params.meteringAreas[i].top;
2981        meteringAreas[i + 2] = params.meteringAreas[i].right;
2982        meteringAreas[i + 3] = params.meteringAreas[i].bottom;
2983        meteringAreas[i + 4] = params.meteringAreas[i].weight;
2984    }
2985    res = updateEntry(request,
2986            ANDROID_CONTROL_AE_REGIONS, meteringAreas, meteringAreasSize);
2987    if (res != OK) return res;
2988
2989    res = updateEntry(request,
2990            ANDROID_CONTROL_AWB_REGIONS, meteringAreas, meteringAreasSize);
2991    if (res != OK) return res;
2992    delete[] meteringAreas;
2993
2994    // Need to convert zoom index into a crop rectangle. The rectangle is
2995    // chosen to maximize its area on the sensor
2996
2997    camera_metadata_entry_t maxDigitalZoom =
2998            staticInfo(ANDROID_SCALER_AVAILABLE_MAX_ZOOM);
2999    float zoomIncrement = (maxDigitalZoom.data.f[0] - 1) /
3000            (NUM_ZOOM_STEPS-1);
3001    float zoomRatio = 1 + zoomIncrement * params.zoom;
3002
3003    camera_metadata_entry_t activePixelArraySize =
3004            staticInfo(ANDROID_SENSOR_ACTIVE_ARRAY_SIZE, 2, 2);
3005    int32_t arrayWidth = activePixelArraySize.data.i32[0];
3006    int32_t arrayHeight = activePixelArraySize.data.i32[1];
3007    float zoomLeft, zoomTop, zoomWidth, zoomHeight;
3008    if (params.previewWidth >= params.previewHeight) {
3009        zoomWidth =  arrayWidth / zoomRatio;
3010        zoomHeight = zoomWidth *
3011                params.previewHeight / params.previewWidth;
3012    } else {
3013        zoomHeight = arrayHeight / zoomRatio;
3014        zoomWidth = zoomHeight *
3015                params.previewWidth / params.previewHeight;
3016    }
3017    zoomLeft = (arrayWidth - zoomWidth) / 2;
3018    zoomTop = (arrayHeight - zoomHeight) / 2;
3019
3020    int32_t cropRegion[3] = { zoomLeft, zoomTop, zoomWidth };
3021    res = updateEntry(request,
3022            ANDROID_SCALER_CROP_REGION, cropRegion, 3);
3023    if (res != OK) return res;
3024
3025    // TODO: Decide how to map recordingHint, or whether just to ignore it
3026
3027    uint8_t vstabMode = params.videoStabilization ?
3028            ANDROID_CONTROL_VIDEO_STABILIZATION_ON :
3029            ANDROID_CONTROL_VIDEO_STABILIZATION_OFF;
3030    res = updateEntry(request,
3031            ANDROID_CONTROL_VIDEO_STABILIZATION_MODE,
3032            &vstabMode, 1);
3033    if (res != OK) return res;
3034
3035    return OK;
3036}
3037
3038status_t Camera2Client::updateEntry(camera_metadata_t *buffer,
3039        uint32_t tag, const void *data, size_t data_count) {
3040    camera_metadata_entry_t entry;
3041    status_t res;
3042    res = find_camera_metadata_entry(buffer, tag, &entry);
3043    if (res == NAME_NOT_FOUND) {
3044        res = add_camera_metadata_entry(buffer,
3045                tag, data, data_count);
3046    } else if (res == OK) {
3047        res = update_camera_metadata_entry(buffer,
3048                entry.index, data, data_count, NULL);
3049    }
3050
3051    if (res != OK) {
3052        ALOGE("%s: Unable to update metadata entry %s.%s (%x): %s (%d)",
3053                __FUNCTION__, get_camera_metadata_section_name(tag),
3054                get_camera_metadata_tag_name(tag), tag, strerror(-res), res);
3055    }
3056    return res;
3057}
3058
3059status_t Camera2Client::deleteEntry(camera_metadata_t *buffer, uint32_t tag) {
3060    camera_metadata_entry_t entry;
3061    status_t res;
3062    res = find_camera_metadata_entry(buffer, tag, &entry);
3063    if (res == NAME_NOT_FOUND) {
3064        return OK;
3065    } else if (res != OK) {
3066        ALOGE("%s: Error looking for entry %s.%s (%x): %s %d",
3067                __FUNCTION__,
3068                get_camera_metadata_section_name(tag),
3069                get_camera_metadata_tag_name(tag), tag, strerror(-res), res);
3070        return res;
3071    }
3072    res = delete_camera_metadata_entry(buffer, entry.index);
3073    if (res != OK) {
3074        ALOGE("%s: Error deleting entry %s.%s (%x): %s %d",
3075                __FUNCTION__,
3076                get_camera_metadata_section_name(tag),
3077                get_camera_metadata_tag_name(tag), tag, strerror(-res), res);
3078    }
3079    return res;
3080}
3081
3082int Camera2Client::formatStringToEnum(const char *format) {
3083    return
3084        !strcmp(format, CameraParameters::PIXEL_FORMAT_YUV422SP) ?
3085            HAL_PIXEL_FORMAT_YCbCr_422_SP : // NV16
3086        !strcmp(format, CameraParameters::PIXEL_FORMAT_YUV420SP) ?
3087            HAL_PIXEL_FORMAT_YCrCb_420_SP : // NV21
3088        !strcmp(format, CameraParameters::PIXEL_FORMAT_YUV422I) ?
3089            HAL_PIXEL_FORMAT_YCbCr_422_I :  // YUY2
3090        !strcmp(format, CameraParameters::PIXEL_FORMAT_YUV420P) ?
3091            HAL_PIXEL_FORMAT_YV12 :         // YV12
3092        !strcmp(format, CameraParameters::PIXEL_FORMAT_RGB565) ?
3093            HAL_PIXEL_FORMAT_RGB_565 :      // RGB565
3094        !strcmp(format, CameraParameters::PIXEL_FORMAT_RGBA8888) ?
3095            HAL_PIXEL_FORMAT_RGBA_8888 :    // RGB8888
3096        !strcmp(format, CameraParameters::PIXEL_FORMAT_BAYER_RGGB) ?
3097            HAL_PIXEL_FORMAT_RAW_SENSOR :   // Raw sensor data
3098        -1;
3099}
3100
3101const char* Camera2Client::formatEnumToString(int format) {
3102    const char *fmt;
3103    switch(format) {
3104        case HAL_PIXEL_FORMAT_YCbCr_422_SP: // NV16
3105            fmt = CameraParameters::PIXEL_FORMAT_YUV422SP;
3106            break;
3107        case HAL_PIXEL_FORMAT_YCrCb_420_SP: // NV21
3108            fmt = CameraParameters::PIXEL_FORMAT_YUV420SP;
3109            break;
3110        case HAL_PIXEL_FORMAT_YCbCr_422_I: // YUY2
3111            fmt = CameraParameters::PIXEL_FORMAT_YUV422I;
3112            break;
3113        case HAL_PIXEL_FORMAT_YV12:        // YV12
3114            fmt = CameraParameters::PIXEL_FORMAT_YUV420P;
3115            break;
3116        case HAL_PIXEL_FORMAT_RGB_565:     // RGB565
3117            fmt = CameraParameters::PIXEL_FORMAT_RGB565;
3118            break;
3119        case HAL_PIXEL_FORMAT_RGBA_8888:   // RGBA8888
3120            fmt = CameraParameters::PIXEL_FORMAT_RGBA8888;
3121            break;
3122        case HAL_PIXEL_FORMAT_RAW_SENSOR:
3123            ALOGW("Raw sensor preview format requested.");
3124            fmt = CameraParameters::PIXEL_FORMAT_BAYER_RGGB;
3125            break;
3126        default:
3127            ALOGE("%s: Unknown preview format: %x",
3128                    __FUNCTION__,  format);
3129            fmt = NULL;
3130            break;
3131    }
3132    return fmt;
3133}
3134
3135int Camera2Client::wbModeStringToEnum(const char *wbMode) {
3136    return
3137        !strcmp(wbMode, CameraParameters::WHITE_BALANCE_AUTO) ?
3138            ANDROID_CONTROL_AWB_AUTO :
3139        !strcmp(wbMode, CameraParameters::WHITE_BALANCE_INCANDESCENT) ?
3140            ANDROID_CONTROL_AWB_INCANDESCENT :
3141        !strcmp(wbMode, CameraParameters::WHITE_BALANCE_FLUORESCENT) ?
3142            ANDROID_CONTROL_AWB_FLUORESCENT :
3143        !strcmp(wbMode, CameraParameters::WHITE_BALANCE_WARM_FLUORESCENT) ?
3144            ANDROID_CONTROL_AWB_WARM_FLUORESCENT :
3145        !strcmp(wbMode, CameraParameters::WHITE_BALANCE_DAYLIGHT) ?
3146            ANDROID_CONTROL_AWB_DAYLIGHT :
3147        !strcmp(wbMode, CameraParameters::WHITE_BALANCE_CLOUDY_DAYLIGHT) ?
3148            ANDROID_CONTROL_AWB_CLOUDY_DAYLIGHT :
3149        !strcmp(wbMode, CameraParameters::WHITE_BALANCE_TWILIGHT) ?
3150            ANDROID_CONTROL_AWB_TWILIGHT :
3151        !strcmp(wbMode, CameraParameters::WHITE_BALANCE_SHADE) ?
3152            ANDROID_CONTROL_AWB_SHADE :
3153        -1;
3154}
3155
3156int Camera2Client::effectModeStringToEnum(const char *effectMode) {
3157    return
3158        !strcmp(effectMode, CameraParameters::EFFECT_NONE) ?
3159            ANDROID_CONTROL_EFFECT_OFF :
3160        !strcmp(effectMode, CameraParameters::EFFECT_MONO) ?
3161            ANDROID_CONTROL_EFFECT_MONO :
3162        !strcmp(effectMode, CameraParameters::EFFECT_NEGATIVE) ?
3163            ANDROID_CONTROL_EFFECT_NEGATIVE :
3164        !strcmp(effectMode, CameraParameters::EFFECT_SOLARIZE) ?
3165            ANDROID_CONTROL_EFFECT_SOLARIZE :
3166        !strcmp(effectMode, CameraParameters::EFFECT_SEPIA) ?
3167            ANDROID_CONTROL_EFFECT_SEPIA :
3168        !strcmp(effectMode, CameraParameters::EFFECT_POSTERIZE) ?
3169            ANDROID_CONTROL_EFFECT_POSTERIZE :
3170        !strcmp(effectMode, CameraParameters::EFFECT_WHITEBOARD) ?
3171            ANDROID_CONTROL_EFFECT_WHITEBOARD :
3172        !strcmp(effectMode, CameraParameters::EFFECT_BLACKBOARD) ?
3173            ANDROID_CONTROL_EFFECT_BLACKBOARD :
3174        !strcmp(effectMode, CameraParameters::EFFECT_AQUA) ?
3175            ANDROID_CONTROL_EFFECT_AQUA :
3176        -1;
3177}
3178
3179int Camera2Client::abModeStringToEnum(const char *abMode) {
3180    return
3181        !strcmp(abMode, CameraParameters::ANTIBANDING_AUTO) ?
3182            ANDROID_CONTROL_AE_ANTIBANDING_AUTO :
3183        !strcmp(abMode, CameraParameters::ANTIBANDING_OFF) ?
3184            ANDROID_CONTROL_AE_ANTIBANDING_OFF :
3185        !strcmp(abMode, CameraParameters::ANTIBANDING_50HZ) ?
3186            ANDROID_CONTROL_AE_ANTIBANDING_50HZ :
3187        !strcmp(abMode, CameraParameters::ANTIBANDING_60HZ) ?
3188            ANDROID_CONTROL_AE_ANTIBANDING_60HZ :
3189        -1;
3190}
3191
3192int Camera2Client::sceneModeStringToEnum(const char *sceneMode) {
3193    return
3194        !strcmp(sceneMode, CameraParameters::SCENE_MODE_AUTO) ?
3195            ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED :
3196        !strcmp(sceneMode, CameraParameters::SCENE_MODE_ACTION) ?
3197            ANDROID_CONTROL_SCENE_MODE_ACTION :
3198        !strcmp(sceneMode, CameraParameters::SCENE_MODE_PORTRAIT) ?
3199            ANDROID_CONTROL_SCENE_MODE_PORTRAIT :
3200        !strcmp(sceneMode, CameraParameters::SCENE_MODE_LANDSCAPE) ?
3201            ANDROID_CONTROL_SCENE_MODE_LANDSCAPE :
3202        !strcmp(sceneMode, CameraParameters::SCENE_MODE_NIGHT) ?
3203            ANDROID_CONTROL_SCENE_MODE_NIGHT :
3204        !strcmp(sceneMode, CameraParameters::SCENE_MODE_NIGHT_PORTRAIT) ?
3205            ANDROID_CONTROL_SCENE_MODE_NIGHT_PORTRAIT :
3206        !strcmp(sceneMode, CameraParameters::SCENE_MODE_THEATRE) ?
3207            ANDROID_CONTROL_SCENE_MODE_THEATRE :
3208        !strcmp(sceneMode, CameraParameters::SCENE_MODE_BEACH) ?
3209            ANDROID_CONTROL_SCENE_MODE_BEACH :
3210        !strcmp(sceneMode, CameraParameters::SCENE_MODE_SNOW) ?
3211            ANDROID_CONTROL_SCENE_MODE_SNOW :
3212        !strcmp(sceneMode, CameraParameters::SCENE_MODE_SUNSET) ?
3213            ANDROID_CONTROL_SCENE_MODE_SUNSET :
3214        !strcmp(sceneMode, CameraParameters::SCENE_MODE_STEADYPHOTO) ?
3215            ANDROID_CONTROL_SCENE_MODE_STEADYPHOTO :
3216        !strcmp(sceneMode, CameraParameters::SCENE_MODE_FIREWORKS) ?
3217            ANDROID_CONTROL_SCENE_MODE_FIREWORKS :
3218        !strcmp(sceneMode, CameraParameters::SCENE_MODE_SPORTS) ?
3219            ANDROID_CONTROL_SCENE_MODE_SPORTS :
3220        !strcmp(sceneMode, CameraParameters::SCENE_MODE_PARTY) ?
3221            ANDROID_CONTROL_SCENE_MODE_PARTY :
3222        !strcmp(sceneMode, CameraParameters::SCENE_MODE_CANDLELIGHT) ?
3223            ANDROID_CONTROL_SCENE_MODE_CANDLELIGHT :
3224        !strcmp(sceneMode, CameraParameters::SCENE_MODE_BARCODE) ?
3225            ANDROID_CONTROL_SCENE_MODE_BARCODE:
3226        -1;
3227}
3228
3229Camera2Client::Parameters::flashMode_t Camera2Client::flashModeStringToEnum(
3230        const char *flashMode) {
3231    return
3232        !strcmp(flashMode, CameraParameters::FLASH_MODE_OFF) ?
3233            Parameters::FLASH_MODE_OFF :
3234        !strcmp(flashMode, CameraParameters::FLASH_MODE_AUTO) ?
3235            Parameters::FLASH_MODE_AUTO :
3236        !strcmp(flashMode, CameraParameters::FLASH_MODE_ON) ?
3237            Parameters::FLASH_MODE_ON :
3238        !strcmp(flashMode, CameraParameters::FLASH_MODE_RED_EYE) ?
3239            Parameters::FLASH_MODE_RED_EYE :
3240        !strcmp(flashMode, CameraParameters::FLASH_MODE_TORCH) ?
3241            Parameters::FLASH_MODE_TORCH :
3242        Parameters::FLASH_MODE_INVALID;
3243}
3244
3245Camera2Client::Parameters::focusMode_t Camera2Client::focusModeStringToEnum(
3246        const char *focusMode) {
3247    return
3248        !strcmp(focusMode, CameraParameters::FOCUS_MODE_AUTO) ?
3249            Parameters::FOCUS_MODE_AUTO :
3250        !strcmp(focusMode, CameraParameters::FOCUS_MODE_INFINITY) ?
3251            Parameters::FOCUS_MODE_INFINITY :
3252        !strcmp(focusMode, CameraParameters::FOCUS_MODE_MACRO) ?
3253            Parameters::FOCUS_MODE_MACRO :
3254        !strcmp(focusMode, CameraParameters::FOCUS_MODE_FIXED) ?
3255            Parameters::FOCUS_MODE_FIXED :
3256        !strcmp(focusMode, CameraParameters::FOCUS_MODE_EDOF) ?
3257            Parameters::FOCUS_MODE_EDOF :
3258        !strcmp(focusMode, CameraParameters::FOCUS_MODE_CONTINUOUS_VIDEO) ?
3259            Parameters::FOCUS_MODE_CONTINUOUS_VIDEO :
3260        !strcmp(focusMode, CameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE) ?
3261            Parameters::FOCUS_MODE_CONTINUOUS_PICTURE :
3262        Parameters::FOCUS_MODE_INVALID;
3263}
3264
3265status_t Camera2Client::parseAreas(const char *areasCStr,
3266        Vector<Parameters::Area> *areas) {
3267    static const size_t NUM_FIELDS = 5;
3268    areas->clear();
3269    if (areasCStr == NULL) {
3270        // If no key exists, use default (0,0,0,0,0)
3271        areas->push();
3272        return OK;
3273    }
3274    String8 areasStr(areasCStr);
3275    ssize_t areaStart = areasStr.find("(", 0) + 1;
3276    while (areaStart != 0) {
3277        const char* area = areasStr.string() + areaStart;
3278        char *numEnd;
3279        int vals[NUM_FIELDS];
3280        for (size_t i = 0; i < NUM_FIELDS; i++) {
3281            errno = 0;
3282            vals[i] = strtol(area, &numEnd, 10);
3283            if (errno || numEnd == area) return BAD_VALUE;
3284            area = numEnd + 1;
3285        }
3286        areas->push(Parameters::Area(
3287            vals[0], vals[1], vals[2], vals[3], vals[4]) );
3288        areaStart = areasStr.find("(", areaStart) + 1;
3289    }
3290    return OK;
3291}
3292
3293status_t Camera2Client::validateAreas(const Vector<Parameters::Area> &areas,
3294                                      size_t maxRegions) {
3295    // Definition of valid area can be found in
3296    // include/camera/CameraParameters.h
3297    if (areas.size() == 0) return BAD_VALUE;
3298    if (areas.size() == 1) {
3299        if (areas[0].left == 0 &&
3300                areas[0].top == 0 &&
3301                areas[0].right == 0 &&
3302                areas[0].bottom == 0 &&
3303                areas[0].weight == 0) {
3304            // Single (0,0,0,0,0) entry is always valid (== driver decides)
3305            return OK;
3306        }
3307    }
3308    if (areas.size() > maxRegions) {
3309        ALOGE("%s: Too many areas requested: %d",
3310                __FUNCTION__, areas.size());
3311        return BAD_VALUE;
3312    }
3313
3314    for (Vector<Parameters::Area>::const_iterator a = areas.begin();
3315         a != areas.end(); a++) {
3316        if (a->weight < 1 || a->weight > 1000) return BAD_VALUE;
3317        if (a->left < -1000 || a->left > 1000) return BAD_VALUE;
3318        if (a->top < -1000 || a->top > 1000) return BAD_VALUE;
3319        if (a->right < -1000 || a->right > 1000) return BAD_VALUE;
3320        if (a->bottom < -1000 || a->bottom > 1000) return BAD_VALUE;
3321        if (a->left >= a->right) return BAD_VALUE;
3322        if (a->top >= a->bottom) return BAD_VALUE;
3323    }
3324    return OK;
3325}
3326
3327bool Camera2Client::boolFromString(const char *boolStr) {
3328    return !boolStr ? false :
3329        !strcmp(boolStr, CameraParameters::TRUE) ? true :
3330        false;
3331}
3332
3333int Camera2Client::degToTransform(int degrees, bool mirror) {
3334    if (!mirror) {
3335        if (degrees == 0) return 0;
3336        else if (degrees == 90) return HAL_TRANSFORM_ROT_90;
3337        else if (degrees == 180) return HAL_TRANSFORM_ROT_180;
3338        else if (degrees == 270) return HAL_TRANSFORM_ROT_270;
3339    } else {  // Do mirror (horizontal flip)
3340        if (degrees == 0) {           // FLIP_H and ROT_0
3341            return HAL_TRANSFORM_FLIP_H;
3342        } else if (degrees == 90) {   // FLIP_H and ROT_90
3343            return HAL_TRANSFORM_FLIP_H | HAL_TRANSFORM_ROT_90;
3344        } else if (degrees == 180) {  // FLIP_H and ROT_180
3345            return HAL_TRANSFORM_FLIP_V;
3346        } else if (degrees == 270) {  // FLIP_H and ROT_270
3347            return HAL_TRANSFORM_FLIP_V | HAL_TRANSFORM_ROT_90;
3348        }
3349    }
3350    ALOGE("%s: Bad input: %d", __FUNCTION__, degrees);
3351    return -1;
3352}
3353
3354} // namespace android
3355