1#ifndef CAMERA_TEST_H
2#define CAMERA_TEST_H
3
4#ifdef ANDROID_API_JB_OR_LATER
5#include <gui/Surface.h>
6#include <gui/SurfaceComposerClient.h>
7#else
8#include <surfaceflinger/Surface.h>
9#include <surfaceflinger/ISurface.h>
10#include <surfaceflinger/ISurfaceComposer.h>
11#include <surfaceflinger/ISurfaceComposerClient.h>
12#include <surfaceflinger/SurfaceComposerClient.h>
13#endif
14
15#ifdef ANDROID_API_JB_OR_LATER
16#   define CAMHAL_LOGV            ALOGV
17#   define CAMHAL_LOGE            ALOGE
18#   define PRINTOVER(arg...)      ALOGD(#arg)
19#   define LOG_FUNCTION_NAME      ALOGD("%d: %s() ENTER", __LINE__, __FUNCTION__);
20#   define LOG_FUNCTION_NAME_EXIT ALOGD("%d: %s() EXIT", __LINE__, __FUNCTION__);
21#else
22#   define CAMHAL_LOGV            LOGV
23#   define CAMHAL_LOGE            LOGE
24#   define PRINTOVER(arg...)      LOGD(#arg)
25#   define LOG_FUNCTION_NAME      LOGD("%d: %s() ENTER", __LINE__, __FUNCTION__);
26#   define LOG_FUNCTION_NAME_EXIT LOGD("%d: %s() EXIT", __LINE__, __FUNCTION__);
27#endif
28
29#define KEY_GBCE            "gbce"
30#define KEY_GLBCE           "glbce"
31#define KEY_CAMERA          "camera-index"
32#define KEY_SATURATION      "saturation"
33#define KEY_BRIGHTNESS      "brightness"
34#define KEY_TI_BURST           "burst-capture"
35#define KEY_EXPOSURE        "exposure"
36#define KEY_CONTRAST        "contrast"
37#define KEY_SHARPNESS       "sharpness"
38#define KEY_ISO             "iso"
39#define KEY_CAF             "caf"
40#define KEY_MODE            "mode"
41#define KEY_VNF             "vnf"
42#define KEY_VSTAB           "vstab"
43#define KEY_COMPENSATION    "exposure-compensation"
44#define KEY_SENSOR_ORIENTATION "sensor-orientation"
45
46#define KEY_IPP             "ipp"
47
48#define KEY_BUFF_STARV      "buff-starvation"
49#define KEY_METERING_MODE   "meter-mode"
50#define KEY_AUTOCONVERGENCE "auto-convergence-mode"
51#define KEY_MANUAL_CONVERGENCE "manual-convergence"
52#define KEY_EXP_BRACKETING_RANGE "exp-bracketing-range"
53#define KEY_EXP_GAIN_BRACKETING_RANGE "exp-gain-bracketing-range"
54#define KEY_TEMP_BRACKETING "temporal-bracketing"
55#define KEY_TEMP_BRACKETING_POS "temporal-bracketing-range-positive"
56#define KEY_TEMP_BRACKETING_NEG "temporal-bracketing-range-negative"
57#define KEY_MEASUREMENT "measurement"
58#define KEY_S3D2D_PREVIEW_MODE "s3d2d-preview"
59#define KEY_S3D_PRV_FRAME_LAYOUT "s3d-prv-frame-layout"
60#define KEY_S3D_CAP_FRAME_LAYOUT "s3d-cap-frame-layout"
61#define KEY_EXIF_MODEL "exif-model"
62#define KEY_EXIF_MAKE "exif-make"
63#define KEY_AF_TIMEOUT "af-timeout"
64
65#define KEY_AUTO_EXPOSURE_LOCK "auto-exposure-lock"
66#define KEY_AUTO_WHITEBALANCE_LOCK "auto-whitebalance-lock"
67
68#define KEY_MECHANICAL_MISALIGNMENT_CORRECTION "mechanical-misalignment-correction"
69
70//TI extensions for enable/disable algos
71#define KEY_ALGO_FIXED_GAMMA            "ti-algo-fixed-gamma"
72#define KEY_ALGO_NSF1                   "ti-algo-nsf1"
73#define KEY_ALGO_NSF2                   "ti-algo-nsf2"
74#define KEY_ALGO_SHARPENING             "ti-algo-sharpening"
75#define KEY_ALGO_THREELINCOLORMAP       "ti-algo-threelinecolormap"
76#define KEY_ALGO_GIC                    "ti-algo-gic"
77
78#define KEY_TAP_OUT_SURFACES            "tap-out"
79#define KEY_TAP_IN_SURFACE              "tap-in"
80
81#define BRACKETING_IDX_DEFAULT          0
82#define BRACKETING_IDX_STREAM           1
83#define BRACKETING_STREAM_BUFFERS       9
84
85#define SDCARD_PATH "/sdcard/"
86#define SECONDARY_SENSOR "_SEC"
87#define S3D_SENSOR "_S3D"
88
89#define MAX_BURST   15
90#define BURST_INC     5
91#define TEMP_BRACKETING_MAX_RANGE 4
92
93#define MEDIASERVER_DUMP "procmem -w $(ps | grep mediaserver | grep -Eo '[0-9]+' | head -n 1) | grep \"\\(Name\\|libcamera.so\\|libOMX\\|libomxcameraadapter.so\\|librcm.so\\|libnotify.so\\|libipcutils.so\\|libipc.so\\|libsysmgr.so\\|TOTAL\\)\""
94#define MEMORY_DUMP "procrank -u"
95#define KEY_METERING_MODE   "meter-mode"
96
97#define TEST_FOCUS_AREA "(-1000,500,-500,1000,1000),(500,500,1000,1000,1)"
98#define TEST_METERING_AREA "(-1000,500,-500,1000,1000),(500,500,1000,1000,1)"
99#define TEST_METERING_AREA_CENTER "(-250,-250,250,250,1000)"
100#define TEST_METERING_AREA_AVERAGE "(-1000,-1000,1000,1000,1000)"
101
102#define COMPENSATION_OFFSET 20
103#define DELIMITER           "|"
104
105#define MODEL "camera_test"
106#define MAKE "camera_test"
107
108#define BLAZE 0
109#define BLAZE_TABLET1 1
110#define BLAZE_TABLET2 2
111
112#define MAX_LINES    80
113#define MAX_SYMBOLS  65
114
115#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
116
117typedef enum test_type {
118    TEST_TYPE_REGRESSION,
119    TEST_TYPE_FUNCTIONAL,
120    TEST_TYPE_API,
121    TEST_TYPE_ERROR,
122} test_type_t;
123
124typedef enum param_ExpBracketParamType_t {
125    PARAM_EXP_BRACKET_PARAM_NONE,
126    PARAM_EXP_BRACKET_PARAM_COMP,
127    PARAM_EXP_BRACKET_PARAM_PAIR,
128} param_ExpBracketParamType;
129
130typedef enum param_ExpBracketValueType_t {
131    PARAM_EXP_BRACKET_VALUE_NONE,
132    PARAM_EXP_BRACKET_VALUE_ABS,
133    PARAM_EXP_BRACKET_VALUE_REL,
134} param_ExpBracketValueType;
135
136typedef enum param_ExpBracketApplyType_t {
137    PARAM_EXP_BRACKET_APPLY_NONE,
138    PARAM_EXP_BRACKET_APPLY_ADJUST,
139    PARAM_EXP_BRACKET_APPLY_FORCED,
140} param_ExpBracketApplyType;
141
142enum logging {
143    LOGGING_LOGCAT = 0x01,
144    LOGGING_SYSLINK = 0x02
145};
146
147typedef struct cmd_args {
148    test_type_t test_type;
149    const char *script_file_name;
150    const char *output_path;
151    int platform_id;
152    int logging;
153} cmd_args_t;
154
155namespace android {
156    class CameraHandler: public CameraListener {
157        public:
158            virtual void notify(int32_t msgType, int32_t ext1, int32_t ext2);
159            virtual void postData(int32_t msgType,
160                                  const sp<IMemory>& dataPtr,
161                                  camera_frame_metadata_t *metadata);
162
163            virtual void postDataTimestamp(nsecs_t timestamp, int32_t msgType, const sp<IMemory>& dataPtr);
164    };
165
166};
167
168using namespace android;
169
170
171typedef struct pixel_format_t {
172    int32_t pixelFormatDesc;
173    const char *pixformat;
174}pixel_format;
175
176typedef struct output_format_t {
177    output_format type;
178    const char *desc;
179} outformat;
180
181typedef struct Vcapture_size_t {
182    int width, height;
183    const char *desc;
184} Vcapture_size;
185
186typedef struct param_Array_t {
187    int width, height;
188    char name[60];
189} param_Array;
190
191typedef struct video_Codecs_t {
192    video_encoder type;
193    const char *desc;
194} video_Codecs;
195
196typedef struct audio_Codecs_t {
197    audio_encoder type;
198    const char *desc;
199} audio_Codecs;
200
201typedef struct V_bitRate_t {
202    uint32_t bit_rate;
203    const char *desc;
204} V_bitRate;
205
206typedef struct zoom_t {
207    int idx;
208    const char *zoom_description;
209} Zoom;
210
211typedef struct fps_ranges_t {
212    int rangeMin;
213    int rangeMax;
214} fps_Array;
215
216typedef struct buffer_info {
217    int size;
218    int width;
219    int height;
220    int format;
221    size_t offset;
222    Rect crop;
223    sp<GraphicBuffer> buf;
224} buffer_info_t;
225
226typedef struct param_NamedExpBracketList_t {
227    const char *desc;
228    param_ExpBracketParamType_t param_type;
229    param_ExpBracketValueType_t value_type;
230    param_ExpBracketApplyType_t apply_type;
231    const char *value;
232} param_NamedExpBracketList;
233
234
235char * get_cycle_cmd(const char *aSrc);
236void trim_script_cmd(char *cmd);
237int execute_functional_script(char *script);
238status_t dump_mem_status();
239int openCamera();
240int closeCamera();
241void createBufferOutputSource();
242void createBufferInputSource();
243void requestBufferSourceReset();
244void initDefaults();
245void setDefaultExpGainPreset(ShotParameters &params, int idx);
246void setSingleExpGainPreset(ShotParameters &params, int idx, int exp, int gain);
247void setExpGainPreset(ShotParameters &params, const char *input, bool force, param_ExpBracketParamType_t type, bool flush);
248void calcNextSingleExpGainPreset(int idx, int &exp, int &gain);
249void updateShotConfigFlushParam();
250int startPreview();
251void stopPreview();
252int startRecording();
253int stopRecording();
254int closeRecorder();
255int openRecorder();
256int configureRecorder();
257void printSupportedParams();
258char *load_script(const char *config);
259int start_logging(int flags, int &pid);
260int stop_logging(int flags, int &pid);
261int execute_error_script(char *script);
262int getParametersFromCapabilities();
263void  getSizeParametersFromCapabilities();
264int getDefaultParameter(const char* val, int numOptions, char **array);
265int getDefaultParameterResol(const char* val, int numOptions, param_Array  **array);
266int getSupportedParameters(char* parameters, int* optionsCount, char ***elem);
267int getSupportedParametersCaptureSize(char* parameters, int *optionsCount, param_Array array[], int arraySize);
268int getSupportedParametersVideoCaptureSize(char* parameters, int *optionsCount, param_Array array[], int arraySize);
269int getSupportedParametersPreviewSize(char* parameters, int *optionsCount, param_Array array[], int arraySize);
270int getSupportedParametersThumbnailSize(char* parameters, int *optionsCount, param_Array array[], int arraySize);
271int getSupportedParametersNames(int width, int height, param_Array array[], int arraySize);
272int checkSupportedParamScript(char **array, int size, char *param);
273int checkSupportedParamScriptLayout(char **array, int size, char *param,int *index);
274int checkSupportedParamScriptResol(param_Array **array, int size, char *param, int *num);
275int checkSupportedParamScriptResol(param_Array **array, int size, int w, int h, int *num);
276int getSupportedParametersfps(char* parameters, int *optionsCount);
277int checkSupportedParamScriptfpsConst(int *array, int size, char *param, int *num);
278int checkSupportedParamScriptfpsRange(char **array, int size, char *param, int *num);
279int trySetVideoStabilization(bool toggle);
280int trySetVideoNoiseFilter(bool toggle);
281int trySetAutoExposureLock(bool toggle);
282int trySetAutoWhiteBalanceLock(bool toggle);
283bool isRawPixelFormat (const char *format);
284int deleteAllocatedMemory();
285void initDefaultsSec();
286
287const char KEY_S3D_PRV_FRAME_LAYOUT_VALUES[] = "s3d-prv-frame-layout-values";
288const char KEY_S3D_CAP_FRAME_LAYOUT_VALUES[] = "s3d-cap-frame-layout-values";
289
290const char KEY_SUPPORTED_PICTURE_TOPBOTTOM_SIZES[] = "supported-picture-topbottom-size-values";
291const char KEY_SUPPORTED_PREVIEW_TOPBOTTOM_SIZES[] = "supported-preview-topbottom-size-values";
292const char KEY_SUPPORTED_PICTURE_SIDEBYSIDE_SIZES[] = "supported-picture-sidebyside-size-values";
293const char KEY_SUPPORTED_PREVIEW_SIDEBYSIDE_SIZES[] = "supported-preview-sidebyside-size-values";
294const char KEY_SUPPORTED_PICTURE_SUBSAMPLED_SIZES[] = "supported-picture-subsampled-size-values";
295const char KEY_SUPPORTED_PREVIEW_SUBSAMPLED_SIZES[] = "supported-preview-subsampled-size-values";
296
297const char KEY_AUTOCONVERGENCE_MODE[] = "auto-convergence-mode";
298const char KEY_AUTOCONVERGENCE_MODE_VALUES[] = "auto-convergence-mode-values";
299
300const char KEY_MANUAL_EXPOSURE[] = "manual-exposure";
301const char KEY_MANUAL_GAIN_ISO[] = "manual-gain-iso";
302const char KEY_MANUAL_EXPOSURE_RIGHT[] = "manual-exposure-right";
303const char KEY_MANUAL_GAIN_ISO_RIGHT[] = "manual-gain-iso-right";
304
305const char KEY_SUPPORTED_MANUAL_CONVERGENCE_MIN[] = "supported-manual-convergence-min";
306const char KEY_SUPPORTED_MANUAL_CONVERGENCE_MAX[] = "supported-manual-convergence-max";
307const char KEY_SUPPORTED_MANUAL_CONVERGENCE_STEP[] = "supported-manual-convergence-step";
308
309const char KEY_SUPPORTED_MANUAL_EXPOSURE_MIN[] = "supported-manual-exposure-min";
310const char KEY_SUPPORTED_MANUAL_EXPOSURE_MAX[] = "supported-manual-exposure-max";
311const char KEY_SUPPORTED_MANUAL_EXPOSURE_STEP[] = "supported-manual-exposure-step";
312
313const char KEY_SUPPORTED_MANUAL_GAIN_ISO_MIN[] = "supported-manual-gain-iso-min";
314const char KEY_SUPPORTED_MANUAL_GAIN_ISO_MAX[] = "supported-manual-gain-iso-max";
315const char KEY_SUPPORTED_MANUAL_GAIN_ISO_STEP[] = "supported-manual-gain-iso-step";
316
317class BufferSourceThread : public Thread {
318public:
319    class Defer : public Thread {
320        private:
321            struct DeferContainer {
322                sp<GraphicBuffer> graphicBuffer;
323                uint8_t *mappedBuffer;
324                unsigned int count;
325                unsigned int slot;
326                Rect crop;
327            };
328        public:
329            Defer(BufferSourceThread* bst) :
330                    Thread(false), mBST(bst), mExiting(false) { }
331            virtual ~Defer() {
332                Mutex::Autolock lock(mFrameQueueMutex);
333                mExiting = true;
334                while (!mDeferQueue.isEmpty()) {
335                    DeferContainer defer = mDeferQueue.itemAt(0);
336                    defer.graphicBuffer->unlock();
337                    mDeferQueue.removeAt(0);
338                }
339                mFrameQueueCondition.signal();
340            }
341
342            virtual void requestExit() {
343                Thread::requestExit();
344
345                mExiting = true;
346                mFrameQueueCondition.signal();
347            }
348
349            virtual bool threadLoop() {
350                Mutex::Autolock lock(mFrameQueueMutex);
351                while (mDeferQueue.isEmpty() && !mExiting) {
352                    mFrameQueueCondition.wait(mFrameQueueMutex);
353                }
354
355                if (!mExiting) {
356                    DeferContainer defer = mDeferQueue.itemAt(0);
357                    printf ("=== handling buffer %d\n", defer.count);
358                    mBST->handleBuffer(defer.graphicBuffer, defer.mappedBuffer,
359                                       defer.count, defer.crop);
360                    defer.graphicBuffer->unlock();
361                    mDeferQueue.removeAt(0);
362                    mBST->onHandled(defer.graphicBuffer, defer.slot);
363                    return true;
364                }
365                return false;
366            }
367            void add(sp<GraphicBuffer> &gbuf, const Rect &crop,
368                     unsigned int count, unsigned int slot = 0) {
369                Mutex::Autolock lock(mFrameQueueMutex);
370                DeferContainer defer;
371                defer.graphicBuffer = gbuf;
372                defer.count = count;
373                defer.slot = slot;
374                defer.crop = crop;
375                gbuf->lock(GRALLOC_USAGE_SW_READ_RARELY, (void**) &defer.mappedBuffer);
376                mDeferQueue.add(defer);
377                mFrameQueueCondition.signal();
378            }
379        private:
380            Vector<DeferContainer> mDeferQueue;
381            Mutex mFrameQueueMutex;
382            Condition mFrameQueueCondition;
383            BufferSourceThread* mBST;
384            bool mExiting;
385    };
386public:
387    BufferSourceThread(sp<Camera> camera) :
388                 Thread(false), mCamera(camera),
389                 mDestroying(false), mRestartCapture(false),
390                 mExpBracketIdx(BRACKETING_IDX_DEFAULT), mExp(0), mGain(0), mCounter(0),
391                 kReturnedBuffersMaxCapacity(6) {
392
393        mDeferThread = new Defer(this);
394        mDeferThread->run();
395    }
396
397    virtual ~BufferSourceThread() {
398        mDestroying = true;
399
400        for (unsigned int i = 0; i < mReturnedBuffers.size(); i++) {
401            buffer_info_t info = mReturnedBuffers.itemAt(i);
402            mReturnedBuffers.removeAt(i);
403        }
404        mDeferThread->requestExit();
405        mDeferThread.clear();
406    }
407
408    virtual bool threadLoop() { return false;}
409    virtual void requestExit() {};
410    virtual void setBuffer(android::ShotParameters &params) {};
411    virtual void onHandled(sp<GraphicBuffer> &g, unsigned int slot) {};
412
413    bool setStreamCapture(bool restart, int expBracketIdx) {
414        Mutex::Autolock lock(mToggleStateMutex);
415        mExpBracketIdx = expBracketIdx;
416        mRestartCapture = restart;
417        return mRestartCapture;
418    }
419
420    buffer_info_t popBuffer() {
421        buffer_info_t buffer;
422        Mutex::Autolock lock(mReturnedBuffersMutex);
423        if (!mReturnedBuffers.isEmpty()) {
424            buffer = mReturnedBuffers.itemAt(0);
425            mReturnedBuffers.removeAt(0);
426        }
427        return buffer;
428    }
429
430    bool hasBuffer() {
431        Mutex::Autolock lock(mReturnedBuffersMutex);
432        return !mReturnedBuffers.isEmpty();
433    }
434
435    void handleBuffer(sp<GraphicBuffer> &, uint8_t *, unsigned int, const Rect &);
436    Rect getCrop(sp<GraphicBuffer> &buffer, const float *mtx);
437    void showMetadata(sp<IMemory> data);
438protected:
439    void restartCapture() {
440        Mutex::Autolock lock(mToggleStateMutex);
441        if (mRestartCapture) {
442            ShotParameters shotParams;
443            calcNextSingleExpGainPreset(mExpBracketIdx, mExp, mGain),
444            setSingleExpGainPreset(shotParams, mExpBracketIdx, mExp, mGain);
445            shotParams.set(ShotParameters::KEY_BURST, 1);
446            mCamera->takePictureWithParameters(0, shotParams.flatten());
447        }
448    }
449protected:
450    sp<Camera> mCamera;
451    bool mDestroying;
452    bool mRestartCapture;
453    int mExpBracketIdx;
454    int mExp;
455    int mGain;
456    sp<Defer> mDeferThread;
457    unsigned int mCounter;
458private:
459    Vector<buffer_info_t> mReturnedBuffers;
460    Mutex mReturnedBuffersMutex;
461    Mutex mToggleStateMutex;
462    const unsigned int kReturnedBuffersMaxCapacity;
463};
464
465
466class BufferSourceInput : public RefBase {
467public:
468    BufferSourceInput(sp<Camera> camera) : mCamera(camera) {
469        mTapOut = new BufferSourceThread(camera);
470        mTapOut->run();
471    }
472
473    virtual ~BufferSourceInput() {
474        mTapOut->requestExit();
475        mTapOut.clear();
476    }
477
478    virtual void setInput(buffer_info_t, const char *format, ShotParameters &params);
479
480protected:
481    sp<BufferSourceThread> mTapOut;
482    sp<ANativeWindow> mWindowTapIn;
483    sp<Camera> mCamera;
484};
485#endif
486