1 /* Copyright (c) 2012-2014, The Linux Foundataion. 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 37 namespace qcamera { 38 39 using namespace android; 40 41 class TestContext; 42 43 class CameraContext : public CameraListener, 44 public ICameraRecordingProxyListener{ 45 public: 46 typedef enum { 47 READ_METADATA = 1, 48 READ_IMAGE = 2, 49 READ_ALL = 3 50 } ReadMode_t; 51 52 // This structure is used to store jpeg file sections in memory. 53 typedef struct { 54 unsigned char * Data; 55 int Type; 56 unsigned Size; 57 } Sections_t; 58 59 public: 60 61 CameraContext(int cameraIndex); 62 virtual ~CameraContext(); 63 64 65 66 status_t openCamera(); 67 status_t closeCamera(); 68 69 status_t startPreview(); 70 status_t stopPreview(); 71 status_t resumePreview(); 72 status_t autoFocus(); 73 status_t enablePreviewCallbacks(); 74 status_t takePicture(); 75 status_t startRecording(); 76 status_t stopRecording(); 77 status_t startViVRecording(); 78 status_t stopViVRecording(); 79 status_t configureViVRecording(); 80 81 status_t nextPreviewSize(); 82 status_t setPreviewSize(const char *format); 83 status_t getCurrentPreviewSize(Size &previewSize); 84 85 status_t nextPictureSize(); 86 status_t getCurrentPictureSize(Size &pictureSize); 87 status_t setPictureSize(const char *format); 88 89 status_t nextVideoSize(); 90 status_t setVideoSize(const char *format); 91 status_t getCurrentVideoSize(Size &videoSize); 92 status_t configureRecorder(); 93 status_t unconfigureRecorder(); 94 Sections_t *FindSection(int SectionType); 95 status_t ReadSectionsFromBuffer (unsigned char *buffer, 96 unsigned int buffer_size, ReadMode_t ReadMode); 97 virtual IBinder* onAsBinder(); 98 void setTestCtxInstance(TestContext *instance); 99 100 void printMenu(sp<CameraContext> currentCamera); 101 void printSupportedParams(); 102 103 getCameraIndex()104 int getCameraIndex() { return mCameraIndex; } 105 int getNumberOfCameras(); 106 void enablePrintPreview(); 107 void disablePrintPreview(); 108 void enablePiPCapture(); 109 void disablePiPCapture(); 110 void CheckSectionsAllocated(); 111 void DiscardData(); 112 void DiscardSections(); 113 size_t calcBufferSize(int width, int height); 114 size_t calcStride(int width); 115 size_t calcYScanLines(int height); 116 size_t calcUVScanLines(int height); 117 118 virtual void notify(int32_t msgType, int32_t ext1, int32_t ext2); 119 virtual void postData(int32_t msgType, 120 const sp<IMemory>& dataPtr, 121 camera_frame_metadata_t *metadata); 122 123 virtual void postDataTimestamp(nsecs_t timestamp, 124 int32_t msgType, 125 const sp<IMemory>& dataPtr); 126 virtual void dataCallbackTimestamp(nsecs_t timestamp, 127 int32_t msgType, 128 const sp<IMemory>& dataPtr); 129 130 private: 131 132 status_t createPreviewSurface(unsigned int width, 133 unsigned int height, 134 int32_t pixFormat); 135 status_t destroyPreviewSurface(); 136 137 status_t saveFile(const sp<IMemory>& mem, String8 path); 138 SkBitmap * PiPCopyToOneFile(SkBitmap *bitmap0, SkBitmap *bitmap1); 139 SkBitmap *decodeJPEG(const sp<IMemory>& mem); 140 status_t encodeJPEG(SkWStream * stream, const SkBitmap *bitmap, 141 String8 path); 142 void previewCallback(const sp<IMemory>& mem); 143 144 static int JpegIdx; 145 int mCameraIndex; 146 bool mResizePreview; 147 bool mHardwareActive; 148 bool mPreviewRunning; 149 bool mRecordRunning; 150 int mVideoFd; 151 int mVideoIdx; 152 bool mRecordingHint; 153 bool mDoPrintMenu; 154 bool mPiPCapture; 155 static int mPiPIdx; 156 int mfmtMultiplier; 157 int mWidthTmp[2]; 158 int mHeightTmp[2]; 159 int mSectionsRead; 160 int mSectionsAllocated; 161 Sections_t * mSections; 162 Sections_t * mJEXIFTmp; 163 Sections_t mJEXIFSection; 164 int mHaveAll; 165 TestContext *mInterpr; 166 Mutex mViVLock; 167 Condition mViVCond; 168 bool mViVinUse; 169 170 171 sp<Camera> mCamera; 172 sp<SurfaceComposerClient> mClient; 173 sp<SurfaceControl> mSurfaceControl; 174 sp<Surface> mPreviewSurface; 175 sp<MediaRecorder> mRecorder; 176 CameraParameters mParams; 177 SkBitmap *skBMDec; 178 SkImageEncoder* skJpegEnc; 179 static SkBitmap *skBMtmp[2]; 180 static sp<IMemory> PiPPtrTmp[2]; 181 182 int mCurrentPreviewSizeIdx; 183 Size getPreviewSizeFromVideoSizes(Size currentVideoSize); 184 int mCurrentPictureSizeIdx; 185 int mCurrentVideoSizeIdx; 186 Vector<Size> mSupportedPreviewSizes; 187 Vector<Size> mSupportedPictureSizes; 188 Vector<Size> mSupportedVideoSizes; 189 190 bool mInUse; 191 Mutex mLock; 192 Condition mCond; 193 194 void useLock(); 195 void signalFinished(); 196 void mutexLock(); 197 void mutexUnlock(); 198 199 //------------------------------------------------------------------------ 200 // JPEG markers consist of one or more 0xFF bytes, followed by a marker 201 // code byte (which is not an FF). Here are the marker codes of interest 202 // in this program. (See jdmarker.c for a more complete list.) 203 //------------------------------------------------------------------------ 204 #define M_SOF0 0xC0 // Start Of Frame N 205 #define M_SOF1 0xC1 // N indicates which compression process 206 #define M_SOF2 0xC2 // Only SOF0-SOF2 are now in common use 207 #define M_SOF3 0xC3 208 #define M_SOF5 0xC5 // NB: codes C4 and CC are NOT SOF markers 209 #define M_SOF6 0xC6 210 #define M_SOF7 0xC7 211 #define M_SOF9 0xC9 212 #define M_SOF10 0xCA 213 #define M_SOF11 0xCB 214 #define M_SOF13 0xCD 215 #define M_SOF14 0xCE 216 #define M_SOF15 0xCF 217 #define M_SOI 0xD8 // Start Of Image (beginning of datastream) 218 #define M_EOI 0xD9 // End Of Image (end of datastream) 219 #define M_SOS 0xDA // Start Of Scan (begins compressed data) 220 #define M_JFIF 0xE0 // Jfif marker 221 #define M_EXIF 0xE1 // Exif marker. Also used for XMP data! 222 #define M_XMP 0x10E1 // Not a real tag same value as Exif! 223 #define M_COM 0xFE // COMment 224 #define M_DQT 0xDB 225 #define M_DHT 0xC4 226 #define M_DRI 0xDD 227 #define M_IPTC 0xED // IPTC marker 228 #define PSEUDO_IMAGE_MARKER 0x123; // Extra value. 229 }; 230 231 class Interpreter 232 { 233 public: 234 enum Commands_e { 235 SWITCH_CAMERA_CMD = 'A', 236 RESUME_PREVIEW_CMD = '[', 237 START_PREVIEW_CMD = '1', 238 STOP_PREVIEW_CMD = '2', 239 CHANGE_VIDEO_SIZE_CMD = '3', 240 CHANGE_PREVIEW_SIZE_CMD = '4', 241 CHANGE_PICTURE_SIZE_CMD = '5', 242 START_RECORD_CMD = '6', 243 STOP_RECORD_CMD = '7', 244 START_VIV_RECORD_CMD = '8', 245 STOP_VIV_RECORD_CMD = '9', 246 DUMP_CAPS_CMD = 'E', 247 AUTOFOCUS_CMD = 'f', 248 TAKEPICTURE_CMD = 'p', 249 TAKEPICTURE_IN_PICTURE_CMD = 'P', 250 ENABLE_PRV_CALLBACKS_CMD = '&', 251 EXIT_CMD = 'q', 252 DELAY = 'd', 253 INVALID_CMD = '0' 254 }; 255 256 struct Command { 257 Command( Commands_e cmd, char *arg = NULL) cmdCommand258 : cmd(cmd) 259 , arg(arg) {} CommandCommand260 Command() 261 : cmd(INVALID_CMD) 262 , arg(NULL) {} 263 Commands_e cmd; 264 char *arg; 265 }; 266 267 /* API */ Interpreter()268 Interpreter() 269 : mUseScript(false) 270 , mScript(NULL) {} 271 272 Interpreter(const char *file); 273 ~Interpreter(); 274 275 Command getCommand(sp<CameraContext> currentCamera); 276 void releasePiPBuff(); 277 status_t configureViVCodec(); 278 //status_t configureViVCodec(); 279 void setViVSize(Size VideoSize, int camIndex); 280 void setTestCtxInst(TestContext *instance); 281 status_t unconfigureViVCodec(); 282 status_t ViVEncoderThread(); 283 void ViVEncode(); 284 static void *ThreadWrapper(void *context); 285 286 private: 287 static const int numberOfCommands; 288 289 bool mUseScript; 290 int mCmdIndex; 291 char *mScript; 292 Vector<Command> mCommands; 293 TestContext *mTestContext; 294 pthread_t mViVEncThread; 295 }; 296 297 class TestContext 298 { 299 friend class CameraContext; 300 friend class Interpreter; 301 public: 302 TestContext(); 303 ~TestContext(); 304 305 int32_t GetCamerasNum(); 306 status_t FunctionalTest(); 307 status_t AddScriptFromFile(const char *scriptFile); 308 void setViVSize(Size VideoSize, int camIndex); 309 310 private: 311 char GetNextCmd(sp<qcamera::CameraContext> currentCamera); 312 int mCurrentCameraIndex; 313 int mSaveCurrentCameraIndex; 314 Vector< sp<qcamera::CameraContext> > mAvailableCameras; 315 bool mTestRunning; 316 Interpreter *mInterpreter; 317 318 typedef struct ViVBuff_t{ 319 void *buff; 320 size_t buffSize; 321 size_t YStride; 322 size_t UVStride; 323 size_t YScanLines; 324 size_t UVScanLines; 325 size_t srcWidth; 326 size_t srcHeight; 327 } ViVBuff_t; 328 329 typedef struct ViVVid_t{ 330 sp<IGraphicBufferProducer> bufferProducer; 331 sp<Surface> surface; 332 sp<MediaCodec> codec; 333 sp<MediaMuxer> muxer; 334 sp<ANativeWindow> ANW; 335 Vector<sp<ABuffer> > buffers; 336 Size VideoSizes[2]; 337 int ViVIdx; 338 size_t buff_cnt; 339 sp<GraphicBuffer> graphBuf; 340 void * mappedBuff; 341 bool isBuffValid; 342 int sourceCameraID; 343 int destinationCameraID; 344 } vidPiP_t; 345 346 ViVVid_t mViVVid; 347 ViVBuff_t mViVBuff; 348 }; 349 350 }; //namespace qcamera 351 352 #endif 353