Home | History | Annotate | Download | only in client2 
      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 #ifndef ANDROID_SERVERS_CAMERA_CAMERA2_CAPTURESEQUENCER_H
     18 #define ANDROID_SERVERS_CAMERA_CAMERA2_CAPTURESEQUENCER_H
     19 
     20 #include <binder/MemoryBase.h>
     21 #include <utils/Thread.h>
     22 #include <utils/String16.h>
     23 #include <utils/Vector.h>
     24 #include <utils/Mutex.h>
     25 #include <utils/Condition.h>
     26 #include "camera/CameraMetadata.h"
     27 #include "camera/CaptureResult.h"
     28 #include "Parameters.h"
     29 #include "FrameProcessor.h"
     30 
     31 namespace android {
     32 
     33 class Camera2Client;
     34 
     35 namespace camera2 {
     36 
     37 class ZslProcessorInterface;
     38 class BurstCapture;
     39 
     40 /**
     41  * Manages the still image capture process for
     42  * zero-shutter-lag, regular, and video snapshots.
     43  */
     44 class CaptureSequencer:
     45             virtual public Thread,
     46             virtual public FrameProcessor::FilteredListener {
     47   public:
     48     CaptureSequencer(wp<Camera2Client> client);
     49     ~CaptureSequencer();
     50 
     51     // Get reference to the ZslProcessor, which holds the ZSL buffers and frames
     52     void setZslProcessor(wp<ZslProcessorInterface> processor);
     53 
     54     // Begin still image capture
     55     status_t startCapture(int msgType);
     56 
     57     // Wait until current image capture completes; returns immediately if no
     58     // capture is active. Returns TIMED_OUT if capture does not complete during
     59     // the specified duration.
     60     status_t waitUntilIdle(nsecs_t timeout);
     61 
     62     // Notifications about AE state changes
     63     void notifyAutoExposure(uint8_t newState, int triggerId);
     64 
     65     // Notification from the frame processor
     66     virtual void onResultAvailable(const CaptureResult &result);
     67 
     68     // Notifications from the JPEG processor
     69     void onCaptureAvailable(nsecs_t timestamp, sp<MemoryBase> captureBuffer);
     70 
     71     void dump(int fd, const Vector<String16>& args);
     72 
     73   private:
     74     /**
     75      * Accessed by other threads
     76      */
     77     Mutex mInputMutex;
     78 
     79     bool mStartCapture;
     80     bool mBusy;
     81     Condition mStartCaptureSignal;
     82 
     83     bool mNewAEState;
     84     uint8_t mAEState;
     85     int mAETriggerId;
     86     Condition mNewNotifySignal;
     87 
     88     bool mNewFrameReceived;
     89     int32_t mNewFrameId;
     90     CameraMetadata mNewFrame;
     91     Condition mNewFrameSignal;
     92 
     93     bool mNewCaptureReceived;
     94     nsecs_t mCaptureTimestamp;
     95     sp<MemoryBase> mCaptureBuffer;
     96     Condition mNewCaptureSignal;
     97 
     98     bool mShutterNotified;
     99 
    100     /**
    101      * Internal to CaptureSequencer
    102      */
    103     static const nsecs_t kWaitDuration = 100000000; // 100 ms
    104     static const int kMaxTimeoutsForPrecaptureStart = 10; // 1 sec
    105     static const int kMaxTimeoutsForPrecaptureEnd = 20;  // 2 sec
    106     static const int kMaxTimeoutsForCaptureEnd    = 40;  // 4 sec
    107 
    108     wp<Camera2Client> mClient;
    109     wp<ZslProcessorInterface> mZslProcessor;
    110     sp<BurstCapture> mBurstCapture;
    111 
    112     enum CaptureState {
    113         IDLE,
    114         START,
    115         ZSL_START,
    116         ZSL_WAITING,
    117         ZSL_REPROCESSING,
    118         STANDARD_START,
    119         STANDARD_PRECAPTURE_WAIT,
    120         STANDARD_CAPTURE,
    121         STANDARD_CAPTURE_WAIT,
    122         BURST_CAPTURE_START,
    123         BURST_CAPTURE_WAIT,
    124         DONE,
    125         ERROR,
    126         NUM_CAPTURE_STATES
    127     } mCaptureState;
    128     static const char* kStateNames[];
    129     int mStateTransitionCount;
    130     Mutex mStateMutex; // Guards mCaptureState
    131     Condition mStateChanged;
    132 
    133     typedef CaptureState (CaptureSequencer::*StateManager)(sp<Camera2Client> &client);
    134     static const StateManager kStateManagers[];
    135 
    136     CameraMetadata mCaptureRequest;
    137 
    138     int mTriggerId;
    139     int mTimeoutCount;
    140     bool mAeInPrecapture;
    141 
    142     int32_t mCaptureId;
    143     int mMsgType;
    144 
    145     // Main internal methods
    146 
    147     virtual bool threadLoop();
    148 
    149     CaptureState manageIdle(sp<Camera2Client> &client);
    150     CaptureState manageStart(sp<Camera2Client> &client);
    151 
    152     CaptureState manageZslStart(sp<Camera2Client> &client);
    153     CaptureState manageZslWaiting(sp<Camera2Client> &client);
    154     CaptureState manageZslReprocessing(sp<Camera2Client> &client);
    155 
    156     CaptureState manageStandardStart(sp<Camera2Client> &client);
    157     CaptureState manageStandardPrecaptureWait(sp<Camera2Client> &client);
    158     CaptureState manageStandardCapture(sp<Camera2Client> &client);
    159     CaptureState manageStandardCaptureWait(sp<Camera2Client> &client);
    160 
    161     CaptureState manageBurstCaptureStart(sp<Camera2Client> &client);
    162     CaptureState manageBurstCaptureWait(sp<Camera2Client> &client);
    163 
    164     CaptureState manageDone(sp<Camera2Client> &client);
    165 
    166     // Utility methods
    167 
    168     status_t updateCaptureRequest(const Parameters &params,
    169             sp<Camera2Client> &client);
    170 
    171     // Emit Shutter/Raw callback to java, and maybe play a shutter sound
    172     static void shutterNotifyLocked(const Parameters &params,
    173             sp<Camera2Client> client, int msgType);
    174 };
    175 
    176 }; // namespace camera2
    177 }; // namespace android
    178 
    179 #endif
    180