xref: /device/google/marlin/camera/QCamera2/HAL/test/qcamera_test.h

/* Copyright (c) 2012-2016, The Linux Foundation. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above
 *       copyright notice, this list of conditions and the following
 *       disclaimer in the documentation and/or other materials provided
 *       with the distribution.
 *     * Neither the name of The Linux Foundation nor the names of its
 *       contributors may be used to endorse or promote products derived
 *       from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 */

#ifndef QCAMERA_TEST_H
#define QCAMERA_TEST_H

#include <SkData.h>
#include <SkBitmap.h>
#include <SkStream.h>

namespace qcamera {

using namespace android;

#define MAX_CAM_INSTANCES 3

class TestContext;

class CameraContext : public CameraListener,
    public ICameraRecordingProxyListener{
public:
    typedef enum {
        READ_METADATA = 1,
        READ_IMAGE = 2,
        READ_ALL = 3
    } ReadMode_t;

    // This structure is used to store jpeg file sections in memory.
    typedef struct {
        unsigned char *  Data;
        int      Type;
        size_t   Size;
    } Sections_t;

public:
    static const char KEY_ZSL[];

    CameraContext(int cameraIndex);
    virtual ~CameraContext();



    status_t openCamera();
    status_t closeCamera();

    status_t startPreview();
    status_t stopPreview();
    status_t resumePreview();
    status_t autoFocus();
    status_t enablePreviewCallbacks();
    status_t takePicture();
    status_t startRecording();
    status_t stopRecording();
    status_t startViVRecording();
    status_t stopViVRecording();
    status_t configureViVRecording();

    status_t nextPreviewSize();
    status_t setPreviewSize(const char *format);
    status_t getCurrentPreviewSize(Size &previewSize);

    status_t nextPictureSize();
    status_t getCurrentPictureSize(Size &pictureSize);
    status_t setPictureSize(const char *format);

    status_t nextVideoSize();
    status_t setVideoSize(const char *format);
    status_t getCurrentVideoSize(Size &videoSize);
    status_t configureRecorder();
    status_t unconfigureRecorder();
    Sections_t *FindSection(int SectionType);
    status_t ReadSectionsFromBuffer (unsigned char *buffer,
            size_t buffer_size, ReadMode_t ReadMode);
    virtual IBinder* onAsBinder();
    void setTestCtxInstance(TestContext *instance);

    void printMenu(sp<CameraContext> currentCamera);
    void printSupportedParams();
    const char *getZSL();
    void setZSL(const char *value);


    int getCameraIndex() { return mCameraIndex; }
    int getNumberOfCameras();
    void enablePrintPreview();
    void disablePrintPreview();
    void enablePiPCapture();
    void disablePiPCapture();
    void CheckSectionsAllocated();
    void DiscardData();
    void DiscardSections();
    size_t calcBufferSize(int width, int height);
    size_t calcStride(int width);
    size_t calcYScanLines(int height);
    size_t calcUVScanLines(int height);

    virtual void notify(int32_t msgType, int32_t ext1, int32_t ext2);
    virtual void postData(int32_t msgType,
            const sp<IMemory>& dataPtr,
            camera_frame_metadata_t *metadata);

    virtual void postDataTimestamp(nsecs_t timestamp,
            int32_t msgType,
            const sp<IMemory>& dataPtr);
    virtual void dataCallbackTimestamp(nsecs_t timestamp,
            int32_t msgType,
            const sp<IMemory>& dataPtr);

private:

    status_t createPreviewSurface(int width, int height, int32_t pixFormat);
    status_t destroyPreviewSurface();

    status_t saveFile(const sp<IMemory>& mem, String8 path);
    SkBitmap * PiPCopyToOneFile(SkBitmap *bitmap0, SkBitmap *bitmap1);
    status_t decodeJPEG(const sp<IMemory>& mem, SkBitmap *skBM);
    status_t encodeJPEG(SkWStream * stream, const SkBitmap *bitmap,
        String8 path);
    void previewCallback(const sp<IMemory>& mem);

    static int JpegIdx;
    int mCameraIndex;
    bool mResizePreview;
    bool mHardwareActive;
    bool mPreviewRunning;
    bool mRecordRunning;
    int  mVideoFd;
    int  mVideoIdx;
    bool mRecordingHint;
    bool mDoPrintMenu;
    bool mPiPCapture;
    static int mPiPIdx;
    unsigned int mfmtMultiplier;
    int mWidthTmp;
    int mHeightTmp;
    size_t mSectionsRead;
    size_t mSectionsAllocated;
    Sections_t * mSections;
    Sections_t * mJEXIFTmp;
    Sections_t mJEXIFSection;
    int mHaveAll;
    TestContext *mInterpr;

    sp<Camera> mCamera;
    sp<SurfaceComposerClient> mClient;
    sp<SurfaceControl> mSurfaceControl;
    sp<Surface> mPreviewSurface;
    sp<MediaRecorder> mRecorder;
    CameraParameters mParams;
    SkBitmap *skBMDec;
    SkBitmap skBMtmp;
    sp<IMemory> PiPPtrTmp;

    size_t mCurrentPreviewSizeIdx;
    Size getPreviewSizeFromVideoSizes(Size currentVideoSize);
    size_t mCurrentPictureSizeIdx;
    size_t mCurrentVideoSizeIdx;
    Vector<Size> mSupportedPreviewSizes;
    Vector<Size> mSupportedPictureSizes;
    Vector<Size> mSupportedVideoSizes;

    bool mInUse;
    Mutex mLock;
    Condition mCond;

    void useLock();
    void signalFinished();

    //------------------------------------------------------------------------
    // JPEG markers consist of one or more 0xFF bytes, followed by a marker
    // code byte (which is not an FF).  Here are the marker codes of interest
    // in this program.  (See jdmarker.c for a more complete list.)
    //------------------------------------------------------------------------
    #define M_SOF0  0xC0          // Start Of Frame N
    #define M_SOF1  0xC1          // N indicates which compression process
    #define M_SOF2  0xC2          // Only SOF0-SOF2 are now in common use
    #define M_SOF3  0xC3
    #define M_SOF5  0xC5          // NB: codes C4 and CC are NOT SOF markers
    #define M_SOF6  0xC6
    #define M_SOF7  0xC7
    #define M_SOF9  0xC9
    #define M_SOF10 0xCA
    #define M_SOF11 0xCB
    #define M_SOF13 0xCD
    #define M_SOF14 0xCE
    #define M_SOF15 0xCF
    #define M_SOI   0xD8          // Start Of Image (beginning of datastream)
    #define M_EOI   0xD9          // End Of Image (end of datastream)
    #define M_SOS   0xDA          // Start Of Scan (begins compressed data)
    #define M_JFIF  0xE0          // Jfif marker
    #define M_EXIF  0xE1          // Exif marker.  Also used for XMP data!
    #define M_XMP   0x10E1        // Not a real tag same value as Exif!
    #define M_COM   0xFE          // COMment
    #define M_DQT   0xDB
    #define M_DHT   0xC4
    #define M_DRI   0xDD
    #define M_IPTC  0xED          // IPTC marker
    #define PSEUDO_IMAGE_MARKER 0x123; // Extra value.
};

class Interpreter
{
public:
    enum Commands_e {
        SWITCH_CAMERA_CMD = 'A',
        RESUME_PREVIEW_CMD = '[',
        START_PREVIEW_CMD = '1',
        STOP_PREVIEW_CMD = '2',
        CHANGE_VIDEO_SIZE_CMD = '3',
        CHANGE_PREVIEW_SIZE_CMD = '4',
        CHANGE_PICTURE_SIZE_CMD = '5',
        START_RECORD_CMD = '6',
        STOP_RECORD_CMD = '7',
        START_VIV_RECORD_CMD = '8',
        STOP_VIV_RECORD_CMD = '9',
        DUMP_CAPS_CMD = 'E',
        AUTOFOCUS_CMD = 'f',
        TAKEPICTURE_CMD = 'p',
        TAKEPICTURE_IN_PICTURE_CMD = 'P',
        ENABLE_PRV_CALLBACKS_CMD = '&',
        EXIT_CMD = 'q',
        DELAY = 'd',
        ZSL_CMD = 'z',
        INVALID_CMD = '0'
    };

