1/* Copyright (c) 2012-2016, The Linux Foundation. All rights reserved.
2 *
3 * Redistribution and use in source and binary forms, with or without
4 * modification, are permitted provided that the following conditions are
5 * met:
6 *     * Redistributions of source code must retain the above copyright
7 *       notice, this list of conditions and the following disclaimer.
8 *     * Redistributions in binary form must reproduce the above
9 *       copyright notice, this list of conditions and the following
10 *       disclaimer in the documentation and/or other materials provided
11 *       with the distribution.
12 *     * Neither the name of The Linux Foundation nor the names of its
13 *       contributors may be used to endorse or promote products derived
14 *       from this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
17 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
18 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
19 * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
20 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
23 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
24 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
25 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
26 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 *
28 */
29
30#ifndef QCAMERA_TEST_H
31#define QCAMERA_TEST_H
32
33#include <SkData.h>
34#include <SkBitmap.h>
35#include <SkStream.h>
36
37namespace qcamera {
38
39using namespace android;
40
41#define MAX_CAM_INSTANCES 3
42
43class TestContext;
44
45class CameraContext : public CameraListener,
46    public ICameraRecordingProxyListener{
47public:
48    typedef enum {
49        READ_METADATA = 1,
50        READ_IMAGE = 2,
51        READ_ALL = 3
52    } ReadMode_t;
53
54    // This structure is used to store jpeg file sections in memory.
55    typedef struct {
56        unsigned char *  Data;
57        int      Type;
58        size_t   Size;
59    } Sections_t;
60
61public:
62    static const char KEY_ZSL[];
63
64    CameraContext(int cameraIndex);
65    virtual ~CameraContext();
66
67
68
69    status_t openCamera();
70    status_t closeCamera();
71
72    status_t startPreview();
73    status_t stopPreview();
74    status_t resumePreview();
75    status_t autoFocus();
76    status_t enablePreviewCallbacks();
77    status_t takePicture();
78    status_t startRecording();
79    status_t stopRecording();
80    status_t startViVRecording();
81    status_t stopViVRecording();
82    status_t configureViVRecording();
83
84    status_t nextPreviewSize();
85    status_t setPreviewSize(const char *format);
86    status_t getCurrentPreviewSize(Size &previewSize);
87
88    status_t nextPictureSize();
89    status_t getCurrentPictureSize(Size &pictureSize);
90    status_t setPictureSize(const char *format);
91
92    status_t nextVideoSize();
93    status_t setVideoSize(const char *format);
94    status_t getCurrentVideoSize(Size &videoSize);
95    status_t configureRecorder();
96    status_t unconfigureRecorder();
97    Sections_t *FindSection(int SectionType);
98    status_t ReadSectionsFromBuffer (unsigned char *buffer,
99            size_t buffer_size, ReadMode_t ReadMode);
100    virtual IBinder* onAsBinder();
101    void setTestCtxInstance(TestContext *instance);
102
103    void printMenu(sp<CameraContext> currentCamera);
104    void printSupportedParams();
105    const char *getZSL();
106    void setZSL(const char *value);
107
108
109    int getCameraIndex() { return mCameraIndex; }
110    int getNumberOfCameras();
111    void enablePrintPreview();
112    void disablePrintPreview();
113    void enablePiPCapture();
114    void disablePiPCapture();
115    void CheckSectionsAllocated();
116    void DiscardData();
117    void DiscardSections();
118    size_t calcBufferSize(int width, int height);
119    size_t calcStride(int width);
120    size_t calcYScanLines(int height);
121    size_t calcUVScanLines(int height);
122
123    virtual void notify(int32_t msgType, int32_t ext1, int32_t ext2);
124    virtual void postData(int32_t msgType,
125            const sp<IMemory>& dataPtr,
126            camera_frame_metadata_t *metadata);
127
128    virtual void postDataTimestamp(nsecs_t timestamp,
129            int32_t msgType,
130            const sp<IMemory>& dataPtr);
131    virtual void dataCallbackTimestamp(nsecs_t timestamp,
132            int32_t msgType,
133            const sp<IMemory>& dataPtr);
134
135private:
136
137    status_t createPreviewSurface(int width, int height, int32_t pixFormat);
138    status_t destroyPreviewSurface();
139
140    status_t saveFile(const sp<IMemory>& mem, String8 path);
141    SkBitmap * PiPCopyToOneFile(SkBitmap *bitmap0, SkBitmap *bitmap1);
142    status_t decodeJPEG(const sp<IMemory>& mem, SkBitmap *skBM);
143    status_t encodeJPEG(SkWStream * stream, const SkBitmap *bitmap,
144        String8 path);
145    void previewCallback(const sp<IMemory>& mem);
146
147    static int JpegIdx;
148    int mCameraIndex;
149    bool mResizePreview;
150    bool mHardwareActive;
151    bool mPreviewRunning;
152    bool mRecordRunning;
153    int  mVideoFd;
154    int  mVideoIdx;
155    bool mRecordingHint;
156    bool mDoPrintMenu;
157    bool mPiPCapture;
158    static int mPiPIdx;
159    unsigned int mfmtMultiplier;
160    int mWidthTmp;
161    int mHeightTmp;
162    size_t mSectionsRead;
163    size_t mSectionsAllocated;
164    Sections_t * mSections;
165    Sections_t * mJEXIFTmp;
166    Sections_t mJEXIFSection;
167    int mHaveAll;
168    TestContext *mInterpr;
169
170    sp<Camera> mCamera;
171    sp<SurfaceComposerClient> mClient;
172    sp<SurfaceControl> mSurfaceControl;
173    sp<Surface> mPreviewSurface;
174    sp<MediaRecorder> mRecorder;
175    CameraParameters mParams;
176    SkBitmap *skBMDec;
177    SkImageEncoder* skJpegEnc;
178    SkBitmap skBMtmp;
179    sp<IMemory> PiPPtrTmp;
180
181    size_t mCurrentPreviewSizeIdx;
182    Size getPreviewSizeFromVideoSizes(Size currentVideoSize);
183    size_t mCurrentPictureSizeIdx;
184    size_t mCurrentVideoSizeIdx;
185    Vector<Size> mSupportedPreviewSizes;
186    Vector<Size> mSupportedPictureSizes;
187    Vector<Size> mSupportedVideoSizes;
188
189    bool mInUse;
190    Mutex mLock;
191    Condition mCond;
192
193    void useLock();
194    void signalFinished();
195
196    //------------------------------------------------------------------------
197    // JPEG markers consist of one or more 0xFF bytes, followed by a marker
198    // code byte (which is not an FF).  Here are the marker codes of interest
199    // in this program.  (See jdmarker.c for a more complete list.)
200    //------------------------------------------------------------------------
201    #define M_SOF0  0xC0          // Start Of Frame N
202    #define M_SOF1  0xC1          // N indicates which compression process
203    #define M_SOF2  0xC2          // Only SOF0-SOF2 are now in common use
204    #define M_SOF3  0xC3
205    #define M_SOF5  0xC5          // NB: codes C4 and CC are NOT SOF markers
206    #define M_SOF6  0xC6
207    #define M_SOF7  0xC7
208    #define M_SOF9  0xC9
209    #define M_SOF10 0xCA
210    #define M_SOF11 0xCB
211    #define M_SOF13 0xCD
212    #define M_SOF14 0xCE
213    #define M_SOF15 0xCF
214    #define M_SOI   0xD8          // Start Of Image (beginning of datastream)
215    #define M_EOI   0xD9          // End Of Image (end of datastream)
216    #define M_SOS   0xDA          // Start Of Scan (begins compressed data)
217    #define M_JFIF  0xE0          // Jfif marker
218    #define M_EXIF  0xE1          // Exif marker.  Also used for XMP data!
219    #define M_XMP   0x10E1        // Not a real tag same value as Exif!
220    #define M_COM   0xFE          // COMment
221    #define M_DQT   0xDB
222    #define M_DHT   0xC4
223    #define M_DRI   0xDD
224    #define M_IPTC  0xED          // IPTC marker
225    #define PSEUDO_IMAGE_MARKER 0x123; // Extra value.
226};
227
228class Interpreter
229{
230public:
231    enum Commands_e {
232        SWITCH_CAMERA_CMD = 'A',
233        RESUME_PREVIEW_CMD = '[',
234        START_PREVIEW_CMD = '1',
235        STOP_PREVIEW_CMD = '2',
236        CHANGE_VIDEO_SIZE_CMD = '3',
237        CHANGE_PREVIEW_SIZE_CMD = '4',
238        CHANGE_PICTURE_SIZE_CMD = '5',
239        START_RECORD_CMD = '6',
240        STOP_RECORD_CMD = '7',
241        START_VIV_RECORD_CMD = '8',
242        STOP_VIV_RECORD_CMD = '9',
243        DUMP_CAPS_CMD = 'E',
244        AUTOFOCUS_CMD = 'f',
245        TAKEPICTURE_CMD = 'p',
246        TAKEPICTURE_IN_PICTURE_CMD = 'P',
247        ENABLE_PRV_CALLBACKS_CMD = '&',
248        EXIT_CMD = 'q',
249        DELAY = 'd',
250        ZSL_CMD = 'z',
251        INVALID_CMD = '0'
252    };
253
254    struct Command {
255        Command( Commands_e cmd_, char *arg_ = NULL)
256        : cmd(cmd_)
257        , arg(arg_) {}
258        Command()
259        : cmd(INVALID_CMD)
260        , arg(NULL) {}
261        Commands_e cmd;
262        char *arg;
263    };
264
265    /* API */
266    Interpreter()
267    : mUseScript(false)
268    , mScript(NULL) {}
269
270    Interpreter(const char *file);
271    ~Interpreter();
272
273    Command getCommand(sp<CameraContext> currentCamera);
274    void releasePiPBuff();
275    status_t configureViVCodec();
276    void setViVSize(Size VideoSize, int camIndex);
277    void setTestCtxInst(TestContext *instance);
278    status_t unconfigureViVCodec();
279    status_t ViVEncoderThread();
280    void ViVEncode();
281    static void *ThreadWrapper(void *context);
282
283private:
284    static const int numberOfCommands;
285
286    bool mUseScript;
287    size_t mCmdIndex;
288    char *mScript;
289    Vector<Command> mCommands;
290    TestContext *mTestContext;
291    pthread_t mViVEncThread;
292};
293
294class TestContext
295{
296    friend class CameraContext;
297    friend class Interpreter;
298public:
299    TestContext();
300    ~TestContext();
301
302    size_t GetCamerasNum();
303    status_t FunctionalTest();
304    status_t AddScriptFromFile(const char *scriptFile);
305    void setViVSize(Size VideoSize, int camIndex);
306    void PiPLock();
307    void PiPUnlock();
308    void ViVLock();
309    void ViVUnlock();
310
311private:
312    sp<CameraContext> camera[MAX_CAM_INSTANCES];
313    char GetNextCmd(sp<qcamera::CameraContext> currentCamera);
314    size_t mCurrentCameraIndex;
315    size_t mSaveCurrentCameraIndex;
316    Vector< sp<qcamera::CameraContext> > mAvailableCameras;
317    bool mTestRunning;
318    Interpreter *mInterpreter;
319    Mutex mPiPLock;
320    Condition mPiPCond;
321    bool mPiPinUse;
322    Mutex mViVLock;
323    Condition mViVCond;
324    bool mViVinUse;
325    bool mIsZSLOn;
326
327    typedef struct ViVBuff_t{
328        void *buff;
329        size_t buffSize;
330        size_t YStride;
331        size_t UVStride;
332        size_t YScanLines;
333        size_t UVScanLines;
334        size_t srcWidth;
335        size_t srcHeight;
336    } ViVBuff_t;
337
338    typedef struct ViVVid_t{
339        sp<IGraphicBufferProducer> bufferProducer;
340        sp<Surface> surface;
341        sp<MediaCodec> codec;
342        sp<MediaMuxer> muxer;
343        sp<ANativeWindow> ANW;
344        Vector<sp<ABuffer> > buffers;
345        Size VideoSizes[2];
346        int ViVIdx;
347        size_t buff_cnt;
348        sp<GraphicBuffer> graphBuf;
349        void * mappedBuff;
350        bool isBuffValid;
351        int sourceCameraID;
352        int destinationCameraID;
353    } vidPiP_t;
354
355    ViVVid_t mViVVid;
356    ViVBuff_t mViVBuff;
357};
358
359}; //namespace qcamera
360
361#endif
362