Examples with Camera android.hardware.Camera used on opensource projects

Example 6 with Camera

use of android.hardware.Camera in project android_frameworks_base by ResurrectionRemix.

the class MediaRecorderTest method validateGetSurface.

private boolean validateGetSurface(boolean useSurface) {
    Log.v(TAG, "validateGetSurface, useSurface=" + useSurface);
    MediaRecorder recorder = new MediaRecorder();
    Surface surface;
    boolean success = true;
    try {
        /* initialization */
        if (!useSurface) {
            mCamera = Camera.open(CAMERA_ID);
            Camera.Parameters parameters = mCamera.getParameters();
            parameters.setPreviewSize(352, 288);
            parameters.set("orientation", "portrait");
            mCamera.setParameters(parameters);
            mCamera.unlock();
            recorder.setCamera(mCamera);
            mSurfaceHolder = MediaFrameworkTest.mSurfaceView.getHolder();
            recorder.setPreviewDisplay(mSurfaceHolder.getSurface());
        }
        recorder.setAudioSource(MediaRecorder.AudioSource.MIC);
        int videoSource = useSurface ? MediaRecorder.VideoSource.SURFACE : MediaRecorder.VideoSource.CAMERA;
        recorder.setVideoSource(videoSource);
        recorder.setOutputFormat(MediaRecorder.OutputFormat.THREE_GPP);
        recorder.setOutputFile(MediaNames.RECORDED_SURFACE_3GP);
        recorder.setVideoFrameRate(30);
        recorder.setVideoSize(352, 288);
        recorder.setVideoEncoder(MediaRecorder.VideoEncoder.H264);
        recorder.setAudioEncoder(MediaRecorder.AudioEncoder.AMR_NB);
        /* Test: getSurface() before prepare()
             * should throw IllegalStateException
             */
        try {
            surface = recorder.getSurface();
            throw new Exception("getSurface failed to throw IllegalStateException");
        } catch (IllegalStateException e) {
        // OK
        }
        recorder.prepare();
        /* Test: getSurface() after prepare()
             * should succeed for surface source
             * should fail for camera source
             */
        try {
            surface = recorder.getSurface();
            if (!useSurface) {
                throw new Exception("getSurface failed to throw IllegalStateException");
            }
        } catch (IllegalStateException e) {
            if (useSurface) {
                throw new Exception("getSurface failed to throw IllegalStateException");
            }
        }
        recorder.start();
        /* Test: getSurface() after start()
             * should succeed for surface source
             * should fail for camera source
             */
        try {
            surface = recorder.getSurface();
            if (!useSurface) {
                throw new Exception("getSurface failed to throw IllegalStateException");
            }
        } catch (IllegalStateException e) {
            if (useSurface) {
                throw new Exception("getSurface failed to throw IllegalStateException");
            }
        }
        try {
            recorder.stop();
        } catch (Exception e) {
        // stop() could fail if the recording is empty, as we didn't render anything.
        // ignore any failure in stop, we just want it stopped.
        }
        /* Test: getSurface() after stop()
             * should throw IllegalStateException
             */
        try {
            surface = recorder.getSurface();
            throw new Exception("getSurface failed to throw IllegalStateException");
        } catch (IllegalStateException e) {
        // OK
        }
    } catch (Exception e) {
        // fail
        success = false;
    }
    try {
        if (mCamera != null) {
            mCamera.lock();
            mCamera.release();
            mCamera = null;
        }
        recorder.release();
    } catch (Exception e) {
        success = false;
    }
    return success;
}

Example 7 with Camera

use of android.hardware.Camera in project android_frameworks_base by ResurrectionRemix.

the class ParameterUtils method convertSizeListToArray.

/**
     * Convert a camera API1 list of sizes into an array of sizes
     */
public static Size[] convertSizeListToArray(List<Camera.Size> sizeList) {
    checkNotNull(sizeList, "sizeList must not be null");
    Size[] array = new Size[sizeList.size()];
    int ctr = 0;
    for (Camera.Size s : sizeList) {
        array[ctr++] = new Size(s.width, s.height);
    }
    return array;
}

Example 8 with Camera

use of android.hardware.Camera in project android_frameworks_base by ResurrectionRemix.

the class ParameterUtils method convertSizeList.

/**
     * Convert a camera API1 list of sizes into a util list of sizes
     */
public static List<Size> convertSizeList(List<Camera.Size> sizeList) {
    checkNotNull(sizeList, "sizeList must not be null");
    List<Size> sizes = new ArrayList<>(sizeList.size());
    for (Camera.Size s : sizeList) {
        sizes.add(new Size(s.width, s.height));
    }
    return sizes;
}