    struct Command {
        Command( Commands_e cmd_, char *arg_ = NULL)
        : cmd(cmd_)
        , arg(arg_) {}
        Command()
        : cmd(INVALID_CMD)
        , arg(NULL) {}
        Commands_e cmd;
        char *arg;
    };

    /* API */
    Interpreter()
    : mUseScript(false)
    , mScript(NULL) {}

    Interpreter(const char *file);
    ~Interpreter();

    Command getCommand(sp<CameraContext> currentCamera);
    void releasePiPBuff();
    status_t configureViVCodec();
    void setViVSize(Size VideoSize, int camIndex);
    void setTestCtxInst(TestContext *instance);
    status_t unconfigureViVCodec();
    status_t ViVEncoderThread();
    void ViVEncode();
    static void *ThreadWrapper(void *context);

private:
    static const int numberOfCommands;

    bool mUseScript;
    size_t mCmdIndex;
    char *mScript;
    Vector<Command> mCommands;
    TestContext *mTestContext;
    pthread_t mViVEncThread;
};

class TestContext
{
    friend class CameraContext;
    friend class Interpreter;
public:
    TestContext();
    ~TestContext();

    size_t GetCamerasNum();
    status_t FunctionalTest();
    status_t AddScriptFromFile(const char *scriptFile);
    void setViVSize(Size VideoSize, int camIndex);
    void PiPLock();
    void PiPUnlock();
    void ViVLock();
    void ViVUnlock();

private:
    sp<CameraContext> camera[MAX_CAM_INSTANCES];
    char GetNextCmd(sp<qcamera::CameraContext> currentCamera);
    size_t mCurrentCameraIndex;
    size_t mSaveCurrentCameraIndex;
    Vector< sp<qcamera::CameraContext> > mAvailableCameras;
    bool mTestRunning;
    Interpreter *mInterpreter;
    Mutex mPiPLock;
    Condition mPiPCond;
    bool mPiPinUse;
    Mutex mViVLock;
    Condition mViVCond;
    bool mViVinUse;
    bool mIsZSLOn;

    typedef struct ViVBuff_t{
        void *buff;
        size_t buffSize;
        size_t YStride;
        size_t UVStride;
        size_t YScanLines;
        size_t UVScanLines;
        size_t srcWidth;
        size_t srcHeight;
    } ViVBuff_t;

    typedef struct ViVVid_t{
        sp<IGraphicBufferProducer> bufferProducer;
        sp<Surface> surface;
        sp<MediaCodec> codec;
        sp<MediaMuxer> muxer;
        sp<ANativeWindow> ANW;
        Vector<sp<ABuffer> > buffers;
        Size VideoSizes[2];
        int ViVIdx;
        size_t buff_cnt;
        sp<GraphicBuffer> graphBuf;
        void * mappedBuff;
        bool isBuffValid;
        int sourceCameraID;
        int destinationCameraID;
    } vidPiP_t;

    ViVVid_t mViVVid;
    ViVBuff_t mViVBuff;
};

}; //namespace qcamera

#endif