Camera2Client.cpp revision 8da4cd7d706d9f551bf2d08cd8b61907a10cd38d 
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
796    if ( checkPid(__FUNCTION__) != OK) return false;
797
798    return recordingEnabledL();
799}
800
801bool Camera2Client::recordingEnabledL() {
802    ATRACE_CALL();
803
804    return (mState == RECORD || mState == VIDEO_SNAPSHOT);
805}
806
807void Camera2Client::releaseRecordingFrame(const sp<IMemory>& mem) {
808    ATRACE_CALL();
809    Mutex::Autolock icl(mICameraLock);
810    status_t res;
811    if ( checkPid(__FUNCTION__) != OK) return;
812    // Make sure this is for the current heap
813    ssize_t offset;
814    size_t size;
815    sp<IMemoryHeap> heap = mem->getMemory(&offset, &size);
816    if (heap->getHeapID() != mRecordingHeap->mHeap->getHeapID()) {
817        ALOGW("%s: Camera %d: Mismatched heap ID, ignoring release "
818                "(got %x, expected %x)", __FUNCTION__, mCameraId,
819                heap->getHeapID(), mRecordingHeap->mHeap->getHeapID());
820        return;
821    }
822    uint8_t *data = (uint8_t*)heap->getBase() + offset;
823    uint32_t type = *(uint32_t*)data;
824    if (type != kMetadataBufferTypeGrallocSource) {
825        ALOGE("%s: Camera %d: Recording frame type invalid (got %x, expected %x)",
826                __FUNCTION__, mCameraId, type, kMetadataBufferTypeGrallocSource);
827        return;
828    }
829    buffer_handle_t imgBuffer = *(buffer_handle_t*)(data + 4);
830    ALOGV("%s: Camera %d: Freeing buffer_handle_t %p", __FUNCTION__, mCameraId,
831            imgBuffer);
832    res = mRecordingConsumer->freeBuffer(imgBuffer);
833    if (res != OK) {
834        ALOGE("%s: Camera %d: Unable to free recording frame (buffer_handle_t: %p):"
835                "%s (%d)",
836                __FUNCTION__, mCameraId, imgBuffer, strerror(-res), res);
837        return;
838    }
839
840    mRecordingHeapFree++;
841}
842
843status_t Camera2Client::autoFocus() {
844    ATRACE_CALL();
845    Mutex::Autolock icl(mICameraLock);
846    status_t res;
847    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
848
849    return OK;
850}
851
852status_t Camera2Client::cancelAutoFocus() {
853    ATRACE_CALL();
854    Mutex::Autolock icl(mICameraLock);
855    status_t res;
856    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
857
858    return OK;
859}
860
861status_t Camera2Client::takePicture(int msgType) {
862    ATRACE_CALL();
863    Mutex::Autolock icl(mICameraLock);
864    status_t res;
865    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
866
867    switch (mState) {
868        case DISCONNECTED:
869        case STOPPED:
870        case WAITING_FOR_PREVIEW_WINDOW:
871            ALOGE("%s: Camera %d: Cannot take picture without preview enabled",
872                    __FUNCTION__, mCameraId);
873            return INVALID_OPERATION;
874        case PREVIEW:
875        case RECORD:
876            // Good to go for takePicture
877            break;
878        case STILL_CAPTURE:
879        case VIDEO_SNAPSHOT:
880            ALOGE("%s: Camera %d: Already taking a picture",
881                    __FUNCTION__, mCameraId);
882            return INVALID_OPERATION;
883    }
884
885    LockedParameters::Key k(mParameters);
886
887    res = updateCaptureStream(k.mParameters);
888    if (res != OK) {
889        ALOGE("%s: Camera %d: Can't set up still image stream: %s (%d)",
890                __FUNCTION__, mCameraId, strerror(-res), res);
891        return res;
892    }
893
894    if (mCaptureRequest == NULL) {
895        res = updateCaptureRequest(k.mParameters);
896        if (res != OK) {
897            ALOGE("%s: Camera %d: Can't create still image capture request: "
898                    "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res);
899            return res;
900        }
901    }
902
903    camera_metadata_entry_t outputStreams;
904    if (mState == PREVIEW) {
905        uint8_t streamIds[2] = { mPreviewStreamId, mCaptureStreamId };
906        res = updateEntry(mCaptureRequest, ANDROID_REQUEST_OUTPUT_STREAMS,
907                &streamIds, 2);
908    } else if (mState == RECORD) {
909        uint8_t streamIds[3] = { mPreviewStreamId, mRecordingStreamId,
910                                 mCaptureStreamId };
911        res = updateEntry(mCaptureRequest, ANDROID_REQUEST_OUTPUT_STREAMS,
912                &streamIds, 3);
913    }
914
915    if (res != OK) {
916        ALOGE("%s: Camera %d: Unable to set up still image capture request: "
917                "%s (%d)",
918                __FUNCTION__, mCameraId, strerror(-res), res);
919        return res;
920    }
921    res = sort_camera_metadata(mCaptureRequest);
922    if (res != OK) {
923        ALOGE("%s: Camera %d: Unable to sort capture request: %s (%d)",
924                __FUNCTION__, mCameraId, strerror(-res), res);
925        return res;
926    }
927
928    camera_metadata_t *captureCopy = clone_camera_metadata(mCaptureRequest);
929    if (captureCopy == NULL) {
930        ALOGE("%s: Camera %d: Unable to copy capture request for HAL device",
931                __FUNCTION__, mCameraId);
932        return NO_MEMORY;
933    }
934
935    if (mState == PREVIEW) {
936        res = mDevice->setStreamingRequest(NULL);
937        if (res != OK) {
938            ALOGE("%s: Camera %d: Unable to stop preview for still capture: "
939                    "%s (%d)",
940                    __FUNCTION__, mCameraId, strerror(-res), res);
941            return res;
942        }
943    }
944    // TODO: Capture should be atomic with setStreamingRequest here
945    res = mDevice->capture(captureCopy);
946    if (res != OK) {
947        ALOGE("%s: Camera %d: Unable to submit still image capture request: "
948                "%s (%d)",
949                __FUNCTION__, mCameraId, strerror(-res), res);
950        return res;
951    }
952
953    switch (mState) {
954        case PREVIEW:
955            mState = STILL_CAPTURE;
956            break;
957        case RECORD:
958            mState = VIDEO_SNAPSHOT;
959            break;
960        default:
961            ALOGE("%s: Camera %d: Unknown state for still capture!",
962                    __FUNCTION__, mCameraId);
963            return INVALID_OPERATION;
964    }
965
966    return OK;
967}
968
969status_t Camera2Client::setParameters(const String8& params) {
970    ATRACE_CALL();
971    ALOGV("%s: E", __FUNCTION__);
972    Mutex::Autolock icl(mICameraLock);
973    status_t res;
974    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
975
976    LockedParameters::Key k(mParameters);
977
978    CameraParameters newParams(params);
979
980    // TODO: Currently ignoring any changes to supposedly read-only
981    // parameters such as supported preview sizes, etc. Should probably
982    // produce an error if they're changed.
983
984    /** Extract and verify new parameters */
985
986    size_t i;
987
988    // PREVIEW_SIZE
989    int previewWidth, previewHeight;
990    newParams.getPreviewSize(&previewWidth, &previewHeight);
991
992    if (previewWidth != k.mParameters.previewWidth ||
993            previewHeight != k.mParameters.previewHeight) {
994        if (mState >= PREVIEW) {
995            ALOGE("%s: Preview size cannot be updated when preview "
996                    "is active! (Currently %d x %d, requested %d x %d",
997                    __FUNCTION__,
998                    k.mParameters.previewWidth, k.mParameters.previewHeight,
999                    previewWidth, previewHeight);
1000            return BAD_VALUE;
1001        }
1002        camera_metadata_entry_t availablePreviewSizes =
1003            staticInfo(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES);
1004        for (i = 0; i < availablePreviewSizes.count; i += 2 ) {
1005            if (availablePreviewSizes.data.i32[i] == previewWidth &&
1006                    availablePreviewSizes.data.i32[i+1] == previewHeight) break;
1007        }
1008        if (i == availablePreviewSizes.count) {
1009            ALOGE("%s: Requested preview size %d x %d is not supported",
1010                    __FUNCTION__, previewWidth, previewHeight);
1011            return BAD_VALUE;
1012        }
1013    }
1014
1015    // PREVIEW_FPS_RANGE
1016    int previewFpsRange[2];
1017    int previewFps = 0;
1018    bool fpsRangeChanged = false;
1019    newParams.getPreviewFpsRange(&previewFpsRange[0], &previewFpsRange[1]);
1020    if (previewFpsRange[0] != k.mParameters.previewFpsRange[0] ||
1021            previewFpsRange[1] != k.mParameters.previewFpsRange[1]) {
1022        fpsRangeChanged = true;
1023        camera_metadata_entry_t availablePreviewFpsRanges =
1024            staticInfo(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES, 2);
1025        for (i = 0; i < availablePreviewFpsRanges.count; i += 2) {
1026            if ((availablePreviewFpsRanges.data.i32[i] ==
1027                    previewFpsRange[0]) &&
1028                (availablePreviewFpsRanges.data.i32[i+1] ==
1029                    previewFpsRange[1]) ) {
1030                break;
1031            }
1032        }
1033        if (i == availablePreviewFpsRanges.count) {
1034            ALOGE("%s: Requested preview FPS range %d - %d is not supported",
1035                __FUNCTION__, previewFpsRange[0], previewFpsRange[1]);
1036            return BAD_VALUE;
1037        }
1038        previewFps = previewFpsRange[0];
1039    }
1040
1041    // PREVIEW_FORMAT
1042    int previewFormat = formatStringToEnum(newParams.getPreviewFormat());
1043    if (previewFormat != k.mParameters.previewFormat) {
1044        if (mState >= PREVIEW) {
1045            ALOGE("%s: Preview format cannot be updated when preview "
1046                    "is active!", __FUNCTION__);
1047            return BAD_VALUE;
1048        }
1049        camera_metadata_entry_t availableFormats =
1050            staticInfo(ANDROID_SCALER_AVAILABLE_FORMATS);
1051        for (i = 0; i < availableFormats.count; i++) {
1052            if (availableFormats.data.i32[i] == previewFormat) break;
1053        }
1054        if (i == availableFormats.count) {
1055            ALOGE("%s: Requested preview format %s (0x%x) is not supported",
1056                    __FUNCTION__, newParams.getPreviewFormat(), previewFormat);
1057            return BAD_VALUE;
1058        }
1059    }
1060
1061    // PREVIEW_FRAME_RATE
1062    // Deprecated, only use if the preview fps range is unchanged this time.
1063    // The single-value FPS is the same as the minimum of the range.
1064    if (!fpsRangeChanged) {
1065        previewFps = newParams.getPreviewFrameRate();
1066        if (previewFps != k.mParameters.previewFps) {
1067            camera_metadata_entry_t availableFrameRates =
1068                staticInfo(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES);
1069            for (i = 0; i < availableFrameRates.count; i+=2) {
1070                if (availableFrameRates.data.i32[i] == previewFps) break;
1071            }
1072            if (i == availableFrameRates.count) {
1073                ALOGE("%s: Requested preview frame rate %d is not supported",
1074                        __FUNCTION__, previewFps);
1075                return BAD_VALUE;
1076            }
1077            previewFpsRange[0] = availableFrameRates.data.i32[i];
1078            previewFpsRange[1] = availableFrameRates.data.i32[i+1];
1079        }
1080    }
1081
1082    // PICTURE_SIZE
1083    int pictureWidth, pictureHeight;
1084    newParams.getPictureSize(&pictureWidth, &pictureHeight);
1085    if (pictureWidth == k.mParameters.pictureWidth ||
1086            pictureHeight == k.mParameters.pictureHeight) {
1087        camera_metadata_entry_t availablePictureSizes =
1088            staticInfo(ANDROID_SCALER_AVAILABLE_JPEG_SIZES);
1089        for (i = 0; i < availablePictureSizes.count; i+=2) {
1090            if (availablePictureSizes.data.i32[i] == pictureWidth &&
1091                    availablePictureSizes.data.i32[i+1] == pictureHeight) break;
1092        }
1093        if (i == availablePictureSizes.count) {
1094            ALOGE("%s: Requested picture size %d x %d is not supported",
1095                    __FUNCTION__, pictureWidth, pictureHeight);
1096            return BAD_VALUE;
1097        }
1098    }
1099
1100    // JPEG_THUMBNAIL_WIDTH/HEIGHT
1101    int jpegThumbSize[2];
1102    jpegThumbSize[0] =
1103            newParams.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH);
1104    jpegThumbSize[1] =
1105            newParams.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT);
1106    if (jpegThumbSize[0] != k.mParameters.jpegThumbSize[0] ||
1107            jpegThumbSize[1] != k.mParameters.jpegThumbSize[1]) {
1108        camera_metadata_entry_t availableJpegThumbSizes =
1109            staticInfo(ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES);
1110        for (i = 0; i < availableJpegThumbSizes.count; i+=2) {
1111            if (availableJpegThumbSizes.data.i32[i] == jpegThumbSize[0] &&
1112                    availableJpegThumbSizes.data.i32[i+1] == jpegThumbSize[1]) {
1113                break;
1114            }
1115        }
1116        if (i == availableJpegThumbSizes.count) {
1117            ALOGE("%s: Requested JPEG thumbnail size %d x %d is not supported",
1118                    __FUNCTION__, jpegThumbSize[0], jpegThumbSize[1]);
1119            return BAD_VALUE;
1120        }
1121    }
1122
1123    // JPEG_THUMBNAIL_QUALITY
1124    int jpegThumbQuality =
1125            newParams.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY);
1126    if (jpegThumbQuality < 0 || jpegThumbQuality > 100) {
1127        ALOGE("%s: Requested JPEG thumbnail quality %d is not supported",
1128                __FUNCTION__, jpegThumbQuality);
1129        return BAD_VALUE;
1130    }
1131
1132    // JPEG_QUALITY
1133    int jpegQuality =
1134            newParams.getInt(CameraParameters::KEY_JPEG_QUALITY);
1135    if (jpegQuality < 0 || jpegQuality > 100) {
1136        ALOGE("%s: Requested JPEG quality %d is not supported",
1137                __FUNCTION__, jpegQuality);
1138        return BAD_VALUE;
1139    }
1140
1141    // ROTATION
1142    int jpegRotation =
1143            newParams.getInt(CameraParameters::KEY_ROTATION);
1144    if (jpegRotation != 0 &&
1145            jpegRotation != 90 &&
1146            jpegRotation != 180 &&
1147            jpegRotation != 270) {
1148        ALOGE("%s: Requested picture rotation angle %d is not supported",
1149                __FUNCTION__, jpegRotation);
1150        return BAD_VALUE;
1151    }
1152
1153    // GPS
1154    bool gpsEnabled = false;
1155    double gpsCoordinates[3] = {0,0,0};
1156    int64_t gpsTimestamp = 0;
1157    String8 gpsProcessingMethod;
1158    const char *gpsLatStr =
1159            newParams.get(CameraParameters::KEY_GPS_LATITUDE);
1160    if (gpsLatStr != NULL) {
1161        const char *gpsLongStr =
1162                newParams.get(CameraParameters::KEY_GPS_LONGITUDE);
1163        const char *gpsAltitudeStr =
1164                newParams.get(CameraParameters::KEY_GPS_ALTITUDE);
1165        const char *gpsTimeStr =
1166                newParams.get(CameraParameters::KEY_GPS_TIMESTAMP);
1167        const char *gpsProcMethodStr =
1168                newParams.get(CameraParameters::KEY_GPS_PROCESSING_METHOD);
1169        if (gpsLongStr == NULL ||
1170                gpsAltitudeStr == NULL ||
1171                gpsTimeStr == NULL ||
1172                gpsProcMethodStr == NULL) {
1173            ALOGE("%s: Incomplete set of GPS parameters provided",
1174                    __FUNCTION__);
1175            return BAD_VALUE;
1176        }
1177        char *endPtr;
1178        errno = 0;
1179        gpsCoordinates[0] = strtod(gpsLatStr, &endPtr);
1180        if (errno || endPtr == gpsLatStr) {
1181            ALOGE("%s: Malformed GPS latitude: %s", __FUNCTION__, gpsLatStr);
1182            return BAD_VALUE;
1183        }
1184        errno = 0;
1185        gpsCoordinates[1] = strtod(gpsLongStr, &endPtr);
1186        if (errno || endPtr == gpsLongStr) {
1187            ALOGE("%s: Malformed GPS longitude: %s", __FUNCTION__, gpsLongStr);
1188            return BAD_VALUE;
1189        }
1190        errno = 0;
1191        gpsCoordinates[2] = strtod(gpsAltitudeStr, &endPtr);
1192        if (errno || endPtr == gpsAltitudeStr) {
1193            ALOGE("%s: Malformed GPS altitude: %s", __FUNCTION__,
1194                    gpsAltitudeStr);
1195            return BAD_VALUE;
1196        }
1197        errno = 0;
1198        gpsTimestamp = strtoll(gpsTimeStr, &endPtr, 10);
1199        if (errno || endPtr == gpsTimeStr) {
1200            ALOGE("%s: Malformed GPS timestamp: %s", __FUNCTION__, gpsTimeStr);
1201            return BAD_VALUE;
1202        }
1203        gpsProcessingMethod = gpsProcMethodStr;
1204
1205        gpsEnabled = true;
1206    }
1207
1208    // WHITE_BALANCE
1209    int wbMode = wbModeStringToEnum(
1210        newParams.get(CameraParameters::KEY_WHITE_BALANCE) );
1211    if (wbMode != k.mParameters.wbMode) {
1212        camera_metadata_entry_t availableWbModes =
1213            staticInfo(ANDROID_CONTROL_AWB_AVAILABLE_MODES);
1214        for (i = 0; i < availableWbModes.count; i++) {
1215            if (wbMode == availableWbModes.data.u8[i]) break;
1216        }
1217        if (i == availableWbModes.count) {
1218            ALOGE("%s: Requested white balance mode %s is not supported",
1219                    __FUNCTION__,
1220                    newParams.get(CameraParameters::KEY_WHITE_BALANCE));
1221            return BAD_VALUE;
1222        }
1223    }
1224
1225    // EFFECT
1226    int effectMode = effectModeStringToEnum(
1227        newParams.get(CameraParameters::KEY_EFFECT) );
1228    if (effectMode != k.mParameters.effectMode) {
1229        camera_metadata_entry_t availableEffectModes =
1230            staticInfo(ANDROID_CONTROL_AVAILABLE_EFFECTS);
1231        for (i = 0; i < availableEffectModes.count; i++) {
1232            if (effectMode == availableEffectModes.data.u8[i]) break;
1233        }
1234        if (i == availableEffectModes.count) {
1235            ALOGE("%s: Requested effect mode \"%s\" is not supported",
1236                    __FUNCTION__,
1237                    newParams.get(CameraParameters::KEY_EFFECT) );
1238            return BAD_VALUE;
1239        }
1240    }
1241
1242    // ANTIBANDING
1243    int antibandingMode = abModeStringToEnum(
1244        newParams.get(CameraParameters::KEY_ANTIBANDING) );
1245    if (antibandingMode != k.mParameters.antibandingMode) {
1246        camera_metadata_entry_t availableAbModes =
1247            staticInfo(ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES);
1248        for (i = 0; i < availableAbModes.count; i++) {
1249            if (antibandingMode == availableAbModes.data.u8[i]) break;
1250        }
1251        if (i == availableAbModes.count) {
1252            ALOGE("%s: Requested antibanding mode \"%s\" is not supported",
1253                    __FUNCTION__,
1254                    newParams.get(CameraParameters::KEY_ANTIBANDING));
1255            return BAD_VALUE;
1256        }
1257    }
1258
1259    // SCENE_MODE
1260    int sceneMode = sceneModeStringToEnum(
1261        newParams.get(CameraParameters::KEY_SCENE_MODE) );
1262    if (sceneMode != k.mParameters.sceneMode) {
1263        camera_metadata_entry_t availableSceneModes =
1264            staticInfo(ANDROID_CONTROL_AVAILABLE_SCENE_MODES);
1265        for (i = 0; i < availableSceneModes.count; i++) {
1266            if (sceneMode == availableSceneModes.data.u8[i]) break;
1267        }
1268        if (i == availableSceneModes.count) {
1269            ALOGE("%s: Requested scene mode \"%s\" is not supported",
1270                    __FUNCTION__,
1271                    newParams.get(CameraParameters::KEY_SCENE_MODE));
1272            return BAD_VALUE;
1273        }
1274    }
1275
1276    // FLASH_MODE
1277    Parameters::flashMode_t flashMode = flashModeStringToEnum(
1278        newParams.get(CameraParameters::KEY_FLASH_MODE) );
1279    if (flashMode != k.mParameters.flashMode) {
1280        camera_metadata_entry_t flashAvailable =
1281            staticInfo(ANDROID_FLASH_AVAILABLE, 1, 1);
1282        if (!flashAvailable.data.u8[0] &&
1283                flashMode != Parameters::FLASH_MODE_OFF) {
1284            ALOGE("%s: Requested flash mode \"%s\" is not supported: "
1285                    "No flash on device", __FUNCTION__,
1286                    newParams.get(CameraParameters::KEY_FLASH_MODE));
1287            return BAD_VALUE;
1288        } else if (flashMode == Parameters::FLASH_MODE_RED_EYE) {
1289            camera_metadata_entry_t availableAeModes =
1290                staticInfo(ANDROID_CONTROL_AE_AVAILABLE_MODES);
1291            for (i = 0; i < availableAeModes.count; i++) {
1292                if (flashMode == availableAeModes.data.u8[i]) break;
1293            }
1294            if (i == availableAeModes.count) {
1295                ALOGE("%s: Requested flash mode \"%s\" is not supported",
1296                        __FUNCTION__,
1297                        newParams.get(CameraParameters::KEY_FLASH_MODE));
1298                return BAD_VALUE;
1299            }
1300        } else if (flashMode == -1) {
1301            ALOGE("%s: Requested flash mode \"%s\" is unknown",
1302                    __FUNCTION__,
1303                    newParams.get(CameraParameters::KEY_FLASH_MODE));
1304            return BAD_VALUE;
1305        }
1306    }
1307
1308    // FOCUS_MODE
1309    Parameters::focusMode_t focusMode = focusModeStringToEnum(
1310        newParams.get(CameraParameters::KEY_FOCUS_MODE));
1311    if (focusMode != k.mParameters.focusMode) {
1312        if (focusMode != Parameters::FOCUS_MODE_FIXED) {
1313            camera_metadata_entry_t minFocusDistance =
1314                staticInfo(ANDROID_LENS_MINIMUM_FOCUS_DISTANCE);
1315            if (minFocusDistance.data.f[0] == 0) {
1316                ALOGE("%s: Requested focus mode \"%s\" is not available: "
1317                        "fixed focus lens",
1318                        __FUNCTION__,
1319                        newParams.get(CameraParameters::KEY_FOCUS_MODE));
1320                return BAD_VALUE;
1321            } else if (focusMode != Parameters::FOCUS_MODE_INFINITY) {
1322                camera_metadata_entry_t availableFocusModes =
1323                    staticInfo(ANDROID_CONTROL_AF_AVAILABLE_MODES);
1324                for (i = 0; i < availableFocusModes.count; i++) {
1325                    if (focusMode == availableFocusModes.data.u8[i]) break;
1326                }
1327                if (i == availableFocusModes.count) {
1328                    ALOGE("%s: Requested focus mode \"%s\" is not supported",
1329                            __FUNCTION__,
1330                            newParams.get(CameraParameters::KEY_FOCUS_MODE));
1331                    return BAD_VALUE;
1332                }
1333            }
1334        }
1335    }
1336
1337    // FOCUS_AREAS
1338    Vector<Parameters::Area> focusingAreas;
1339    res = parseAreas(newParams.get(CameraParameters::KEY_FOCUS_AREAS),
1340            &focusingAreas);
1341    size_t max3aRegions =
1342        (size_t)staticInfo(ANDROID_CONTROL_MAX_REGIONS, 1, 1).data.i32[0];
1343    if (res == OK) res = validateAreas(focusingAreas, max3aRegions);
1344    if (res != OK) {
1345        ALOGE("%s: Requested focus areas are malformed: %s",
1346                __FUNCTION__, newParams.get(CameraParameters::KEY_FOCUS_AREAS));
1347        return BAD_VALUE;
1348    }
1349
1350    // EXPOSURE_COMPENSATION
1351    int exposureCompensation =
1352        newParams.getInt(CameraParameters::KEY_EXPOSURE_COMPENSATION);
1353    camera_metadata_entry_t exposureCompensationRange =
1354        staticInfo(ANDROID_CONTROL_AE_EXP_COMPENSATION_RANGE);
1355    if (exposureCompensation < exposureCompensationRange.data.i32[0] ||
1356            exposureCompensation > exposureCompensationRange.data.i32[1]) {
1357        ALOGE("%s: Requested exposure compensation index is out of bounds: %d",
1358                __FUNCTION__, exposureCompensation);
1359        return BAD_VALUE;
1360    }
1361
1362    // AUTO_EXPOSURE_LOCK (always supported)
1363    bool autoExposureLock = boolFromString(
1364        newParams.get(CameraParameters::KEY_AUTO_EXPOSURE_LOCK));
1365
1366    // AUTO_WHITEBALANCE_LOCK (always supported)
1367    bool autoWhiteBalanceLock = boolFromString(
1368        newParams.get(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK));
1369
1370    // METERING_AREAS
1371    Vector<Parameters::Area> meteringAreas;
1372    res = parseAreas(newParams.get(CameraParameters::KEY_METERING_AREAS),
1373            &meteringAreas);
1374    if (res == OK) res = validateAreas(focusingAreas, max3aRegions);
1375    if (res != OK) {
1376        ALOGE("%s: Requested metering areas are malformed: %s",
1377                __FUNCTION__,
1378                newParams.get(CameraParameters::KEY_METERING_AREAS));
1379        return BAD_VALUE;
1380    }
1381
1382    // ZOOM
1383    int zoom = newParams.getInt(CameraParameters::KEY_ZOOM);
1384    if (zoom < 0 || zoom > (int)NUM_ZOOM_STEPS) {
1385        ALOGE("%s: Requested zoom level %d is not supported",
1386                __FUNCTION__, zoom);
1387        return BAD_VALUE;
1388    }
1389
1390    // VIDEO_SIZE
1391    int videoWidth, videoHeight;
1392    newParams.getVideoSize(&videoWidth, &videoHeight);
1393    if (videoWidth != k.mParameters.videoWidth ||
1394            videoHeight != k.mParameters.videoHeight) {
1395        if (mState == RECORD) {
1396            ALOGE("%s: Video size cannot be updated when recording is active!",
1397                    __FUNCTION__);
1398            return BAD_VALUE;
1399        }
1400        camera_metadata_entry_t availableVideoSizes =
1401            staticInfo(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES);
1402        for (i = 0; i < availableVideoSizes.count; i += 2 ) {
1403            if (availableVideoSizes.data.i32[i] == videoWidth &&
1404                    availableVideoSizes.data.i32[i+1] == videoHeight)  break;
1405        }
1406        if (i == availableVideoSizes.count) {
1407            ALOGE("%s: Requested video size %d x %d is not supported",
1408                    __FUNCTION__, videoWidth, videoHeight);
1409            return BAD_VALUE;
1410        }
1411    }
1412
1413    // RECORDING_HINT (always supported)
1414    bool recordingHint = boolFromString(
1415        newParams.get(CameraParameters::KEY_RECORDING_HINT) );
1416
1417    // VIDEO_STABILIZATION
1418    bool videoStabilization = boolFromString(
1419        newParams.get(CameraParameters::KEY_VIDEO_STABILIZATION) );
1420    camera_metadata_entry_t availableVideoStabilizationModes =
1421        staticInfo(ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES);
1422    if (videoStabilization && availableVideoStabilizationModes.count == 1) {
1423        ALOGE("%s: Video stabilization not supported", __FUNCTION__);
1424    }
1425
1426    /** Update internal parameters */
1427
1428    k.mParameters.previewWidth = previewWidth;
1429    k.mParameters.previewHeight = previewHeight;
1430    k.mParameters.previewFpsRange[0] = previewFpsRange[0];
1431    k.mParameters.previewFpsRange[1] = previewFpsRange[1];
1432    k.mParameters.previewFps = previewFps;
1433    k.mParameters.previewFormat = previewFormat;
1434
1435    k.mParameters.pictureWidth = pictureWidth;
1436    k.mParameters.pictureHeight = pictureHeight;
1437
1438    k.mParameters.jpegThumbSize[0] = jpegThumbSize[0];
1439    k.mParameters.jpegThumbSize[1] = jpegThumbSize[1];
1440    k.mParameters.jpegQuality = jpegQuality;
1441    k.mParameters.jpegThumbQuality = jpegThumbQuality;
1442
1443    k.mParameters.gpsEnabled = gpsEnabled;
1444    k.mParameters.gpsCoordinates[0] = gpsCoordinates[0];
1445    k.mParameters.gpsCoordinates[1] = gpsCoordinates[1];
1446    k.mParameters.gpsCoordinates[2] = gpsCoordinates[2];
1447    k.mParameters.gpsTimestamp = gpsTimestamp;
1448    k.mParameters.gpsProcessingMethod = gpsProcessingMethod;
1449
1450    k.mParameters.wbMode = wbMode;
1451    k.mParameters.effectMode = effectMode;
1452    k.mParameters.antibandingMode = antibandingMode;
1453    k.mParameters.sceneMode = sceneMode;
1454
1455    k.mParameters.flashMode = flashMode;
1456    k.mParameters.focusMode = focusMode;
1457
1458    k.mParameters.focusingAreas = focusingAreas;
1459    k.mParameters.exposureCompensation = exposureCompensation;
1460    k.mParameters.autoExposureLock = autoExposureLock;
1461    k.mParameters.autoWhiteBalanceLock = autoWhiteBalanceLock;
1462    k.mParameters.meteringAreas = meteringAreas;
1463    k.mParameters.zoom = zoom;
1464
1465    k.mParameters.videoWidth = videoWidth;
1466    k.mParameters.videoHeight = videoHeight;
1467
1468    k.mParameters.recordingHint = recordingHint;
1469    k.mParameters.videoStabilization = videoStabilization;
1470
1471    res = updatePreviewRequest(k.mParameters);
1472    if (res != OK) {
1473        ALOGE("%s: Camera %d: Unable to update preview request: %s (%d)",
1474                __FUNCTION__, mCameraId, strerror(-res), res);
1475        return res;
1476    }
1477    res = updateCaptureRequest(k.mParameters);
1478    if (res != OK) {
1479        ALOGE("%s: Camera %d: Unable to update capture request: %s (%d)",
1480                __FUNCTION__, mCameraId, strerror(-res), res);
1481        return res;
1482    }
1483
1484    res = updateRecordingRequest(k.mParameters);
1485    if (res != OK) {
1486        ALOGE("%s: Camera %d: Unable to update recording request: %s (%d)",
1487                __FUNCTION__, mCameraId, strerror(-res), res);
1488        return res;
1489    }
1490
1491    if (mState == PREVIEW) {
1492        res = mDevice->setStreamingRequest(mPreviewRequest);
1493        if (res != OK) {
1494            ALOGE("%s: Camera %d: Error streaming new preview request: %s (%d)",
1495                    __FUNCTION__, mCameraId, strerror(-res), res);
1496            return res;
1497        }
1498    } else if (mState == RECORD || mState == VIDEO_SNAPSHOT) {
1499        res = mDevice->setStreamingRequest(mRecordingRequest);
1500        if (res != OK) {
1501            ALOGE("%s: Camera %d: Error streaming new record request: %s (%d)",
1502                    __FUNCTION__, mCameraId, strerror(-res), res);
1503            return res;
1504        }
1505    }
1506
1507    k.mParameters.paramsFlattened = params;
1508
1509    return OK;
1510}
1511
1512String8 Camera2Client::getParameters() const {
1513    ATRACE_CALL();
1514    Mutex::Autolock icl(mICameraLock);
1515    if ( checkPid(__FUNCTION__) != OK) return String8();
1516
1517    LockedParameters::ReadKey k(mParameters);
1518
1519    // TODO: Deal with focus distances
1520    return k.mParameters.paramsFlattened;
1521}
1522
1523status_t Camera2Client::sendCommand(int32_t cmd, int32_t arg1, int32_t arg2) {
1524    ATRACE_CALL();
1525    Mutex::Autolock icl(mICameraLock);
1526    status_t res;
1527    if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
1528
1529    ALOGV("%s: Camera %d: Command %d (%d, %d)", __FUNCTION__, mCameraId,
1530            cmd, arg1, arg2);
1531
1532    switch (cmd) {
1533        case CAMERA_CMD_START_SMOOTH_ZOOM:
1534            return commandStartSmoothZoomL();
1535        case CAMERA_CMD_STOP_SMOOTH_ZOOM:
1536            return commandStopSmoothZoomL();
1537        case CAMERA_CMD_SET_DISPLAY_ORIENTATION:
1538            return commandSetDisplayOrientationL(arg1);
1539        case CAMERA_CMD_ENABLE_SHUTTER_SOUND:
1540            return commandEnableShutterSoundL(arg1 == 1);
1541        case CAMERA_CMD_PLAY_RECORDING_SOUND:
1542            return commandPlayRecordingSoundL();
1543        case CAMERA_CMD_START_FACE_DETECTION:
1544            return commandStartFaceDetectionL(arg1);
1545        case CAMERA_CMD_STOP_FACE_DETECTION:
1546            return commandStopFaceDetectionL();
1547        case CAMERA_CMD_ENABLE_FOCUS_MOVE_MSG:
1548            return commandEnableFocusMoveMsgL(arg1 == 1);
1549        case CAMERA_CMD_PING:
1550            return commandPingL();
1551        case CAMERA_CMD_SET_VIDEO_BUFFER_COUNT:
1552            return commandSetVideoBufferCountL(arg1);
1553        default:
1554            ALOGE("%s: Unknown command %d (arguments %d, %d)",
1555                    __FUNCTION__, cmd, arg1, arg2);
1556            return BAD_VALUE;
1557    }
1558}
1559
1560status_t Camera2Client::commandStartSmoothZoomL() {
1561    ALOGE("%s: Unimplemented!", __FUNCTION__);
1562    return OK;
1563}
1564
1565status_t Camera2Client::commandStopSmoothZoomL() {
1566    ALOGE("%s: Unimplemented!", __FUNCTION__);
1567    return OK;
1568}
1569
1570status_t Camera2Client::commandSetDisplayOrientationL(int degrees) {
1571    LockedParameters::Key k(mParameters);
1572    int transform = degToTransform(degrees,
1573            mCameraFacing == CAMERA_FACING_FRONT);
1574    if (transform == -1) {
1575        ALOGE("%s: Camera %d: Error setting %d as display orientation value",
1576                __FUNCTION__, mCameraId, degrees);
1577        return BAD_VALUE;
1578    }
1579    if (transform != k.mParameters.previewTransform &&
1580            mPreviewStreamId != NO_STREAM) {
1581        mDevice->setStreamTransform(mPreviewStreamId, transform);
1582    }
1583    k.mParameters.previewTransform = transform;
1584    return OK;
1585}
1586
1587status_t Camera2Client::commandEnableShutterSoundL(bool enable) {
1588    LockedParameters::Key k(mParameters);
1589    if (enable) {
1590        k.mParameters.playShutterSound = true;
1591        return OK;
1592    }
1593
1594    // Disabling shutter sound may not be allowed. In that case only
1595    // allow the mediaserver process to disable the sound.
1596    char value[PROPERTY_VALUE_MAX];
1597    property_get("ro.camera.sound.forced", value, "0");
1598    if (strncmp(value, "0", 2) != 0) {
1599        // Disabling shutter sound is not allowed. Deny if the current
1600        // process is not mediaserver.
1601        if (getCallingPid() != getpid()) {
1602            ALOGE("Failed to disable shutter sound. Permission denied (pid %d)",
1603                    getCallingPid());
1604            return PERMISSION_DENIED;
1605        }
1606    }
1607
1608    k.mParameters.playShutterSound = false;
1609    return OK;
1610}
1611
1612status_t Camera2Client::commandPlayRecordingSoundL() {
1613    mCameraService->playSound(CameraService::SOUND_RECORDING);
1614    return OK;
1615}
1616
1617status_t Camera2Client::commandStartFaceDetectionL(int type) {
1618    ALOGE("%s: Unimplemented!", __FUNCTION__);
1619    return OK;
1620}
1621
1622status_t Camera2Client::commandStopFaceDetectionL() {
1623    ALOGE("%s: Unimplemented!", __FUNCTION__);
1624    return OK;
1625}
1626
1627status_t Camera2Client::commandEnableFocusMoveMsgL(bool enable) {
1628    ALOGE("%s: Unimplemented!", __FUNCTION__);
1629    return OK;
1630}
1631
1632status_t Camera2Client::commandPingL() {
1633    // Always ping back if access is proper and device is alive
1634    if (mState != DISCONNECTED) {
1635        return OK;
1636    } else {
1637        return NO_INIT;
1638    }
1639}
1640
1641status_t Camera2Client::commandSetVideoBufferCountL(size_t count) {
1642    if (recordingEnabledL()) {
1643        ALOGE("%s: Camera %d: Error setting video buffer count after "
1644                "recording was started", __FUNCTION__, mCameraId);
1645        return INVALID_OPERATION;
1646    }
1647
1648    // 32 is the current upper limit on the video buffer count for BufferQueue
1649    if (count > 32) {
1650        ALOGE("%s: Camera %d: Error setting %d as video buffer count value",
1651                __FUNCTION__, mCameraId, count);
1652        return BAD_VALUE;
1653    }
1654
1655    // Need to reallocate memory for heap
1656    if (mRecordingHeapCount != count) {
1657        if  (mRecordingHeap != 0) {
1658            mRecordingHeap.clear();
1659            mRecordingHeap = NULL;
1660        }
1661        mRecordingHeapCount = count;
1662    }
1663
1664    return OK;
1665}
1666
1667/** Device-related methods */
1668
1669void Camera2Client::notifyError(int errorCode, int arg1, int arg2) {
1670    ALOGE("Error condition %d reported by HAL, arguments %d, %d", errorCode, arg1, arg2);
1671}
1672
1673void Camera2Client::notifyShutter(int frameNumber, nsecs_t timestamp) {
1674    ALOGV("%s: Shutter notification for frame %d at time %lld", __FUNCTION__,
1675            frameNumber, timestamp);
1676}
1677
1678void Camera2Client::notifyAutoFocus(uint8_t newState, int triggerId) {
1679    ALOGV("%s: Autofocus state now %d, last trigger %d",
1680            __FUNCTION__, newState, triggerId);
1681}
1682
1683void Camera2Client::notifyAutoExposure(uint8_t newState, int triggerId) {
1684    ALOGV("%s: Autoexposure state now %d, last trigger %d",
1685            __FUNCTION__, newState, triggerId);
1686}
1687
1688void Camera2Client::notifyAutoWhitebalance(uint8_t newState, int triggerId) {
1689    ALOGV("%s: Auto-whitebalance state now %d, last trigger %d",
1690            __FUNCTION__, newState, triggerId);
1691}
1692
1693void Camera2Client::onCaptureAvailable() {
1694    ATRACE_CALL();
1695    status_t res;
1696    sp<ICameraClient> currentClient;
1697    ALOGV("%s: Camera %d: Still capture available", __FUNCTION__, mCameraId);
1698
1699    CpuConsumer::LockedBuffer imgBuffer;
1700    {
1701        Mutex::Autolock icl(mICameraLock);
1702
1703        // TODO: Signal errors here upstream
1704        if (mState != STILL_CAPTURE && mState != VIDEO_SNAPSHOT) {
1705            ALOGE("%s: Camera %d: Still image produced unexpectedly!",
1706                    __FUNCTION__, mCameraId);
1707            return;
1708        }
1709
1710        res = mCaptureConsumer->lockNextBuffer(&imgBuffer);
1711        if (res != OK) {
1712            ALOGE("%s: Camera %d: Error receiving still image buffer: %s (%d)",
1713                    __FUNCTION__, mCameraId, strerror(-res), res);
1714            return;
1715        }
1716
1717        if (imgBuffer.format != HAL_PIXEL_FORMAT_BLOB) {
1718            ALOGE("%s: Camera %d: Unexpected format for still image: "
1719                    "%x, expected %x", __FUNCTION__, mCameraId,
1720                    imgBuffer.format,
1721                    HAL_PIXEL_FORMAT_BLOB);
1722            mCaptureConsumer->unlockBuffer(imgBuffer);
1723            return;
1724        }
1725
1726        // TODO: Optimize this to avoid memcopy
1727        void* captureMemory = mCaptureHeap->mHeap->getBase();
1728        size_t size = mCaptureHeap->mHeap->getSize();
1729        memcpy(captureMemory, imgBuffer.data, size);
1730
1731        mCaptureConsumer->unlockBuffer(imgBuffer);
1732
1733        currentClient = mCameraClient;
1734        switch (mState) {
1735            case STILL_CAPTURE:
1736                mState = STOPPED;
1737                break;
1738            case VIDEO_SNAPSHOT:
1739                mState = RECORD;
1740                break;
1741            default:
1742                ALOGE("%s: Camera %d: Unexpected state %d", __FUNCTION__,
1743                        mCameraId, mState);
1744                break;
1745        }
1746    }
1747    // Call outside mICameraLock to allow re-entrancy from notification
1748    if (currentClient != 0) {
1749        currentClient->dataCallback(CAMERA_MSG_COMPRESSED_IMAGE,
1750                mCaptureHeap->mBuffers[0], NULL);
1751    }
1752}
1753
1754void Camera2Client::onRecordingFrameAvailable() {
1755    ATRACE_CALL();
1756    status_t res;
1757    sp<ICameraClient> currentClient;
1758    size_t heapIdx = 0;
1759    nsecs_t timestamp;
1760    {
1761        Mutex::Autolock icl(mICameraLock);
1762        // TODO: Signal errors here upstream
1763        bool discardData = false;
1764        if (mState != RECORD && mState != VIDEO_SNAPSHOT) {
1765            ALOGV("%s: Camera %d: Discarding recording image buffers received after "
1766                    "recording done",
1767                    __FUNCTION__, mCameraId);
1768            discardData = true;
1769        }
1770
1771        buffer_handle_t imgBuffer;
1772        res = mRecordingConsumer->getNextBuffer(&imgBuffer, &timestamp);
1773        if (res != OK) {
1774            ALOGE("%s: Camera %d: Error receiving recording buffer: %s (%d)",
1775                    __FUNCTION__, mCameraId, strerror(-res), res);
1776            return;
1777        }
1778
1779        if (discardData) {
1780            mRecordingConsumer->freeBuffer(imgBuffer);
1781            return;
1782        }
1783
1784        if (mRecordingHeap == 0) {
1785            const size_t bufferSize = 4 + sizeof(buffer_handle_t);
1786            ALOGV("%s: Camera %d: Creating recording heap with %d buffers of "
1787                    "size %d bytes", __FUNCTION__, mCameraId,
1788                    mRecordingHeapCount, bufferSize);
1789            if (mRecordingHeap != 0) {
1790                ALOGV("%s: Camera %d: Previous heap has size %d "
1791                        "(new will be %d) bytes", __FUNCTION__, mCameraId,
1792                        mRecordingHeap->mHeap->getSize(),
1793                        bufferSize * mRecordingHeapCount);
1794            }
1795            // Need to allocate memory for heap
1796            mRecordingHeap.clear();
1797
1798            mRecordingHeap = new Camera2Heap(bufferSize, mRecordingHeapCount,
1799                    "Camera2Client::RecordingHeap");
1800            if (mRecordingHeap->mHeap->getSize() == 0) {
1801                ALOGE("%s: Camera %d: Unable to allocate memory for recording",
1802                        __FUNCTION__, mCameraId);
1803                mRecordingConsumer->freeBuffer(imgBuffer);
1804                return;
1805            }
1806            mRecordingHeapHead = 0;
1807            mRecordingHeapFree = mRecordingHeapCount;
1808        }
1809
1810        if ( mRecordingHeapFree == 0) {
1811            ALOGE("%s: Camera %d: No free recording buffers, dropping frame",
1812                    __FUNCTION__, mCameraId);
1813            mRecordingConsumer->freeBuffer(imgBuffer);
1814            return;
1815        }
1816        heapIdx = mRecordingHeapHead;
1817        mRecordingHeapHead = (mRecordingHeapHead + 1) % mRecordingHeapCount;
1818        mRecordingHeapFree--;
1819
1820        ALOGV("%s: Camera %d: Timestamp %lld",
1821                __FUNCTION__, mCameraId, timestamp);
1822
1823        ssize_t offset;
1824        size_t size;
1825        sp<IMemoryHeap> heap =
1826                mRecordingHeap->mBuffers[heapIdx]->getMemory(&offset,
1827                        &size);
1828
1829        uint8_t *data = (uint8_t*)heap->getBase() + offset;
1830        uint32_t type = kMetadataBufferTypeGrallocSource;
1831        memcpy(data, &type, 4);
1832        memcpy(data + 4, &imgBuffer, sizeof(buffer_handle_t));
1833        ALOGV("%s: Camera %d: Sending out buffer_handle_t %p",
1834                __FUNCTION__, mCameraId, imgBuffer);
1835        currentClient = mCameraClient;
1836    }
1837    // Call outside mICameraLock to allow re-entrancy from notification
1838    if (currentClient != 0) {
1839        currentClient->dataCallbackTimestamp(timestamp,
1840                CAMERA_MSG_VIDEO_FRAME,
1841                mRecordingHeap->mBuffers[heapIdx]);
1842    }
1843}
1844
1845camera_metadata_entry_t Camera2Client::staticInfo(uint32_t tag,
1846        size_t minCount, size_t maxCount) {
1847    status_t res;
1848    camera_metadata_entry_t entry;
1849    res = find_camera_metadata_entry(mDevice->info(),
1850            tag,
1851            &entry);
1852    if (CC_UNLIKELY( res != OK )) {
1853        const char* tagSection = get_camera_metadata_section_name(tag);
1854        if (tagSection == NULL) tagSection = "<unknown>";
1855        const char* tagName = get_camera_metadata_tag_name(tag);
1856        if (tagName == NULL) tagName = "<unknown>";
1857
1858        ALOGE("Error finding static metadata entry '%s.%s' (%x): %s (%d)",
1859                tagSection, tagName, tag, strerror(-res), res);
1860        entry.count = 0;
1861        entry.data.u8 = NULL;
1862    } else if (CC_UNLIKELY(
1863            (minCount != 0 && entry.count < minCount) ||
1864            (maxCount != 0 && entry.count > maxCount) ) ) {
1865        const char* tagSection = get_camera_metadata_section_name(tag);
1866        if (tagSection == NULL) tagSection = "<unknown>";
1867        const char* tagName = get_camera_metadata_tag_name(tag);
1868        if (tagName == NULL) tagName = "<unknown>";
1869        ALOGE("Malformed static metadata entry '%s.%s' (%x):"
1870                "Expected between %d and %d values, but got %d values",
1871                tagSection, tagName, tag, minCount, maxCount, entry.count);
1872        entry.count = 0;
1873        entry.data.u8 = NULL;
1874    }
1875
1876    return entry;
1877}
1878
1879/** Utility methods */
1880
1881
1882status_t Camera2Client::buildDefaultParameters() {
1883    ATRACE_CALL();
1884    LockedParameters::Key k(mParameters);
1885
1886    status_t res;
1887    CameraParameters params;
1888
1889    camera_metadata_entry_t availableProcessedSizes =
1890        staticInfo(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES, 2);
1891    if (!availableProcessedSizes.count) return NO_INIT;
1892
1893    // TODO: Pick more intelligently
1894    k.mParameters.previewWidth = availableProcessedSizes.data.i32[0];
1895    k.mParameters.previewHeight = availableProcessedSizes.data.i32[1];
1896    k.mParameters.videoWidth = k.mParameters.previewWidth;
1897    k.mParameters.videoHeight = k.mParameters.previewHeight;
1898
1899    params.setPreviewSize(k.mParameters.previewWidth, k.mParameters.previewHeight);
1900    params.setVideoSize(k.mParameters.videoWidth, k.mParameters.videoHeight);
1901    params.set(CameraParameters::KEY_PREFERRED_PREVIEW_SIZE_FOR_VIDEO,
1902            String8::format("%dx%d",
1903                    k.mParameters.previewWidth, k.mParameters.previewHeight));
1904    {
1905        String8 supportedPreviewSizes;
1906        for (size_t i=0; i < availableProcessedSizes.count; i += 2) {
1907            if (i != 0) supportedPreviewSizes += ",";
1908            supportedPreviewSizes += String8::format("%dx%d",
1909                    availableProcessedSizes.data.i32[i],
1910                    availableProcessedSizes.data.i32[i+1]);
1911        }
1912        params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES,
1913                supportedPreviewSizes);
1914        params.set(CameraParameters::KEY_SUPPORTED_VIDEO_SIZES,
1915                supportedPreviewSizes);
1916    }
1917
1918    camera_metadata_entry_t availableFpsRanges =
1919        staticInfo(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES, 2);
1920    if (!availableFpsRanges.count) return NO_INIT;
1921
1922    k.mParameters.previewFpsRange[0] = availableFpsRanges.data.i32[0];
1923    k.mParameters.previewFpsRange[1] = availableFpsRanges.data.i32[1];
1924
1925    params.set(CameraParameters::KEY_PREVIEW_FPS_RANGE,
1926            String8::format("%d,%d",
1927                    k.mParameters.previewFpsRange[0],
1928                    k.mParameters.previewFpsRange[1]));
1929
1930    {
1931        String8 supportedPreviewFpsRange;
1932        for (size_t i=0; i < availableFpsRanges.count; i += 2) {
1933            if (i != 0) supportedPreviewFpsRange += ",";
1934            supportedPreviewFpsRange += String8::format("(%d,%d)",
1935                    availableFpsRanges.data.i32[i],
1936                    availableFpsRanges.data.i32[i+1]);
1937        }
1938        params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE,
1939                supportedPreviewFpsRange);
1940    }
1941
1942    k.mParameters.previewFormat = HAL_PIXEL_FORMAT_YCrCb_420_SP;
1943    params.set(CameraParameters::KEY_PREVIEW_FORMAT,
1944            formatEnumToString(k.mParameters.previewFormat)); // NV21
1945
1946    k.mParameters.previewTransform = degToTransform(0,
1947            mCameraFacing == CAMERA_FACING_FRONT);
1948
1949    camera_metadata_entry_t availableFormats =
1950        staticInfo(ANDROID_SCALER_AVAILABLE_FORMATS);
1951
1952    {
1953        String8 supportedPreviewFormats;
1954        bool addComma = false;
1955        for (size_t i=0; i < availableFormats.count; i++) {
1956            if (addComma) supportedPreviewFormats += ",";
1957            addComma = true;
1958            switch (availableFormats.data.i32[i]) {
1959            case HAL_PIXEL_FORMAT_YCbCr_422_SP:
1960                supportedPreviewFormats +=
1961                    CameraParameters::PIXEL_FORMAT_YUV422SP;
1962                break;
1963            case HAL_PIXEL_FORMAT_YCrCb_420_SP:
1964                supportedPreviewFormats +=
1965                    CameraParameters::PIXEL_FORMAT_YUV420SP;
1966                break;
1967            case HAL_PIXEL_FORMAT_YCbCr_422_I:
1968                supportedPreviewFormats +=
1969                    CameraParameters::PIXEL_FORMAT_YUV422I;
1970                break;
1971            case HAL_PIXEL_FORMAT_YV12:
1972                supportedPreviewFormats +=
1973                    CameraParameters::PIXEL_FORMAT_YUV420P;
1974                break;
1975            case HAL_PIXEL_FORMAT_RGB_565:
1976                supportedPreviewFormats +=
1977                    CameraParameters::PIXEL_FORMAT_RGB565;
1978                break;
1979            case HAL_PIXEL_FORMAT_RGBA_8888:
1980                supportedPreviewFormats +=
1981                    CameraParameters::PIXEL_FORMAT_RGBA8888;
1982                break;
1983            // Not advertizing JPEG, RAW_SENSOR, etc, for preview formats
1984            case HAL_PIXEL_FORMAT_RAW_SENSOR:
1985            case HAL_PIXEL_FORMAT_BLOB:
1986                addComma = false;
1987                break;
1988
1989            default:
1990                ALOGW("%s: Camera %d: Unknown preview format: %x",
1991                        __FUNCTION__, mCameraId, availableFormats.data.i32[i]);
1992                addComma = false;
1993                break;
1994            }
1995        }
1996        params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS,
1997                supportedPreviewFormats);
1998    }
1999
2000    // PREVIEW_FRAME_RATE / SUPPORTED_PREVIEW_FRAME_RATES are deprecated, but
2001    // still have to do something sane for them
2002
2003    params.set(CameraParameters::KEY_PREVIEW_FRAME_RATE,
2004            k.mParameters.previewFpsRange[0]);
2005
2006    {
2007        String8 supportedPreviewFrameRates;
2008        for (size_t i=0; i < availableFpsRanges.count; i += 2) {
2009            if (i != 0) supportedPreviewFrameRates += ",";
2010            supportedPreviewFrameRates += String8::format("%d",
2011                    availableFpsRanges.data.i32[i]);
2012        }
2013        params.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES,
2014                supportedPreviewFrameRates);
2015    }
2016
2017    camera_metadata_entry_t availableJpegSizes =
2018        staticInfo(ANDROID_SCALER_AVAILABLE_JPEG_SIZES, 2);
2019    if (!availableJpegSizes.count) return NO_INIT;
2020
2021    // TODO: Pick maximum
2022    k.mParameters.pictureWidth = availableJpegSizes.data.i32[0];
2023    k.mParameters.pictureHeight = availableJpegSizes.data.i32[1];
2024
2025    params.setPictureSize(k.mParameters.pictureWidth,
2026            k.mParameters.pictureHeight);
2027
2028    {
2029        String8 supportedPictureSizes;
2030        for (size_t i=0; i < availableJpegSizes.count; i += 2) {
2031            if (i != 0) supportedPictureSizes += ",";
2032            supportedPictureSizes += String8::format("%dx%d",
2033                    availableJpegSizes.data.i32[i],
2034                    availableJpegSizes.data.i32[i+1]);
2035        }
2036        params.set(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES,
2037                supportedPictureSizes);
2038    }
2039
2040    params.setPictureFormat(CameraParameters::PIXEL_FORMAT_JPEG);
2041    params.set(CameraParameters::KEY_SUPPORTED_PICTURE_FORMATS,
2042            CameraParameters::PIXEL_FORMAT_JPEG);
2043
2044    camera_metadata_entry_t availableJpegThumbnailSizes =
2045        staticInfo(ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES, 2);
2046    if (!availableJpegThumbnailSizes.count) return NO_INIT;
2047
2048    // TODO: Pick default thumbnail size sensibly
2049    k.mParameters.jpegThumbSize[0] = availableJpegThumbnailSizes.data.i32[0];
2050    k.mParameters.jpegThumbSize[1] = availableJpegThumbnailSizes.data.i32[1];
2051
2052    params.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH,
2053            k.mParameters.jpegThumbSize[0]);
2054    params.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT,
2055            k.mParameters.jpegThumbSize[1]);
2056
2057    {
2058        String8 supportedJpegThumbSizes;
2059        for (size_t i=0; i < availableJpegThumbnailSizes.count; i += 2) {
2060            if (i != 0) supportedJpegThumbSizes += ",";
2061            supportedJpegThumbSizes += String8::format("%dx%d",
2062                    availableJpegThumbnailSizes.data.i32[i],
2063                    availableJpegThumbnailSizes.data.i32[i+1]);
2064        }
2065        params.set(CameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES,
2066                supportedJpegThumbSizes);
2067    }
2068
2069    k.mParameters.jpegThumbQuality = 90;
2070    params.set(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY,
2071            k.mParameters.jpegThumbQuality);
2072    k.mParameters.jpegQuality = 90;
2073    params.set(CameraParameters::KEY_JPEG_QUALITY,
2074            k.mParameters.jpegQuality);
2075    k.mParameters.jpegRotation = 0;
2076    params.set(CameraParameters::KEY_ROTATION,
2077            k.mParameters.jpegRotation);
2078
2079    k.mParameters.gpsEnabled = false;
2080    k.mParameters.gpsProcessingMethod = "unknown";
2081    // GPS fields in CameraParameters are not set by implementation
2082
2083    k.mParameters.wbMode = ANDROID_CONTROL_AWB_AUTO;
2084    params.set(CameraParameters::KEY_WHITE_BALANCE,
2085            CameraParameters::WHITE_BALANCE_AUTO);
2086
2087    camera_metadata_entry_t availableWhiteBalanceModes =
2088        staticInfo(ANDROID_CONTROL_AWB_AVAILABLE_MODES);
2089    {
2090        String8 supportedWhiteBalance;
2091        bool addComma = false;
2092        for (size_t i=0; i < availableWhiteBalanceModes.count; i++) {
2093            if (addComma) supportedWhiteBalance += ",";
2094            addComma = true;
2095            switch (availableWhiteBalanceModes.data.u8[i]) {
2096            case ANDROID_CONTROL_AWB_AUTO:
2097                supportedWhiteBalance +=
2098                    CameraParameters::WHITE_BALANCE_AUTO;
2099                break;
2100            case ANDROID_CONTROL_AWB_INCANDESCENT:
2101                supportedWhiteBalance +=
2102                    CameraParameters::WHITE_BALANCE_INCANDESCENT;
2103                break;
2104            case ANDROID_CONTROL_AWB_FLUORESCENT:
2105                supportedWhiteBalance +=
2106                    CameraParameters::WHITE_BALANCE_FLUORESCENT;
2107                break;
2108            case ANDROID_CONTROL_AWB_WARM_FLUORESCENT:
2109                supportedWhiteBalance +=
2110                    CameraParameters::WHITE_BALANCE_WARM_FLUORESCENT;
2111                break;
2112            case ANDROID_CONTROL_AWB_DAYLIGHT:
2113                supportedWhiteBalance +=
2114                    CameraParameters::WHITE_BALANCE_DAYLIGHT;
2115                break;
2116            case ANDROID_CONTROL_AWB_CLOUDY_DAYLIGHT:
2117                supportedWhiteBalance +=
2118                    CameraParameters::WHITE_BALANCE_CLOUDY_DAYLIGHT;
2119                break;
2120            case ANDROID_CONTROL_AWB_TWILIGHT:
2121                supportedWhiteBalance +=
2122                    CameraParameters::WHITE_BALANCE_TWILIGHT;
2123                break;
2124            case ANDROID_CONTROL_AWB_SHADE:
2125                supportedWhiteBalance +=
2126                    CameraParameters::WHITE_BALANCE_SHADE;
2127                break;
2128            // Skipping values not mappable to v1 API
2129            case ANDROID_CONTROL_AWB_OFF:
2130                addComma = false;
2131                break;
2132            default:
2133                ALOGW("%s: Camera %d: Unknown white balance value: %d",
2134                        __FUNCTION__, mCameraId,
2135                        availableWhiteBalanceModes.data.u8[i]);
2136                addComma = false;
2137                break;
2138            }
2139        }
2140        params.set(CameraParameters::KEY_SUPPORTED_WHITE_BALANCE,
2141                supportedWhiteBalance);
2142    }
2143
2144    k.mParameters.effectMode = ANDROID_CONTROL_EFFECT_OFF;
2145    params.set(CameraParameters::KEY_EFFECT,
2146            CameraParameters::EFFECT_NONE);
2147
2148    camera_metadata_entry_t availableEffects =
2149        staticInfo(ANDROID_CONTROL_AVAILABLE_EFFECTS);
2150    if (!availableEffects.count) return NO_INIT;
2151    {
2152        String8 supportedEffects;
2153        bool addComma = false;
2154        for (size_t i=0; i < availableEffects.count; i++) {
2155            if (addComma) supportedEffects += ",";
2156            addComma = true;
2157            switch (availableEffects.data.u8[i]) {
2158                case ANDROID_CONTROL_EFFECT_OFF:
2159                    supportedEffects +=
2160                        CameraParameters::EFFECT_NONE;
2161                    break;
2162                case ANDROID_CONTROL_EFFECT_MONO:
2163                    supportedEffects +=
2164                        CameraParameters::EFFECT_MONO;
2165                    break;
2166                case ANDROID_CONTROL_EFFECT_NEGATIVE:
2167                    supportedEffects +=
2168                        CameraParameters::EFFECT_NEGATIVE;
2169                    break;
2170                case ANDROID_CONTROL_EFFECT_SOLARIZE:
2171                    supportedEffects +=
2172                        CameraParameters::EFFECT_SOLARIZE;
2173                    break;
2174                case ANDROID_CONTROL_EFFECT_SEPIA:
2175                    supportedEffects +=
2176                        CameraParameters::EFFECT_SEPIA;
2177                    break;
2178                case ANDROID_CONTROL_EFFECT_POSTERIZE:
2179                    supportedEffects +=
2180                        CameraParameters::EFFECT_POSTERIZE;
2181                    break;
2182                case ANDROID_CONTROL_EFFECT_WHITEBOARD:
2183                    supportedEffects +=
2184                        CameraParameters::EFFECT_WHITEBOARD;
2185                    break;
2186                case ANDROID_CONTROL_EFFECT_BLACKBOARD:
2187                    supportedEffects +=
2188                        CameraParameters::EFFECT_BLACKBOARD;
2189                    break;
2190                case ANDROID_CONTROL_EFFECT_AQUA:
2191                    supportedEffects +=
2192                        CameraParameters::EFFECT_AQUA;
2193                    break;
2194                default:
2195                    ALOGW("%s: Camera %d: Unknown effect value: %d",
2196                        __FUNCTION__, mCameraId, availableEffects.data.u8[i]);
2197                    addComma = false;
2198                    break;
2199            }
2200        }
2201        params.set(CameraParameters::KEY_SUPPORTED_EFFECTS, supportedEffects);
2202    }
2203
2204    k.mParameters.antibandingMode = ANDROID_CONTROL_AE_ANTIBANDING_AUTO;
2205    params.set(CameraParameters::KEY_ANTIBANDING,
2206            CameraParameters::ANTIBANDING_AUTO);
2207
2208    camera_metadata_entry_t availableAntibandingModes =
2209        staticInfo(ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES);
2210    if (!availableAntibandingModes.count) return NO_INIT;
2211    {
2212        String8 supportedAntibanding;
2213        bool addComma = false;
2214        for (size_t i=0; i < availableAntibandingModes.count; i++) {
2215            if (addComma) supportedAntibanding += ",";
2216            addComma = true;
2217            switch (availableAntibandingModes.data.u8[i]) {
2218                case ANDROID_CONTROL_AE_ANTIBANDING_OFF:
2219                    supportedAntibanding +=
2220                        CameraParameters::ANTIBANDING_OFF;
2221                    break;
2222                case ANDROID_CONTROL_AE_ANTIBANDING_50HZ:
2223                    supportedAntibanding +=
2224                        CameraParameters::ANTIBANDING_50HZ;
2225                    break;
2226                case ANDROID_CONTROL_AE_ANTIBANDING_60HZ:
2227                    supportedAntibanding +=
2228                        CameraParameters::ANTIBANDING_60HZ;
2229                    break;
2230                case ANDROID_CONTROL_AE_ANTIBANDING_AUTO:
2231                    supportedAntibanding +=
2232                        CameraParameters::ANTIBANDING_AUTO;
2233                    break;
2234                default:
2235                    ALOGW("%s: Camera %d: Unknown antibanding value: %d",
2236                        __FUNCTION__, mCameraId,
2237                            availableAntibandingModes.data.u8[i]);
2238                    addComma = false;
2239                    break;
2240            }
2241        }
2242        params.set(CameraParameters::KEY_SUPPORTED_ANTIBANDING,
2243                supportedAntibanding);
2244    }
2245
2246    k.mParameters.sceneMode = ANDROID_CONTROL_OFF;
2247    params.set(CameraParameters::KEY_SCENE_MODE,
2248            CameraParameters::SCENE_MODE_AUTO);
2249
2250    camera_metadata_entry_t availableSceneModes =
2251        staticInfo(ANDROID_CONTROL_AVAILABLE_SCENE_MODES);
2252    if (!availableSceneModes.count) return NO_INIT;
2253    {
2254        String8 supportedSceneModes(CameraParameters::SCENE_MODE_AUTO);
2255        bool addComma = true;
2256        bool noSceneModes = false;
2257        for (size_t i=0; i < availableSceneModes.count; i++) {
2258            if (addComma) supportedSceneModes += ",";
2259            addComma = true;
2260            switch (availableSceneModes.data.u8[i]) {
2261                case ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED:
2262                    noSceneModes = true;
2263                    break;
2264                case ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY:
2265                    // Not in old API
2266                    addComma = false;
2267                    break;
2268                case ANDROID_CONTROL_SCENE_MODE_ACTION:
2269                    supportedSceneModes +=
2270                        CameraParameters::SCENE_MODE_ACTION;
2271                    break;
2272                case ANDROID_CONTROL_SCENE_MODE_PORTRAIT:
2273                    supportedSceneModes +=
2274                        CameraParameters::SCENE_MODE_PORTRAIT;
2275                    break;
2276                case ANDROID_CONTROL_SCENE_MODE_LANDSCAPE:
2277                    supportedSceneModes +=
2278                        CameraParameters::SCENE_MODE_LANDSCAPE;
2279                    break;
2280                case ANDROID_CONTROL_SCENE_MODE_NIGHT:
2281                    supportedSceneModes +=
2282                        CameraParameters::SCENE_MODE_NIGHT;
2283                    break;
2284                case ANDROID_CONTROL_SCENE_MODE_NIGHT_PORTRAIT:
2285                    supportedSceneModes +=
2286                        CameraParameters::SCENE_MODE_NIGHT_PORTRAIT;
2287                    break;
2288                case ANDROID_CONTROL_SCENE_MODE_THEATRE:
2289                    supportedSceneModes +=
2290                        CameraParameters::SCENE_MODE_THEATRE;
2291                    break;
2292                case ANDROID_CONTROL_SCENE_MODE_BEACH:
2293                    supportedSceneModes +=
2294                        CameraParameters::SCENE_MODE_BEACH;
2295                    break;
2296                case ANDROID_CONTROL_SCENE_MODE_SNOW:
2297                    supportedSceneModes +=
2298                        CameraParameters::SCENE_MODE_SNOW;
2299                    break;
2300                case ANDROID_CONTROL_SCENE_MODE_SUNSET:
2301                    supportedSceneModes +=
2302                        CameraParameters::SCENE_MODE_SUNSET;
2303                    break;
2304                case ANDROID_CONTROL_SCENE_MODE_STEADYPHOTO:
2305                    supportedSceneModes +=
2306                        CameraParameters::SCENE_MODE_STEADYPHOTO;
2307                    break;
2308                case ANDROID_CONTROL_SCENE_MODE_FIREWORKS:
2309                    supportedSceneModes +=
2310                        CameraParameters::SCENE_MODE_FIREWORKS;
2311                    break;
2312                case ANDROID_CONTROL_SCENE_MODE_SPORTS:
2313                    supportedSceneModes +=
2314                        CameraParameters::SCENE_MODE_SPORTS;
2315                    break;
2316                case ANDROID_CONTROL_SCENE_MODE_PARTY:
2317                    supportedSceneModes +=
2318                        CameraParameters::SCENE_MODE_PARTY;
2319                    break;
2320                case ANDROID_CONTROL_SCENE_MODE_CANDLELIGHT:
2321                    supportedSceneModes +=
2322                        CameraParameters::SCENE_MODE_CANDLELIGHT;
2323                    break;
2324                case ANDROID_CONTROL_SCENE_MODE_BARCODE:
2325                    supportedSceneModes +=
2326                        CameraParameters::SCENE_MODE_BARCODE;
2327                    break;
2328                default:
2329                    ALOGW("%s: Camera %d: Unknown scene mode value: %d",
2330                        __FUNCTION__, mCameraId,
2331                            availableSceneModes.data.u8[i]);
2332                    addComma = false;
2333                    break;
2334            }
2335        }
2336        if (!noSceneModes) {
2337            params.set(CameraParameters::KEY_SUPPORTED_SCENE_MODES,
2338                    supportedSceneModes);
2339        }
2340    }
2341
2342    camera_metadata_entry_t flashAvailable =
2343        staticInfo(ANDROID_FLASH_AVAILABLE, 1, 1);
2344    if (!flashAvailable.count) return NO_INIT;
2345
2346    camera_metadata_entry_t availableAeModes =
2347        staticInfo(ANDROID_CONTROL_AE_AVAILABLE_MODES);
2348    if (!availableAeModes.count) return NO_INIT;
2349
2350    if (flashAvailable.data.u8[0]) {
2351        k.mParameters.flashMode = Parameters::FLASH_MODE_AUTO;
2352        params.set(CameraParameters::KEY_FLASH_MODE,
2353                CameraParameters::FLASH_MODE_AUTO);
2354
2355        String8 supportedFlashModes(CameraParameters::FLASH_MODE_OFF);
2356        supportedFlashModes = supportedFlashModes +
2357            "," + CameraParameters::FLASH_MODE_AUTO +
2358            "," + CameraParameters::FLASH_MODE_ON +
2359            "," + CameraParameters::FLASH_MODE_TORCH;
2360        for (size_t i=0; i < availableAeModes.count; i++) {
2361            if (availableAeModes.data.u8[i] ==
2362                    ANDROID_CONTROL_AE_ON_AUTO_FLASH_REDEYE) {
2363                supportedFlashModes = supportedFlashModes + "," +
2364                    CameraParameters::FLASH_MODE_RED_EYE;
2365                break;
2366            }
2367        }
2368        params.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES,
2369                supportedFlashModes);
2370    } else {
2371        k.mParameters.flashMode = Parameters::FLASH_MODE_OFF;
2372        params.set(CameraParameters::KEY_FLASH_MODE,
2373                CameraParameters::FLASH_MODE_OFF);
2374        params.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES,
2375                CameraParameters::FLASH_MODE_OFF);
2376    }
2377
2378    camera_metadata_entry_t minFocusDistance =
2379        staticInfo(ANDROID_LENS_MINIMUM_FOCUS_DISTANCE, 1, 1);
2380    if (!minFocusDistance.count) return NO_INIT;
2381
2382    camera_metadata_entry_t availableAfModes =
2383        staticInfo(ANDROID_CONTROL_AF_AVAILABLE_MODES);
2384    if (!availableAfModes.count) return NO_INIT;
2385
2386    if (minFocusDistance.data.f[0] == 0) {
2387        // Fixed-focus lens
2388        k.mParameters.focusMode = Parameters::FOCUS_MODE_FIXED;
2389        params.set(CameraParameters::KEY_FOCUS_MODE,
2390                CameraParameters::FOCUS_MODE_FIXED);
2391        params.set(CameraParameters::KEY_SUPPORTED_FOCUS_MODES,
2392                CameraParameters::FOCUS_MODE_FIXED);
2393    } else {
2394        k.mParameters.focusMode = Parameters::FOCUS_MODE_AUTO;
2395        params.set(CameraParameters::KEY_FOCUS_MODE,
2396                CameraParameters::FOCUS_MODE_AUTO);
2397        String8 supportedFocusModes(CameraParameters::FOCUS_MODE_FIXED);
2398        supportedFocusModes = supportedFocusModes + "," +
2399            CameraParameters::FOCUS_MODE_INFINITY;
2400        bool addComma = true;
2401
2402        for (size_t i=0; i < availableAfModes.count; i++) {
2403            if (addComma) supportedFocusModes += ",";
2404            addComma = true;
2405            switch (availableAfModes.data.u8[i]) {
2406                case ANDROID_CONTROL_AF_AUTO:
2407                    supportedFocusModes +=
2408                        CameraParameters::FOCUS_MODE_AUTO;
2409                    break;
2410                case ANDROID_CONTROL_AF_MACRO:
2411                    supportedFocusModes +=
2412                        CameraParameters::FOCUS_MODE_MACRO;
2413                    break;
2414                case ANDROID_CONTROL_AF_CONTINUOUS_VIDEO:
2415                    supportedFocusModes +=
2416                        CameraParameters::FOCUS_MODE_CONTINUOUS_VIDEO;
2417                    break;
2418                case ANDROID_CONTROL_AF_CONTINUOUS_PICTURE:
2419                    supportedFocusModes +=
2420                        CameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE;
2421                    break;
2422                case ANDROID_CONTROL_AF_EDOF:
2423                    supportedFocusModes +=
2424                        CameraParameters::FOCUS_MODE_EDOF;
2425                    break;
2426                // Not supported in old API
2427                case ANDROID_CONTROL_AF_OFF:
2428                    addComma = false;
2429                    break;
2430                default:
2431                    ALOGW("%s: Camera %d: Unknown AF mode value: %d",
2432                        __FUNCTION__, mCameraId, availableAfModes.data.u8[i]);
2433                    addComma = false;
2434                    break;
2435            }
2436        }
2437        params.set(CameraParameters::KEY_SUPPORTED_FOCUS_MODES,
2438                supportedFocusModes);
2439    }
2440
2441    camera_metadata_entry_t max3aRegions =
2442        staticInfo(ANDROID_CONTROL_MAX_REGIONS, 1, 1);
2443    if (!max3aRegions.count) return NO_INIT;
2444
2445    params.set(CameraParameters::KEY_MAX_NUM_FOCUS_AREAS,
2446            max3aRegions.data.i32[0]);
2447    params.set(CameraParameters::KEY_FOCUS_AREAS,
2448            "(0,0,0,0,0)");
2449    k.mParameters.focusingAreas.clear();
2450    k.mParameters.focusingAreas.add(Parameters::Area(0,0,0,0,0));
2451
2452    camera_metadata_entry_t availableFocalLengths =
2453        staticInfo(ANDROID_LENS_AVAILABLE_FOCAL_LENGTHS);
2454    if (!availableFocalLengths.count) return NO_INIT;
2455
2456    float minFocalLength = availableFocalLengths.data.f[0];
2457    params.setFloat(CameraParameters::KEY_FOCAL_LENGTH, minFocalLength);
2458
2459    camera_metadata_entry_t sensorSize =
2460        staticInfo(ANDROID_SENSOR_PHYSICAL_SIZE, 2, 2);
2461    if (!sensorSize.count) return NO_INIT;
2462
2463    // The fields of view here assume infinity focus, maximum wide angle
2464    float horizFov = 180 / M_PI *
2465            2 * atanf(sensorSize.data.f[0] / (2 * minFocalLength));
2466    float vertFov  = 180 / M_PI *
2467            2 * atanf(sensorSize.data.f[1] / (2 * minFocalLength));
2468    params.setFloat(CameraParameters::KEY_HORIZONTAL_VIEW_ANGLE, horizFov);
2469    params.setFloat(CameraParameters::KEY_VERTICAL_VIEW_ANGLE, vertFov);
2470
2471    k.mParameters.exposureCompensation = 0;
2472    params.set(CameraParameters::KEY_EXPOSURE_COMPENSATION,
2473                k.mParameters.exposureCompensation);
2474
2475    camera_metadata_entry_t exposureCompensationRange =
2476        staticInfo(ANDROID_CONTROL_AE_EXP_COMPENSATION_RANGE, 2, 2);
2477    if (!exposureCompensationRange.count) return NO_INIT;
2478
2479    params.set(CameraParameters::KEY_MAX_EXPOSURE_COMPENSATION,
2480            exposureCompensationRange.data.i32[1]);
2481    params.set(CameraParameters::KEY_MIN_EXPOSURE_COMPENSATION,
2482            exposureCompensationRange.data.i32[0]);
2483
2484    camera_metadata_entry_t exposureCompensationStep =
2485        staticInfo(ANDROID_CONTROL_AE_EXP_COMPENSATION_STEP, 1, 1);
2486    if (!exposureCompensationStep.count) return NO_INIT;
2487
2488    params.setFloat(CameraParameters::KEY_EXPOSURE_COMPENSATION_STEP,
2489            (float)exposureCompensationStep.data.r[0].numerator /
2490            exposureCompensationStep.data.r[0].denominator);
2491
2492    k.mParameters.autoExposureLock = false;
2493    params.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK,
2494            CameraParameters::FALSE);
2495    params.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK_SUPPORTED,
2496            CameraParameters::TRUE);
2497
2498    k.mParameters.autoWhiteBalanceLock = false;
2499    params.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK,
2500            CameraParameters::FALSE);
2501    params.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK_SUPPORTED,
2502            CameraParameters::TRUE);
2503
2504    k.mParameters.meteringAreas.add(Parameters::Area(0, 0, 0, 0, 0));
2505    params.set(CameraParameters::KEY_MAX_NUM_METERING_AREAS,
2506            max3aRegions.data.i32[0]);
2507    params.set(CameraParameters::KEY_METERING_AREAS,
2508            "(0,0,0,0,0)");
2509
2510    k.mParameters.zoom = 0;
2511    params.set(CameraParameters::KEY_ZOOM, k.mParameters.zoom);
2512    params.set(CameraParameters::KEY_MAX_ZOOM, NUM_ZOOM_STEPS - 1);
2513
2514    camera_metadata_entry_t maxDigitalZoom =
2515        staticInfo(ANDROID_SCALER_AVAILABLE_MAX_ZOOM, 1, 1);
2516    if (!maxDigitalZoom.count) return NO_INIT;
2517
2518    {
2519        String8 zoomRatios;
2520        float zoom = 1.f;
2521        float zoomIncrement = (maxDigitalZoom.data.f[0] - zoom) /
2522                (NUM_ZOOM_STEPS-1);
2523        bool addComma = false;
2524        for (size_t i=0; i < NUM_ZOOM_STEPS; i++) {
2525            if (addComma) zoomRatios += ",";
2526            addComma = true;
2527            zoomRatios += String8::format("%d", static_cast<int>(zoom * 100));
2528            zoom += zoomIncrement;
2529        }
2530        params.set(CameraParameters::KEY_ZOOM_RATIOS, zoomRatios);
2531    }
2532
2533    params.set(CameraParameters::KEY_ZOOM_SUPPORTED,
2534            CameraParameters::TRUE);
2535    params.set(CameraParameters::KEY_SMOOTH_ZOOM_SUPPORTED,
2536            CameraParameters::TRUE);
2537
2538    params.set(CameraParameters::KEY_FOCUS_DISTANCES,
2539            "Infinity,Infinity,Infinity");
2540
2541    camera_metadata_entry_t maxFacesDetected =
2542        staticInfo(ANDROID_STATS_MAX_FACE_COUNT, 1, 1);
2543    params.set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_HW,
2544            maxFacesDetected.data.i32[0]);
2545    params.set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_SW,
2546            0);
2547
2548    params.set(CameraParameters::KEY_VIDEO_FRAME_FORMAT,
2549            CameraParameters::PIXEL_FORMAT_ANDROID_OPAQUE);
2550
2551    params.set(CameraParameters::KEY_RECORDING_HINT,
2552            CameraParameters::FALSE);
2553
2554    params.set(CameraParameters::KEY_VIDEO_SNAPSHOT_SUPPORTED,
2555            CameraParameters::TRUE);
2556
2557    params.set(CameraParameters::KEY_VIDEO_STABILIZATION,
2558            CameraParameters::FALSE);
2559
2560    camera_metadata_entry_t availableVideoStabilizationModes =
2561        staticInfo(ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES);
2562    if (!availableVideoStabilizationModes.count) return NO_INIT;
2563
2564    if (availableVideoStabilizationModes.count > 1) {
2565        params.set(CameraParameters::KEY_VIDEO_STABILIZATION_SUPPORTED,
2566                CameraParameters::TRUE);
2567    } else {
2568        params.set(CameraParameters::KEY_VIDEO_STABILIZATION_SUPPORTED,
2569                CameraParameters::FALSE);
2570    }
2571
2572    // Set up initial state for non-Camera.Parameters state variables
2573
2574    k.mParameters.storeMetadataInBuffers = true;
2575    k.mParameters.playShutterSound = true;
2576
2577    k.mParameters.paramsFlattened = params.flatten();
2578
2579    return OK;
2580}
2581
2582status_t Camera2Client::updatePreviewStream(const Parameters &params) {
2583    ATRACE_CALL();
2584    status_t res;
2585
2586    if (mPreviewStreamId != NO_STREAM) {
2587        // Check if stream parameters have to change
2588        uint32_t currentWidth, currentHeight;
2589        res = mDevice->getStreamInfo(mPreviewStreamId,
2590                &currentWidth, &currentHeight, 0);
2591        if (res != OK) {
2592            ALOGE("%s: Camera %d: Error querying preview stream info: "
2593                    "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res);
2594            return res;
2595        }
2596        if (currentWidth != (uint32_t)params.previewWidth ||
2597                currentHeight != (uint32_t)params.previewHeight) {
2598            ALOGV("%s: Camera %d: Preview size switch: %d x %d -> %d x %d",
2599                    __FUNCTION__, mCameraId, currentWidth, currentHeight,
2600                    params.previewWidth, params.previewHeight);
2601            res = mDevice->waitUntilDrained();
2602            if (res != OK) {
2603                ALOGE("%s: Camera %d: Error waiting for preview to drain: "
2604                        "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res);
2605                return res;
2606            }
2607            res = mDevice->deleteStream(mPreviewStreamId);
2608            if (res != OK) {
2609                ALOGE("%s: Camera %d: Unable to delete old output stream "
2610                        "for preview: %s (%d)", __FUNCTION__, mCameraId,
2611                        strerror(-res), res);
2612                return res;
2613            }
2614            mPreviewStreamId = NO_STREAM;
2615        }
2616    }
2617
2618    if (mPreviewStreamId == NO_STREAM) {
2619        res = mDevice->createStream(mPreviewWindow,
2620                params.previewWidth, params.previewHeight,
2621                CAMERA2_HAL_PIXEL_FORMAT_OPAQUE, 0,
2622                &mPreviewStreamId);
2623        if (res != OK) {
2624            ALOGE("%s: Camera %d: Unable to create preview stream: %s (%d)",
2625                    __FUNCTION__, mCameraId, strerror(-res), res);
2626            return res;
2627        }
2628    }
2629
2630    res = mDevice->setStreamTransform(mPreviewStreamId,
2631            params.previewTransform);
2632    if (res != OK) {
2633        ALOGE("%s: Camera %d: Unable to set preview stream transform: "
2634                "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res);
2635        return res;
2636    }
2637
2638    return OK;
2639}
2640
2641status_t Camera2Client::updatePreviewRequest(const Parameters &params) {
2642    ATRACE_CALL();
2643    status_t res;
2644    if (mPreviewRequest == NULL) {
2645        res = mDevice->createDefaultRequest(CAMERA2_TEMPLATE_PREVIEW,
2646                &mPreviewRequest);
2647        if (res != OK) {
2648            ALOGE("%s: Camera %d: Unable to create default preview request: "
2649                    "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res);
2650            return res;
2651        }
2652    }
2653
2654    res = updateRequestCommon(mPreviewRequest, params);
2655    if (res != OK) {
2656        ALOGE("%s: Camera %d: Unable to update common entries of preview "
2657                "request: %s (%d)", __FUNCTION__, mCameraId,
2658                strerror(-res), res);
2659        return res;
2660    }
2661
2662    return OK;
2663}
2664
2665status_t Camera2Client::updateCaptureStream(const Parameters &params) {
2666    ATRACE_CALL();
2667    status_t res;
2668    // Find out buffer size for JPEG
2669    camera_metadata_entry_t maxJpegSize =
2670            staticInfo(ANDROID_JPEG_MAX_SIZE);
2671    if (maxJpegSize.count == 0) {
2672        ALOGE("%s: Camera %d: Can't find ANDROID_JPEG_MAX_SIZE!",
2673                __FUNCTION__, mCameraId);
2674        return INVALID_OPERATION;
2675    }
2676
2677    if (mCaptureConsumer == 0) {
2678        // Create CPU buffer queue endpoint
2679        mCaptureConsumer = new CpuConsumer(1);
2680        mCaptureConsumer->setFrameAvailableListener(new CaptureWaiter(this));
2681        mCaptureConsumer->setName(String8("Camera2Client::CaptureConsumer"));
2682        mCaptureWindow = new SurfaceTextureClient(
2683            mCaptureConsumer->getProducerInterface());
2684        // Create memory for API consumption
2685        mCaptureHeap = new Camera2Heap(maxJpegSize.data.i32[0], 1,
2686                                       "Camera2Client::CaptureHeap");
2687        if (mCaptureHeap->mHeap->getSize() == 0) {
2688            ALOGE("%s: Camera %d: Unable to allocate memory for capture",
2689                    __FUNCTION__, mCameraId);
2690            return NO_MEMORY;
2691        }
2692    }
2693
2694    if (mCaptureStreamId != NO_STREAM) {
2695        // Check if stream parameters have to change
2696        uint32_t currentWidth, currentHeight;
2697        res = mDevice->getStreamInfo(mCaptureStreamId,
2698                &currentWidth, &currentHeight, 0);
2699        if (res != OK) {
2700            ALOGE("%s: Camera %d: Error querying capture output stream info: "
2701                    "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res);
2702            return res;
2703        }
2704        if (currentWidth != (uint32_t)params.pictureWidth ||
2705                currentHeight != (uint32_t)params.pictureHeight) {
2706            res = mDevice->deleteStream(mCaptureStreamId);
2707            if (res != OK) {
2708                ALOGE("%s: Camera %d: Unable to delete old output stream "
2709                        "for capture: %s (%d)", __FUNCTION__, mCameraId,
2710                        strerror(-res), res);
2711                return res;
2712            }
2713            mCaptureStreamId = NO_STREAM;
2714        }
2715    }
2716
2717    if (mCaptureStreamId == NO_STREAM) {
2718        // Create stream for HAL production
2719        res = mDevice->createStream(mCaptureWindow,
2720                params.pictureWidth, params.pictureHeight,
2721                HAL_PIXEL_FORMAT_BLOB, maxJpegSize.data.i32[0],
2722                &mCaptureStreamId);
2723        if (res != OK) {
2724            ALOGE("%s: Camera %d: Can't create output stream for capture: "
2725                    "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res);
2726            return res;
2727        }
2728
2729    }
2730    return OK;
2731}
2732
2733status_t Camera2Client::updateCaptureRequest(const Parameters &params) {
2734    ATRACE_CALL();
2735    status_t res;
2736    if (mCaptureRequest == NULL) {
2737        res = mDevice->createDefaultRequest(CAMERA2_TEMPLATE_STILL_CAPTURE,
2738                &mCaptureRequest);
2739        if (res != OK) {
2740            ALOGE("%s: Camera %d: Unable to create default still image request:"
2741                    " %s (%d)", __FUNCTION__, mCameraId, strerror(-res), res);
2742            return res;
2743        }
2744    }
2745
2746    res = updateRequestCommon(mCaptureRequest, params);
2747    if (res != OK) {
2748        ALOGE("%s: Camera %d: Unable to update common entries of capture "
2749                "request: %s (%d)", __FUNCTION__, mCameraId,
2750                strerror(-res), res);
2751        return res;
2752    }
2753
2754    res = updateEntry(mCaptureRequest,
2755            ANDROID_JPEG_THUMBNAIL_SIZE,
2756            params.jpegThumbSize, 2);
2757    if (res != OK) return res;
2758    res = updateEntry(mCaptureRequest,
2759            ANDROID_JPEG_THUMBNAIL_QUALITY,
2760            &params.jpegThumbQuality, 1);
2761    if (res != OK) return res;
2762    res = updateEntry(mCaptureRequest,
2763            ANDROID_JPEG_QUALITY,
2764            &params.jpegQuality, 1);
2765    if (res != OK) return res;
2766    res = updateEntry(mCaptureRequest,
2767            ANDROID_JPEG_ORIENTATION,
2768            &params.jpegRotation, 1);
2769    if (res != OK) return res;
2770
2771    if (params.gpsEnabled) {
2772        res = updateEntry(mCaptureRequest,
2773                ANDROID_JPEG_GPS_COORDINATES,
2774                params.gpsCoordinates, 3);
2775        if (res != OK) return res;
2776        res = updateEntry(mCaptureRequest,
2777                ANDROID_JPEG_GPS_TIMESTAMP,
2778                &params.gpsTimestamp, 1);
2779        if (res != OK) return res;
2780        res = updateEntry(mCaptureRequest,
2781                ANDROID_JPEG_GPS_PROCESSING_METHOD,
2782                params.gpsProcessingMethod.string(),
2783                params.gpsProcessingMethod.size());
2784        if (res != OK) return res;
2785    } else {
2786        res = deleteEntry(mCaptureRequest,
2787                ANDROID_JPEG_GPS_COORDINATES);
2788        if (res != OK) return res;
2789        res = deleteEntry(mCaptureRequest,
2790                ANDROID_JPEG_GPS_TIMESTAMP);
2791        if (res != OK) return res;
2792        res = deleteEntry(mCaptureRequest,
2793                ANDROID_JPEG_GPS_PROCESSING_METHOD);
2794        if (res != OK) return res;
2795    }
2796
2797    return OK;
2798}
2799
2800status_t Camera2Client::updateRecordingRequest(const Parameters &params) {
2801    ATRACE_CALL();
2802    status_t res;
2803    if (mRecordingRequest == NULL) {
2804        res = mDevice->createDefaultRequest(CAMERA2_TEMPLATE_VIDEO_RECORD,
2805                &mRecordingRequest);
2806        if (res != OK) {
2807            ALOGE("%s: Camera %d: Unable to create default recording request:"
2808                    " %s (%d)", __FUNCTION__, mCameraId, strerror(-res), res);
2809            return res;
2810        }
2811    }
2812
2813    res = updateRequestCommon(mRecordingRequest, params);
2814    if (res != OK) {
2815        ALOGE("%s: Camera %d: Unable to update common entries of recording "
2816                "request: %s (%d)", __FUNCTION__, mCameraId,
2817                strerror(-res), res);
2818        return res;
2819    }
2820
2821    return OK;
2822}
2823
2824status_t Camera2Client::updateRecordingStream(const Parameters &params) {
2825    status_t res;
2826
2827    if (mRecordingConsumer == 0) {
2828        // Create CPU buffer queue endpoint
2829        mRecordingConsumer = new MediaConsumer(mRecordingHeapCount);
2830        mRecordingConsumer->setFrameAvailableListener(new RecordingWaiter(this));
2831        mRecordingConsumer->setName(String8("Camera2Client::RecordingConsumer"));
2832        mRecordingWindow = new SurfaceTextureClient(
2833            mRecordingConsumer->getProducerInterface());
2834        // Allocate memory later, since we don't know buffer size until receipt
2835    }
2836
2837    if (mRecordingStreamId != NO_STREAM) {
2838        // Check if stream parameters have to change
2839        uint32_t currentWidth, currentHeight;
2840        res = mDevice->getStreamInfo(mRecordingStreamId,
2841                &currentWidth, &currentHeight, 0);
2842        if (res != OK) {
2843            ALOGE("%s: Camera %d: Error querying recording output stream info: "
2844                    "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res);
2845            return res;
2846        }
2847        if (currentWidth != (uint32_t)params.videoWidth ||
2848                currentHeight != (uint32_t)params.videoHeight) {
2849            // TODO: Should wait to be sure previous recording has finished
2850            res = mDevice->deleteStream(mRecordingStreamId);
2851            if (res != OK) {
2852                ALOGE("%s: Camera %d: Unable to delete old output stream "
2853                        "for recording: %s (%d)", __FUNCTION__, mCameraId,
2854                        strerror(-res), res);
2855                return res;
2856            }
2857            mRecordingStreamId = NO_STREAM;
2858        }
2859    }
2860
2861    if (mRecordingStreamId == NO_STREAM) {
2862        res = mDevice->createStream(mRecordingWindow,
2863                params.videoWidth, params.videoHeight,
2864                CAMERA2_HAL_PIXEL_FORMAT_OPAQUE, 0, &mRecordingStreamId);
2865        if (res != OK) {
2866            ALOGE("%s: Camera %d: Can't create output stream for recording: "
2867                    "%s (%d)", __FUNCTION__, mCameraId, strerror(-res), res);
2868            return res;
2869        }
2870    }
2871
2872    return OK;
2873}
2874
2875status_t Camera2Client::updateRequestCommon(camera_metadata_t *request,
2876        const Parameters &params) {
2877    ATRACE_CALL();
2878    status_t res;
2879    res = updateEntry(request,
2880            ANDROID_CONTROL_AE_TARGET_FPS_RANGE, params.previewFpsRange, 2);
2881    if (res != OK) return res;
2882
2883    uint8_t wbMode = params.autoWhiteBalanceLock ?
2884            ANDROID_CONTROL_AWB_LOCKED : params.wbMode;
2885    res = updateEntry(request,
2886            ANDROID_CONTROL_AWB_MODE, &wbMode, 1);
2887    if (res != OK) return res;
2888    res = updateEntry(request,
2889            ANDROID_CONTROL_EFFECT_MODE, &params.effectMode, 1);
2890    if (res != OK) return res;
2891    res = updateEntry(request,
2892            ANDROID_CONTROL_AE_ANTIBANDING_MODE,
2893            &params.antibandingMode, 1);
2894    if (res != OK) return res;
2895
2896    uint8_t controlMode =
2897            (params.sceneMode == ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED) ?
2898            ANDROID_CONTROL_AUTO : ANDROID_CONTROL_USE_SCENE_MODE;
2899    res = updateEntry(request,
2900            ANDROID_CONTROL_MODE, &controlMode, 1);
2901    if (res != OK) return res;
2902    if (controlMode == ANDROID_CONTROL_USE_SCENE_MODE) {
2903        res = updateEntry(request,
2904                ANDROID_CONTROL_SCENE_MODE,
2905                &params.sceneMode, 1);
2906        if (res != OK) return res;
2907    }
2908
2909    uint8_t flashMode = ANDROID_FLASH_OFF;
2910    uint8_t aeMode;
2911    switch (params.flashMode) {
2912        case Parameters::FLASH_MODE_OFF:
2913            aeMode = ANDROID_CONTROL_AE_ON; break;
2914        case Parameters::FLASH_MODE_AUTO:
2915            aeMode = ANDROID_CONTROL_AE_ON_AUTO_FLASH; break;
2916        case Parameters::FLASH_MODE_ON:
2917            aeMode = ANDROID_CONTROL_AE_ON_ALWAYS_FLASH; break;
2918        case Parameters::FLASH_MODE_TORCH:
2919            aeMode = ANDROID_CONTROL_AE_ON;
2920            flashMode = ANDROID_FLASH_TORCH;
2921            break;
2922        case Parameters::FLASH_MODE_RED_EYE:
2923            aeMode = ANDROID_CONTROL_AE_ON_AUTO_FLASH_REDEYE; break;
2924        default:
2925            ALOGE("%s: Camera %d: Unknown flash mode %d", __FUNCTION__,
2926                    mCameraId, params.flashMode);
2927            return BAD_VALUE;
2928    }
2929    if (params.autoExposureLock) aeMode = ANDROID_CONTROL_AE_LOCKED;
2930
2931    res = updateEntry(request,
2932            ANDROID_FLASH_MODE, &flashMode, 1);
2933    if (res != OK) return res;
2934    res = updateEntry(request,
2935            ANDROID_CONTROL_AE_MODE, &aeMode, 1);
2936    if (res != OK) return res;
2937
2938    float focusDistance = 0; // infinity focus in diopters
2939    uint8_t focusMode;
2940    switch (params.focusMode) {
2941        case Parameters::FOCUS_MODE_AUTO:
2942        case Parameters::FOCUS_MODE_MACRO:
2943        case Parameters::FOCUS_MODE_CONTINUOUS_VIDEO:
2944        case Parameters::FOCUS_MODE_CONTINUOUS_PICTURE:
2945        case Parameters::FOCUS_MODE_EDOF:
2946            focusMode = params.focusMode;
2947            break;
2948        case Parameters::FOCUS_MODE_INFINITY:
2949        case Parameters::FOCUS_MODE_FIXED:
2950            focusMode = ANDROID_CONTROL_AF_OFF;
2951            break;
2952        default:
2953            ALOGE("%s: Camera %d: Unknown focus mode %d", __FUNCTION__,
2954                    mCameraId, params.focusMode);
2955            return BAD_VALUE;
2956    }
2957    res = updateEntry(request,
2958            ANDROID_LENS_FOCUS_DISTANCE, &focusDistance, 1);
2959    if (res != OK) return res;
2960    res = updateEntry(request,
2961            ANDROID_CONTROL_AF_MODE, &focusMode, 1);
2962    if (res != OK) return res;
2963
2964    size_t focusingAreasSize = params.focusingAreas.size() * 5;
2965    int32_t *focusingAreas = new int32_t[focusingAreasSize];
2966    for (size_t i = 0; i < focusingAreasSize; i += 5) {
2967        focusingAreas[i + 0] = params.focusingAreas[i].left;
2968        focusingAreas[i + 1] = params.focusingAreas[i].top;
2969        focusingAreas[i + 2] = params.focusingAreas[i].right;
2970        focusingAreas[i + 3] = params.focusingAreas[i].bottom;
2971        focusingAreas[i + 4] = params.focusingAreas[i].weight;
2972    }
2973    res = updateEntry(request,
2974            ANDROID_CONTROL_AF_REGIONS, focusingAreas,focusingAreasSize);
2975    if (res != OK) return res;
2976    delete[] focusingAreas;
2977
2978    res = updateEntry(request,
2979            ANDROID_CONTROL_AE_EXP_COMPENSATION,
2980            &params.exposureCompensation, 1);
2981    if (res != OK) return res;
2982
2983    size_t meteringAreasSize = params.meteringAreas.size() * 5;
2984    int32_t *meteringAreas = new int32_t[meteringAreasSize];
2985    for (size_t i = 0; i < meteringAreasSize; i += 5) {
2986        meteringAreas[i + 0] = params.meteringAreas[i].left;
2987        meteringAreas[i + 1] = params.meteringAreas[i].top;
2988        meteringAreas[i + 2] = params.meteringAreas[i].right;
2989        meteringAreas[i + 3] = params.meteringAreas[i].bottom;
2990        meteringAreas[i + 4] = params.meteringAreas[i].weight;
2991    }
2992    res = updateEntry(request,
2993            ANDROID_CONTROL_AE_REGIONS, meteringAreas, meteringAreasSize);
2994    if (res != OK) return res;
2995
2996    res = updateEntry(request,
2997            ANDROID_CONTROL_AWB_REGIONS, meteringAreas, meteringAreasSize);
2998    if (res != OK) return res;
2999    delete[] meteringAreas;
3000
3001    // Need to convert zoom index into a crop rectangle. The rectangle is
3002    // chosen to maximize its area on the sensor
3003
3004    camera_metadata_entry_t maxDigitalZoom =
3005            staticInfo(ANDROID_SCALER_AVAILABLE_MAX_ZOOM);
3006    float zoomIncrement = (maxDigitalZoom.data.f[0] - 1) /
3007            (NUM_ZOOM_STEPS-1);
3008    float zoomRatio = 1 + zoomIncrement * params.zoom;
3009
3010    camera_metadata_entry_t activePixelArraySize =
3011            staticInfo(ANDROID_SENSOR_ACTIVE_ARRAY_SIZE, 2, 2);
3012    int32_t arrayWidth = activePixelArraySize.data.i32[0];
3013    int32_t arrayHeight = activePixelArraySize.data.i32[1];
3014    float zoomLeft, zoomTop, zoomWidth, zoomHeight;
3015    if (params.previewWidth >= params.previewHeight) {
3016        zoomWidth =  arrayWidth / zoomRatio;
3017        zoomHeight = zoomWidth *
3018                params.previewHeight / params.previewWidth;
3019    } else {
3020        zoomHeight = arrayHeight / zoomRatio;
3021        zoomWidth = zoomHeight *
3022                params.previewWidth / params.previewHeight;
3023    }
3024    zoomLeft = (arrayWidth - zoomWidth) / 2;
3025    zoomTop = (arrayHeight - zoomHeight) / 2;
3026
3027    int32_t cropRegion[3] = { zoomLeft, zoomTop, zoomWidth };
3028    res = updateEntry(request,
3029            ANDROID_SCALER_CROP_REGION, cropRegion, 3);
3030    if (res != OK) return res;
3031
3032    // TODO: Decide how to map recordingHint, or whether just to ignore it
3033
3034    uint8_t vstabMode = params.videoStabilization ?
3035            ANDROID_CONTROL_VIDEO_STABILIZATION_ON :
3036            ANDROID_CONTROL_VIDEO_STABILIZATION_OFF;
3037    res = updateEntry(request,
3038            ANDROID_CONTROL_VIDEO_STABILIZATION_MODE,
3039            &vstabMode, 1);
3040    if (res != OK) return res;
3041
3042    return OK;
3043}
3044
3045status_t Camera2Client::updateEntry(camera_metadata_t *buffer,
3046        uint32_t tag, const void *data, size_t data_count) {
3047    camera_metadata_entry_t entry;
3048    status_t res;
3049    res = find_camera_metadata_entry(buffer, tag, &entry);
3050    if (res == NAME_NOT_FOUND) {
3051        res = add_camera_metadata_entry(buffer,
3052                tag, data, data_count);
3053    } else if (res == OK) {
3054        res = update_camera_metadata_entry(buffer,
3055                entry.index, data, data_count, NULL);
3056    }
3057
3058    if (res != OK) {
3059        ALOGE("%s: Unable to update metadata entry %s.%s (%x): %s (%d)",
3060                __FUNCTION__, get_camera_metadata_section_name(tag),
3061                get_camera_metadata_tag_name(tag), tag, strerror(-res), res);
3062    }
3063    return res;
3064}
3065
3066status_t Camera2Client::deleteEntry(camera_metadata_t *buffer, uint32_t tag) {
3067    camera_metadata_entry_t entry;
3068    status_t res;
3069    res = find_camera_metadata_entry(buffer, tag, &entry);
3070    if (res == NAME_NOT_FOUND) {
3071        return OK;
3072    } else if (res != OK) {
3073        ALOGE("%s: Error looking for entry %s.%s (%x): %s %d",
3074                __FUNCTION__,
3075                get_camera_metadata_section_name(tag),
3076                get_camera_metadata_tag_name(tag), tag, strerror(-res), res);
3077        return res;
3078    }
3079    res = delete_camera_metadata_entry(buffer, entry.index);
3080    if (res != OK) {
3081        ALOGE("%s: Error deleting entry %s.%s (%x): %s %d",
3082                __FUNCTION__,
3083                get_camera_metadata_section_name(tag),
3084                get_camera_metadata_tag_name(tag), tag, strerror(-res), res);
3085    }
3086    return res;
3087}
3088
3089int Camera2Client::formatStringToEnum(const char *format) {
3090    return
3091        !strcmp(format, CameraParameters::PIXEL_FORMAT_YUV422SP) ?
3092            HAL_PIXEL_FORMAT_YCbCr_422_SP : // NV16
3093        !strcmp(format, CameraParameters::PIXEL_FORMAT_YUV420SP) ?
3094            HAL_PIXEL_FORMAT_YCrCb_420_SP : // NV21
3095        !strcmp(format, CameraParameters::PIXEL_FORMAT_YUV422I) ?
3096            HAL_PIXEL_FORMAT_YCbCr_422_I :  // YUY2
3097        !strcmp(format, CameraParameters::PIXEL_FORMAT_YUV420P) ?
3098            HAL_PIXEL_FORMAT_YV12 :         // YV12
3099        !strcmp(format, CameraParameters::PIXEL_FORMAT_RGB565) ?
3100            HAL_PIXEL_FORMAT_RGB_565 :      // RGB565
3101        !strcmp(format, CameraParameters::PIXEL_FORMAT_RGBA8888) ?
3102            HAL_PIXEL_FORMAT_RGBA_8888 :    // RGB8888
3103        !strcmp(format, CameraParameters::PIXEL_FORMAT_BAYER_RGGB) ?
3104            HAL_PIXEL_FORMAT_RAW_SENSOR :   // Raw sensor data
3105        -1;
3106}
3107
3108const char* Camera2Client::formatEnumToString(int format) {
3109    const char *fmt;
3110    switch(format) {
3111        case HAL_PIXEL_FORMAT_YCbCr_422_SP: // NV16
3112            fmt = CameraParameters::PIXEL_FORMAT_YUV422SP;
3113            break;
3114        case HAL_PIXEL_FORMAT_YCrCb_420_SP: // NV21
3115            fmt = CameraParameters::PIXEL_FORMAT_YUV420SP;
3116            break;
3117        case HAL_PIXEL_FORMAT_YCbCr_422_I: // YUY2
3118            fmt = CameraParameters::PIXEL_FORMAT_YUV422I;
3119            break;
3120        case HAL_PIXEL_FORMAT_YV12:        // YV12
3121            fmt = CameraParameters::PIXEL_FORMAT_YUV420P;
3122            break;
3123        case HAL_PIXEL_FORMAT_RGB_565:     // RGB565
3124            fmt = CameraParameters::PIXEL_FORMAT_RGB565;
3125            break;
3126        case HAL_PIXEL_FORMAT_RGBA_8888:   // RGBA8888
3127            fmt = CameraParameters::PIXEL_FORMAT_RGBA8888;
3128            break;
3129        case HAL_PIXEL_FORMAT_RAW_SENSOR:
3130            ALOGW("Raw sensor preview format requested.");
3131            fmt = CameraParameters::PIXEL_FORMAT_BAYER_RGGB;
3132            break;
3133        default:
3134            ALOGE("%s: Unknown preview format: %x",
3135                    __FUNCTION__,  format);
3136            fmt = NULL;
3137            break;
3138    }
3139    return fmt;
3140}
3141
3142int Camera2Client::wbModeStringToEnum(const char *wbMode) {
3143    return
3144        !strcmp(wbMode, CameraParameters::WHITE_BALANCE_AUTO) ?
3145            ANDROID_CONTROL_AWB_AUTO :
3146        !strcmp(wbMode, CameraParameters::WHITE_BALANCE_INCANDESCENT) ?
3147            ANDROID_CONTROL_AWB_INCANDESCENT :
3148        !strcmp(wbMode, CameraParameters::WHITE_BALANCE_FLUORESCENT) ?
3149            ANDROID_CONTROL_AWB_FLUORESCENT :
3150        !strcmp(wbMode, CameraParameters::WHITE_BALANCE_WARM_FLUORESCENT) ?
3151            ANDROID_CONTROL_AWB_WARM_FLUORESCENT :
3152        !strcmp(wbMode, CameraParameters::WHITE_BALANCE_DAYLIGHT) ?
3153            ANDROID_CONTROL_AWB_DAYLIGHT :
3154        !strcmp(wbMode, CameraParameters::WHITE_BALANCE_CLOUDY_DAYLIGHT) ?
3155            ANDROID_CONTROL_AWB_CLOUDY_DAYLIGHT :
3156        !strcmp(wbMode, CameraParameters::WHITE_BALANCE_TWILIGHT) ?
3157            ANDROID_CONTROL_AWB_TWILIGHT :
3158        !strcmp(wbMode, CameraParameters::WHITE_BALANCE_SHADE) ?
3159            ANDROID_CONTROL_AWB_SHADE :
3160        -1;
3161}
3162
3163int Camera2Client::effectModeStringToEnum(const char *effectMode) {
3164    return
3165        !strcmp(effectMode, CameraParameters::EFFECT_NONE) ?
3166            ANDROID_CONTROL_EFFECT_OFF :
3167        !strcmp(effectMode, CameraParameters::EFFECT_MONO) ?
3168            ANDROID_CONTROL_EFFECT_MONO :
3169        !strcmp(effectMode, CameraParameters::EFFECT_NEGATIVE) ?
3170            ANDROID_CONTROL_EFFECT_NEGATIVE :
3171        !strcmp(effectMode, CameraParameters::EFFECT_SOLARIZE) ?
3172            ANDROID_CONTROL_EFFECT_SOLARIZE :
3173        !strcmp(effectMode, CameraParameters::EFFECT_SEPIA) ?
3174            ANDROID_CONTROL_EFFECT_SEPIA :
3175        !strcmp(effectMode, CameraParameters::EFFECT_POSTERIZE) ?
3176            ANDROID_CONTROL_EFFECT_POSTERIZE :
3177        !strcmp(effectMode, CameraParameters::EFFECT_WHITEBOARD) ?
3178            ANDROID_CONTROL_EFFECT_WHITEBOARD :
3179        !strcmp(effectMode, CameraParameters::EFFECT_BLACKBOARD) ?
3180            ANDROID_CONTROL_EFFECT_BLACKBOARD :
3181        !strcmp(effectMode, CameraParameters::EFFECT_AQUA) ?
3182            ANDROID_CONTROL_EFFECT_AQUA :
3183        -1;
3184}
3185
3186int Camera2Client::abModeStringToEnum(const char *abMode) {
3187    return
3188        !strcmp(abMode, CameraParameters::ANTIBANDING_AUTO) ?
3189            ANDROID_CONTROL_AE_ANTIBANDING_AUTO :
3190        !strcmp(abMode, CameraParameters::ANTIBANDING_OFF) ?
3191            ANDROID_CONTROL_AE_ANTIBANDING_OFF :
3192        !strcmp(abMode, CameraParameters::ANTIBANDING_50HZ) ?
3193            ANDROID_CONTROL_AE_ANTIBANDING_50HZ :
3194        !strcmp(abMode, CameraParameters::ANTIBANDING_60HZ) ?
3195            ANDROID_CONTROL_AE_ANTIBANDING_60HZ :
3196        -1;
3197}
3198
3199int Camera2Client::sceneModeStringToEnum(const char *sceneMode) {
3200    return
3201        !strcmp(sceneMode, CameraParameters::SCENE_MODE_AUTO) ?
3202            ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED :
3203        !strcmp(sceneMode, CameraParameters::SCENE_MODE_ACTION) ?
3204            ANDROID_CONTROL_SCENE_MODE_ACTION :
3205        !strcmp(sceneMode, CameraParameters::SCENE_MODE_PORTRAIT) ?
3206            ANDROID_CONTROL_SCENE_MODE_PORTRAIT :
3207        !strcmp(sceneMode, CameraParameters::SCENE_MODE_LANDSCAPE) ?
3208            ANDROID_CONTROL_SCENE_MODE_LANDSCAPE :
3209        !strcmp(sceneMode, CameraParameters::SCENE_MODE_NIGHT) ?
3210            ANDROID_CONTROL_SCENE_MODE_NIGHT :
3211        !strcmp(sceneMode, CameraParameters::SCENE_MODE_NIGHT_PORTRAIT) ?
3212            ANDROID_CONTROL_SCENE_MODE_NIGHT_PORTRAIT :
3213        !strcmp(sceneMode, CameraParameters::SCENE_MODE_THEATRE) ?
3214            ANDROID_CONTROL_SCENE_MODE_THEATRE :
3215        !strcmp(sceneMode, CameraParameters::SCENE_MODE_BEACH) ?
3216            ANDROID_CONTROL_SCENE_MODE_BEACH :
3217        !strcmp(sceneMode, CameraParameters::SCENE_MODE_SNOW) ?
3218            ANDROID_CONTROL_SCENE_MODE_SNOW :
3219        !strcmp(sceneMode, CameraParameters::SCENE_MODE_SUNSET) ?
3220            ANDROID_CONTROL_SCENE_MODE_SUNSET :
3221        !strcmp(sceneMode, CameraParameters::SCENE_MODE_STEADYPHOTO) ?
3222            ANDROID_CONTROL_SCENE_MODE_STEADYPHOTO :
3223        !strcmp(sceneMode, CameraParameters::SCENE_MODE_FIREWORKS) ?
3224            ANDROID_CONTROL_SCENE_MODE_FIREWORKS :
3225        !strcmp(sceneMode, CameraParameters::SCENE_MODE_SPORTS) ?
3226            ANDROID_CONTROL_SCENE_MODE_SPORTS :
3227        !strcmp(sceneMode, CameraParameters::SCENE_MODE_PARTY) ?
3228            ANDROID_CONTROL_SCENE_MODE_PARTY :
3229        !strcmp(sceneMode, CameraParameters::SCENE_MODE_CANDLELIGHT) ?
3230            ANDROID_CONTROL_SCENE_MODE_CANDLELIGHT :
3231        !strcmp(sceneMode, CameraParameters::SCENE_MODE_BARCODE) ?
3232            ANDROID_CONTROL_SCENE_MODE_BARCODE:
3233        -1;
3234}
3235
3236Camera2Client::Parameters::flashMode_t Camera2Client::flashModeStringToEnum(
3237        const char *flashMode) {
3238    return
3239        !strcmp(flashMode, CameraParameters::FLASH_MODE_OFF) ?
3240            Parameters::FLASH_MODE_OFF :
3241        !strcmp(flashMode, CameraParameters::FLASH_MODE_AUTO) ?
3242            Parameters::FLASH_MODE_AUTO :
3243        !strcmp(flashMode, CameraParameters::FLASH_MODE_ON) ?
3244            Parameters::FLASH_MODE_ON :
3245        !strcmp(flashMode, CameraParameters::FLASH_MODE_RED_EYE) ?
3246            Parameters::FLASH_MODE_RED_EYE :
3247        !strcmp(flashMode, CameraParameters::FLASH_MODE_TORCH) ?
3248            Parameters::FLASH_MODE_TORCH :
3249        Parameters::FLASH_MODE_INVALID;
3250}
3251
3252Camera2Client::Parameters::focusMode_t Camera2Client::focusModeStringToEnum(
3253        const char *focusMode) {
3254    return
3255        !strcmp(focusMode, CameraParameters::FOCUS_MODE_AUTO) ?
3256            Parameters::FOCUS_MODE_AUTO :
3257        !strcmp(focusMode, CameraParameters::FOCUS_MODE_INFINITY) ?
3258            Parameters::FOCUS_MODE_INFINITY :
3259        !strcmp(focusMode, CameraParameters::FOCUS_MODE_MACRO) ?
3260            Parameters::FOCUS_MODE_MACRO :
3261        !strcmp(focusMode, CameraParameters::FOCUS_MODE_FIXED) ?
3262            Parameters::FOCUS_MODE_FIXED :
3263        !strcmp(focusMode, CameraParameters::FOCUS_MODE_EDOF) ?
3264            Parameters::FOCUS_MODE_EDOF :
3265        !strcmp(focusMode, CameraParameters::FOCUS_MODE_CONTINUOUS_VIDEO) ?
3266            Parameters::FOCUS_MODE_CONTINUOUS_VIDEO :
3267        !strcmp(focusMode, CameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE) ?
3268            Parameters::FOCUS_MODE_CONTINUOUS_PICTURE :
3269        Parameters::FOCUS_MODE_INVALID;
3270}
3271
3272status_t Camera2Client::parseAreas(const char *areasCStr,
3273        Vector<Parameters::Area> *areas) {
3274    static const size_t NUM_FIELDS = 5;
3275    areas->clear();
3276    if (areasCStr == NULL) {
3277        // If no key exists, use default (0,0,0,0,0)
3278        areas->push();
3279        return OK;
3280    }
3281    String8 areasStr(areasCStr);
3282    ssize_t areaStart = areasStr.find("(", 0) + 1;
3283    while (areaStart != 0) {
3284        const char* area = areasStr.string() + areaStart;
3285        char *numEnd;
3286        int vals[NUM_FIELDS];
3287        for (size_t i = 0; i < NUM_FIELDS; i++) {
3288            errno = 0;
3289            vals[i] = strtol(area, &numEnd, 10);
3290            if (errno || numEnd == area) return BAD_VALUE;
3291            area = numEnd + 1;
3292        }
3293        areas->push(Parameters::Area(
3294            vals[0], vals[1], vals[2], vals[3], vals[4]) );
3295        areaStart = areasStr.find("(", areaStart) + 1;
3296    }
3297    return OK;
3298}
3299
3300status_t Camera2Client::validateAreas(const Vector<Parameters::Area> &areas,
3301                                      size_t maxRegions) {
3302    // Definition of valid area can be found in
3303    // include/camera/CameraParameters.h
3304    if (areas.size() == 0) return BAD_VALUE;
3305    if (areas.size() == 1) {
3306        if (areas[0].left == 0 &&
3307                areas[0].top == 0 &&
3308                areas[0].right == 0 &&
3309                areas[0].bottom == 0 &&
3310                areas[0].weight == 0) {
3311            // Single (0,0,0,0,0) entry is always valid (== driver decides)
3312            return OK;
3313        }
3314    }
3315    if (areas.size() > maxRegions) {
3316        ALOGE("%s: Too many areas requested: %d",
3317                __FUNCTION__, areas.size());
3318        return BAD_VALUE;
3319    }
3320
3321    for (Vector<Parameters::Area>::const_iterator a = areas.begin();
3322         a != areas.end(); a++) {
3323        if (a->weight < 1 || a->weight > 1000) return BAD_VALUE;
3324        if (a->left < -1000 || a->left > 1000) return BAD_VALUE;
3325        if (a->top < -1000 || a->top > 1000) return BAD_VALUE;
3326        if (a->right < -1000 || a->right > 1000) return BAD_VALUE;
3327        if (a->bottom < -1000 || a->bottom > 1000) return BAD_VALUE;
3328        if (a->left >= a->right) return BAD_VALUE;
3329        if (a->top >= a->bottom) return BAD_VALUE;
3330    }
3331    return OK;
3332}
3333
3334bool Camera2Client::boolFromString(const char *boolStr) {
3335    return !boolStr ? false :
3336        !strcmp(boolStr, CameraParameters::TRUE) ? true :
3337        false;
3338}
3339
3340int Camera2Client::degToTransform(int degrees, bool mirror) {
3341    if (!mirror) {
3342        if (degrees == 0) return 0;
3343        else if (degrees == 90) return HAL_TRANSFORM_ROT_90;
3344        else if (degrees == 180) return HAL_TRANSFORM_ROT_180;
3345        else if (degrees == 270) return HAL_TRANSFORM_ROT_270;
3346    } else {  // Do mirror (horizontal flip)
3347        if (degrees == 0) {           // FLIP_H and ROT_0
3348            return HAL_TRANSFORM_FLIP_H;
3349        } else if (degrees == 90) {   // FLIP_H and ROT_90
3350            return HAL_TRANSFORM_FLIP_H | HAL_TRANSFORM_ROT_90;
3351        } else if (degrees == 180) {  // FLIP_H and ROT_180
3352            return HAL_TRANSFORM_FLIP_V;
3353        } else if (degrees == 270) {  // FLIP_H and ROT_270
3354            return HAL_TRANSFORM_FLIP_V | HAL_TRANSFORM_ROT_90;
3355        }
3356    }
3357    ALOGE("%s: Bad input: %d", __FUNCTION__, degrees);
3358    return -1;
3359}
3360
3361} // namespace android
3362