camera.h

Go to the documentation of this file.

#pragma once
#include <wut.h>
#include <coreinit/thread.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define CAMERA_WIDTH 640
#define CAMERA_PITCH 768
#define CAMERA_HEIGHT 480
 
#define CAMERA_Y_BUFFER_SIZE  (CAMERA_PITCH * CAMERA_HEIGHT)
#define CAMERA_UV_BUFFER_SIZE (CAMERA_PITCH * CAMERA_HEIGHT / 2)
#define CAMERA_YUV_BUFFER_SIZE (CAMERA_Y_BUFFER_SIZE + CAMERA_UV_BUFFER_SIZE)
 
#define CAMERA_YUV_BUFFER_ALIGNMENT 256
 
typedef int CAMHandle;
typedef int CAMError;
 
typedef struct CAMEventData CAMEventData;
typedef struct CAMMode CAMMode;
typedef struct CAMWorkMem CAMWorkMem;
typedef struct CAMStreamInfo CAMStreamInfo;
typedef struct CAMSetupInfo CAMSetupInfo;
typedef struct CAMSurface CAMSurface;
 
typedef enum CamError
{
   CAMERA_ERROR_OK                     =  0,
   CAMERA_ERROR_INVALID_ARG            = -1,
   CAMERA_ERROR_INVALID_HANDLE         = -2,
   CAMERA_ERROR_TOO_MANY_SURFACES      = -4,
   CAMERA_ERROR_INSUFFICIENT_MEMORY    = -5,
   CAMERA_ERROR_NOT_READY              = -6,
   CAMERA_ERROR_UNINITIALIZED          = -8,
   CAMERA_ERROR_UVC                    = -9,
   CAMERA_ERROR_UVD_CONTEXT            = -10,
   CAMERA_ERROR_DEVICE_IN_USE          = -12,
   CAMERA_ERROR_UVD_SESSION            = -13,
   CAMERA_ERROR_SEGMENT_VIOLATION      = -15
} CamError;
 
typedef enum CamFps
{
   CAMERA_FPS_15   = 0,
   CAMERA_FPS_30   = 1
} CamFps;
 
typedef enum CamStreamType
{
   CAMERA_STREAM_TYPE_1   = 0
} CamStreamType;
 
typedef enum CamEventType
{
   CAMERA_DECODE_DONE   = 0,
   CAMERA_DRC_DETACH    = 1
} CamEventType;
 
struct CAMEventData
{
   CamEventType eventType;
   union
   {
      struct
      {
         void* surfaceBuffer;
         CAMHandle handle;
         BOOL failed;
      } decode;
      struct
      {
         BOOL connected;
         CAMHandle handle;
      } detach;
      uint32_t args[3];
   };
};
WUT_CHECK_OFFSET(CAMEventData, 0x00, eventType);
WUT_CHECK_OFFSET(CAMEventData, 0x04, decode.surfaceBuffer);
WUT_CHECK_OFFSET(CAMEventData, 0x08, decode.handle);
WUT_CHECK_OFFSET(CAMEventData, 0x0c, decode.failed);
WUT_CHECK_OFFSET(CAMEventData, 0x04, detach.connected);
WUT_CHECK_OFFSET(CAMEventData, 0x08, detach.handle);
WUT_CHECK_OFFSET(CAMEventData, 0x04, args);
WUT_CHECK_SIZE(CAMEventData, 0x10);
 
typedef void(*CAMEventHandler)(CAMEventData *camEventData);
 
struct CAMMode
{
   BOOL forceDrc;
   CamFps fps;
};
WUT_CHECK_OFFSET(CAMMode, 0x00, forceDrc);
WUT_CHECK_OFFSET(CAMMode, 0x04, fps);
WUT_CHECK_SIZE(CAMMode, 0x08);
 
struct CAMWorkMem
{
   uint32_t size;
   void *pMem;
};
WUT_CHECK_OFFSET(CAMWorkMem, 0x00, size);
WUT_CHECK_OFFSET(CAMWorkMem, 0x04, pMem);
WUT_CHECK_SIZE(CAMWorkMem, 0x08);
 
struct CAMStreamInfo
{
   CamStreamType type;
   uint32_t height;
   uint32_t width;
};
WUT_CHECK_OFFSET(CAMStreamInfo, 0x00, type);
WUT_CHECK_OFFSET(CAMStreamInfo, 0x04, height);
WUT_CHECK_OFFSET(CAMStreamInfo, 0x08, width);
WUT_CHECK_SIZE(CAMStreamInfo, 0x0C);
 
struct CAMSetupInfo
{
   CAMStreamInfo streamInfo;
   CAMWorkMem workMem;
   CAMEventHandler eventHandler;
   CAMMode mode;
   uint32_t threadAffinity;
   WUT_PADDING_BYTES(0x10);
};
WUT_CHECK_OFFSET(CAMSetupInfo, 0x00, streamInfo);
WUT_CHECK_OFFSET(CAMSetupInfo, 0x0C, workMem);
WUT_CHECK_OFFSET(CAMSetupInfo, 0x14, eventHandler);
WUT_CHECK_OFFSET(CAMSetupInfo, 0x18, mode);
WUT_CHECK_OFFSET(CAMSetupInfo, 0x20, threadAffinity);
WUT_CHECK_SIZE(CAMSetupInfo, 0x34);
 
struct CAMSurface
{
   int32_t surfaceSize;
   void *surfaceBuffer;
   int32_t height;
   int32_t width;
   int32_t pitch;
   int32_t alignment;
   int32_t tileMode;
   int32_t pixelFormat;
};
WUT_CHECK_OFFSET(CAMSurface, 0x00, surfaceSize);
WUT_CHECK_OFFSET(CAMSurface, 0x04, surfaceBuffer);
WUT_CHECK_OFFSET(CAMSurface, 0x08, height);
WUT_CHECK_OFFSET(CAMSurface, 0x0C, width);
WUT_CHECK_OFFSET(CAMSurface, 0x10, pitch);
WUT_CHECK_OFFSET(CAMSurface, 0x14, alignment);
WUT_CHECK_OFFSET(CAMSurface, 0x18, tileMode);
WUT_CHECK_OFFSET(CAMSurface, 0x1C, pixelFormat);
WUT_CHECK_SIZE(CAMSurface, 0x20);
 
CAMHandle 
CAMInit(int instance, CAMSetupInfo *setupInfo, CAMError *err);
 
void 
CAMExit(CAMHandle handle);
 
CAMError 
CAMOpen(CAMHandle handle);
 
CAMError 
CAMClose(CAMHandle handle);
 
int32_t
CAMGetMemReq(CAMStreamInfo *streamInfo);
 
CAMError 
CAMSubmitTargetSurface(CAMHandle handle, CAMSurface *surface);
 
CAMError 
CAMCheckMemSegmentation(void *pMem, uint32_t size);
 
#ifdef __cplusplus
}
#endif