/* * Copyright (C) 2014 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.android.camera.one.v2; import android.annotation.TargetApi; import android.hardware.camera2.CameraDevice; import android.hardware.camera2.CaptureRequest; import android.os.Build.VERSION_CODES; import android.util.Range; import android.view.Surface; import com.android.camera.FatalErrorHandler; import com.android.camera.async.HandlerFactory; import com.android.camera.async.Lifetime; import com.android.camera.async.MainThread; import com.android.camera.async.Observable; import com.android.camera.async.Observables; import com.android.camera.async.Updatable; import com.android.camera.burst.BurstFacade; import com.android.camera.burst.BurstTaker; import com.android.camera.burst.BurstTakerImpl; import com.android.camera.debug.Log.Tag; import com.android.camera.debug.Logger; import com.android.camera.debug.Loggers; import com.android.camera.one.OneCamera; import com.android.camera.one.OneCameraCharacteristics; import com.android.camera.one.config.OneCameraFeatureConfig.CaptureSupportLevel; import com.android.camera.one.v2.camera2proxy.AndroidImageReaderProxy; import com.android.camera.one.v2.camera2proxy.CameraCaptureSessionProxy; import com.android.camera.one.v2.camera2proxy.CameraDeviceProxy; import com.android.camera.one.v2.camera2proxy.CameraDeviceRequestBuilderFactory; import com.android.camera.one.v2.camera2proxy.ImageReaderProxy; import com.android.camera.one.v2.camera2proxy.TotalCaptureResultProxy; import com.android.camera.one.v2.commands.CameraCommandExecutor; import com.android.camera.one.v2.commands.ZslPreviewCommandFactory; import com.android.camera.one.v2.common.BasicCameraFactory; import com.android.camera.one.v2.common.SimpleCaptureStream; import com.android.camera.one.v2.core.FrameServer; import com.android.camera.one.v2.core.FrameServerFactory; import com.android.camera.one.v2.core.RequestTemplate; import com.android.camera.one.v2.core.ResponseListener; import com.android.camera.one.v2.core.ResponseListeners; import com.android.camera.one.v2.errorhandling.FramerateJankDetector; import com.android.camera.one.v2.errorhandling.RepeatFailureHandlerComponent; import com.android.camera.one.v2.imagesaver.ImageSaver; import com.android.camera.one.v2.initialization.CameraStarter; import com.android.camera.one.v2.initialization.InitializedOneCameraFactory; import com.android.camera.one.v2.photo.ZslPictureTakerFactory; import com.android.camera.one.v2.sharedimagereader.ZslSharedImageReaderFactory; import com.android.camera.stats.UsageStatistics; import com.android.camera.util.AndroidContext; import com.android.camera.util.ApiHelper; import com.android.camera.util.GservicesHelper; import com.android.camera.util.Provider; import com.android.camera.util.Size; import com.google.common.base.Supplier; import java.util.ArrayList; import java.util.Arrays; import java.util.List; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; @TargetApi(VERSION_CODES.LOLLIPOP) public class ZslOneCameraFactory implements OneCameraFactory { private static Tag TAG = new Tag("ZslOneCamFactory"); private final Logger mLogger; private final int mImageFormat; private final int mMaxImageCount; private final int maxRingBufferSize; public ZslOneCameraFactory(int imageFormat, int maxImageCount) { mImageFormat = imageFormat; mMaxImageCount = maxImageCount; mLogger = Loggers.tagFactory().create(TAG); // Determines the maximum size of the ZSL ring-buffer. // Note that this is *different* from mMaxImageCount. // mMaxImageCount determines the size of the ImageReader used for large // (typically YUV) images to be saved. It is correlated with the total // number of in-progress captures which can simultaneously occur by // buffering captured images. // maxRingBufferSize determines the maximum size of the ring-buffer // (which uses a subset of the capacity of the ImageReader). This is // correlated to the maximum amount of look-back for zero-shutter-lag // photography. If this is greater than mMaxImageCount - 2, then it // places no additional constraints on ring-buffer size. That is, // the ring-buffer will expand to fill the entire capacity of the // ImageReader whenever possible. // A value of 1 here is adequate for single-frame ZSL capture, but // *must* be increased to support multi-frame burst capture with // zero-shutter-lag. maxRingBufferSize = 1; } /** * Slows down the requested camera frame for Nexus 5 back camera issue. This * hack is for the Back Camera for Nexus 5. Requesting on full YUV frames at * 30 fps causes the video preview to deliver frames out of order, mostly * likely due to the overloading of the ISP, and/or image bandwith. The * short-term solution is to back off the frame rate to unadvertised, valid * frame rate of 28 fps. The long-term solution is to advertise this [7,28] * frame rate range in the HAL and get buy-in from the manufacturer to * support and CTS this feature. Then framerate process can occur in more * integrated manner. The tracking bug for this issue is b/18950682. * * @param requestTemplate Request template that will be applied to the * current camera device */ private void applyNexus5BackCameraFrameRateWorkaround(RequestTemplate requestTemplate) { Range frameRateBackOff = new Range<>(7, 28); mLogger.v("Applying Nexus5 specific framerate backoff of " + frameRateBackOff); requestTemplate.setParam(CaptureRequest.CONTROL_AE_TARGET_FPS_RANGE, frameRateBackOff); } @Override public OneCamera createOneCamera(final CameraDeviceProxy device, final OneCameraCharacteristics characteristics, CaptureSupportLevel featureConfig, final MainThread mainThread, Size pictureSize, final ImageSaver.Builder imageSaverBuilder, final Observable flashSetting, final Observable exposureSetting, final Observable hdrSceneSetting, final BurstFacade burstFacade, final FatalErrorHandler fatalErrorHandler) { final Lifetime lifetime = new Lifetime(); final ImageReaderProxy imageReader = new CloseWhenDoneImageReader( new LoggingImageReader(AndroidImageReaderProxy.newInstance( pictureSize.getWidth(), pictureSize.getHeight(), mImageFormat, mMaxImageCount), Loggers.tagFactory())); lifetime.add(imageReader); lifetime.add(device); List outputSurfaces = new ArrayList<>(); outputSurfaces.add(imageReader.getSurface()); if (burstFacade.getInputSurface() != null) { outputSurfaces.add(burstFacade.getInputSurface()); } /** * Finishes constructing the camera when prerequisites, e.g. the preview * stream and capture session, are ready. */ CameraStarter cameraStarter = new CameraStarter() { @Override public CameraControls startCamera(Lifetime cameraLifetime, CameraCaptureSessionProxy cameraCaptureSession, Surface previewSurface, Observable zoomState, Updatable metadataCallback, Updatable readyStateCallback) { // Create the FrameServer from the CaptureSession. FrameServerFactory frameServerComponent = new FrameServerFactory(new Lifetime (cameraLifetime), cameraCaptureSession, new HandlerFactory()); FrameServer frameServer = frameServerComponent.provideFrameServer(); FrameServer ephemeralFrameServer = frameServerComponent .provideEphemeralFrameServer(); // Create the shared image reader. ZslSharedImageReaderFactory sharedImageReaderFactory = new ZslSharedImageReaderFactory(new Lifetime(cameraLifetime), imageReader, new HandlerFactory(), maxRingBufferSize); CameraCommandExecutor cameraCommandExecutor = new CameraCommandExecutor( Loggers.tagFactory(), new Provider() { @Override public ExecutorService get() { // Use a dynamically-expanding thread pool to // allow any number of commands to execute // simultaneously. return Executors.newCachedThreadPool(); } }); // Create the request builder used by all camera operations. // Streams, ResponseListeners, and Parameters added to // this will be applied to *all* requests sent to the camera. RequestTemplate rootTemplate = new RequestTemplate( new CameraDeviceRequestBuilderFactory(device)); rootTemplate.addResponseListener(sharedImageReaderFactory .provideGlobalResponseListener()); rootTemplate.addResponseListener(ResponseListeners .forFinalMetadata(metadataCallback)); // Create the request builder for the preview warmup in order to workaround // the face detection failure. This is a work around of the HAL face detection // failure in b/20724126. RequestTemplate previewWarmupTemplate = new RequestTemplate(rootTemplate); previewWarmupTemplate.addStream(new SimpleCaptureStream(previewSurface)); // Create the request builder for the ZSL stream RequestTemplate zslTemplate = new RequestTemplate(rootTemplate); zslTemplate.addStream(sharedImageReaderFactory.provideZSLStream()); // Create the request builder that will be used by most camera // operations. RequestTemplate zslAndPreviewTemplate = new RequestTemplate(zslTemplate); zslAndPreviewTemplate.addStream(new SimpleCaptureStream(previewSurface)); boolean isBackCamera = characteristics.getCameraDirection() == OneCamera.Facing.BACK; if (isBackCamera && ApiHelper.IS_NEXUS_5) { applyNexus5BackCameraFrameRateWorkaround(zslTemplate); } // Create basic functionality (zoom, AE, AF). BasicCameraFactory basicCameraFactory = new BasicCameraFactory( new Lifetime(cameraLifetime), characteristics, ephemeralFrameServer, zslAndPreviewTemplate, cameraCommandExecutor, new ZslPreviewCommandFactory(ephemeralFrameServer, previewWarmupTemplate, zslTemplate), flashSetting, exposureSetting, zoomState, hdrSceneSetting, CameraDevice.TEMPLATE_ZERO_SHUTTER_LAG); lifetime.add(cameraCommandExecutor); // Create the picture-taker. ZslPictureTakerFactory pictureTakerFactory = ZslPictureTakerFactory.create( Loggers.tagFactory(), mainThread, cameraCommandExecutor, imageSaverBuilder, frameServer, basicCameraFactory.provideMeteredZoomedRequestBuilder(), sharedImageReaderFactory.provideSharedImageReader(), sharedImageReaderFactory.provideZSLStream(), sharedImageReaderFactory.provideMetadataPool(), flashSetting, zslAndPreviewTemplate); BurstTaker burstTaker = new BurstTakerImpl(cameraCommandExecutor, frameServer, basicCameraFactory.provideMeteredZoomedRequestBuilder(), sharedImageReaderFactory.provideSharedImageReader(), burstFacade.getInputSurface(), basicCameraFactory.providePreviewUpdater(), // ImageReader#acquireLatestImage() requires two images // as the margin so // specify that as the maximum number of images that can // be used by burst. mMaxImageCount - 2); burstFacade.setBurstTaker(burstTaker); if (isBackCamera && ApiHelper.IS_NEXUS_5) { // Workaround for bug: 19061883 ResponseListener failureDetector = RepeatFailureHandlerComponent.create( Loggers.tagFactory(), fatalErrorHandler, cameraCaptureSession, cameraCommandExecutor, basicCameraFactory.providePreviewUpdater(), UsageStatistics.instance(), 10 /* consecutiveFailureThreshold */).provideResponseListener(); zslTemplate.addResponseListener(failureDetector); } if (GservicesHelper.isJankStatisticsEnabled(AndroidContext.instance().get() .getContentResolver())) { // Don't add jank detection unless the preview is running. zslAndPreviewTemplate.addResponseListener( new FramerateJankDetector(Loggers.tagFactory(), UsageStatistics.instance())); } final Observable availableImageCount = sharedImageReaderFactory .provideAvailableImageCount(); final Observable frameServerAvailability = frameServerComponent .provideReadyState(); Observable readyObservable = Observables.transform( Arrays.asList(availableImageCount, frameServerAvailability), new Supplier() { @Override public Boolean get() { boolean atLeastOneImageAvailable = availableImageCount.get() >= 1; boolean frameServerAvailable = frameServerAvailability.get(); return atLeastOneImageAvailable && frameServerAvailable; } }); lifetime.add(Observables.addThreadSafeCallback(readyObservable, readyStateCallback)); basicCameraFactory.providePreviewUpdater().run(); return new CameraControls( pictureTakerFactory.providePictureTaker(), basicCameraFactory.provideManualAutoFocus()); } }; float maxZoom = characteristics.getAvailableMaxDigitalZoom(); List supportedPreviewSizes = characteristics.getSupportedPreviewSizes(); OneCamera.Facing direction = characteristics.getCameraDirection(); return new InitializedOneCameraFactory(lifetime, cameraStarter, device, outputSurfaces, mainThread, new HandlerFactory(), maxZoom, supportedPreviewSizes, characteristics.getLensFocusRange(), direction).provideOneCamera(); } }