Example 9 with Camera

use of android.hardware.Camera in project android_frameworks_base by ResurrectionRemix.

the class LegacyMetadataMapper method createCharacteristics.

/**
     * Create characteristics for a legacy device by mapping the {@code parameters}
     * and {@code info}
     *
     * @param parameters A string parseable by {@link Camera.Parameters#unflatten}
     * @param info Camera info with camera facing direction and angle of orientation
     * @return static camera characteristics for a camera device
     *
     * @throws NullPointerException if any of the args were {@code null}
     */
public static CameraCharacteristics createCharacteristics(String parameters, android.hardware.CameraInfo info) {
    checkNotNull(parameters, "parameters must not be null");
    checkNotNull(info, "info must not be null");
    checkNotNull(info.info, "info.info must not be null");
    CameraMetadataNative m = new CameraMetadataNative();
    mapCharacteristicsFromInfo(m, info.info);
    Camera.Parameters params = Camera.getEmptyParameters();
    params.unflatten(parameters);
    mapCharacteristicsFromParameters(m, params);
    if (DEBUG) {
        Log.v(TAG, "createCharacteristics metadata:");
        Log.v(TAG, "--------------------------------------------------- (start)");
        m.dumpToLog();
        Log.v(TAG, "--------------------------------------------------- (end)");
    }
    return new CameraCharacteristics(m);
}

Example 10 with Camera

use of android.hardware.Camera in project android_frameworks_base by ResurrectionRemix.

the class LegacyFaceDetectMapper method mapResultFaces.

/**
     * Update the {@code result} camera metadata map with the new value for the
     * {@code statistics.faces} and {@code statistics.faceDetectMode}.
     *
     * <p>Face detect callbacks are processed in the background, and each call to
     * {@link #mapResultFaces} will have the latest faces as reflected by the camera1 callbacks.</p>
     *
     * <p>If the scene mode was set to {@code FACE_PRIORITY} but face detection is disabled,
     * the camera will still run face detection in the background, but no faces will be reported
     * in the capture result.</p>
     *
     * @param result a non-{@code null} result
     * @param legacyRequest a non-{@code null} request (read-only)
     */
public void mapResultFaces(CameraMetadataNative result, LegacyRequest legacyRequest) {
    checkNotNull(result, "result must not be null");
    checkNotNull(legacyRequest, "legacyRequest must not be null");
    Camera.Face[] faces, previousFaces;
    int fdMode;
    boolean fdScenePriority;
    synchronized (mLock) {
        fdMode = mFaceDetectReporting ? STATISTICS_FACE_DETECT_MODE_SIMPLE : STATISTICS_FACE_DETECT_MODE_OFF;
        if (mFaceDetectReporting) {
            faces = mFaces;
        } else {
            faces = null;
        }
        fdScenePriority = mFaceDetectScenePriority;
        previousFaces = mFacesPrev;
        mFacesPrev = faces;
    }
    CameraCharacteristics characteristics = legacyRequest.characteristics;
    CaptureRequest request = legacyRequest.captureRequest;
    Size previewSize = legacyRequest.previewSize;
    Camera.Parameters params = legacyRequest.parameters;
    Rect activeArray = characteristics.get(CameraCharacteristics.SENSOR_INFO_ACTIVE_ARRAY_SIZE);
    ZoomData zoomData = ParameterUtils.convertScalerCropRegion(activeArray, request.get(CaptureRequest.SCALER_CROP_REGION), previewSize, params);
    List<Face> convertedFaces = new ArrayList<>();
    if (faces != null) {
        for (Camera.Face face : faces) {
            if (face != null) {
                convertedFaces.add(ParameterUtils.convertFaceFromLegacy(face, activeArray, zoomData));
            } else {
                Log.w(TAG, "mapResultFaces - read NULL face from camera1 device");
            }
        }
    }
    if (DEBUG && previousFaces != faces) {
        // Log only in verbose and IF the faces changed
        Log.v(TAG, "mapResultFaces - changed to " + ListUtils.listToString(convertedFaces));
    }
    result.set(CaptureResult.STATISTICS_FACES, convertedFaces.toArray(new Face[0]));
    result.set(CaptureResult.STATISTICS_FACE_DETECT_MODE, fdMode);
    // Override scene mode with FACE_PRIORITY if the request was using FACE_PRIORITY
    if (fdScenePriority) {
        result.set(CaptureResult.CONTROL_SCENE_MODE, CONTROL_SCENE_MODE_FACE_PRIORITY);
    }
}