/*---------------------------------------------------------------------------*

  Copyright (C) Nintendo.  All rights reserved.

  These coded instructions, statements, and computer programs contain
  proprietary information of Nintendo of America Inc. and/or Nintendo
  Company Ltd., and are protected by Federal copyright law.  They may
  not be disclosed to third parties or copied or duplicated in any form,
  in whole or in part, without the prior written consent of Nintendo.

 *---------------------------------------------------------------------------*/
////============================================================================
///  DEMODRCCamera.c
///
///     This is DRC Camera system code for the DEMO library.
///
////============================================================================

#include <cafe/demo.h>
#include <cafe/gx2.h>
#include <cafe/camera/camera.h>

// Camera related members
CAMSurface       DEMODRCCameraSurface[2];
GX2Texture       DEMODRCCameraYTexture;
GX2Texture       DEMODRCCameraUVTexture;

CAMSetupInfo     DEMODRCCameraSetupInfo;
CAMHandle        DEMOCameraHandle;

#define DEMO_CAM_MAX_ALLOC_ATTEMPTS (10) 

void* DEMODRCCameraMemAlloc(int size, int alignment)
{
    void *pMemTemp[DEMO_CAM_MAX_ALLOC_ATTEMPTS] = {0};
    void *pMem = NULL;
    s32 err;
    u32 i;

    if (size == 0) return 0;

    for (i=0; i<DEMO_CAM_MAX_ALLOC_ATTEMPTS; i++) 
    { 
        pMem = DEMOAllocEx(size, alignment);

        if (!pMem)
        {
            OSReport("DEMODRCCameraAlloc: Memory Allocation failed\n");
            break;
        }   

        err = CAMCheckMemSegmentation((void *)pMem, size);
        if (err!=CAMERA_ERROR_NONE)
        {
            if (err != CAMERA_ERROR_SEGMENT_VIOLATION)
            {
                OSReport("DEMODRCCameraAlloc: unknown error\n");
                break;  //logically we should never get here
            }
            else
            {
                pMemTemp[i] = pMem;
            }
        }
        else  //CAMCheckMemSegmentation succeeded
        {
           break;
        }
    }
    
    for(i=0; i < DEMO_CAM_MAX_ALLOC_ATTEMPTS; i++)
    {
        if(pMemTemp[i])
        {
            MEMFreeToDefaultHeap(pMemTemp[i]);
            pMemTemp[i] = 0;
        }
    }

    return pMem;
} 


void DEMODRCCameraInit(DRC_CAMERA_FPS fps)
{
    s32              total_size;
    s32              err;
    s32              *pErr = &err;
    const u32        BUFFER_ALIGNMENT = 256;

    // Set up another linear L8 texture
    GX2InitTexture(&DEMODRCCameraYTexture,
                   CAMERA_STREAM_WIDTH,  // width
                   CAMERA_STREAM_HEIGHT,  // height
                   1,      // depth
                   1,      // num mips
                   GX2_SURFACE_FORMAT_TC_R8_UNORM,
                   GX2_SURFACE_DIM_2D);
    DEMODRCCameraYTexture.surface.tileMode = GX2_TILE_MODE_LINEAR_ALIGNED;
    // Recalculate, reinit due to tileMode change
    GX2CalcSurfaceSizeAndAlignment(&DEMODRCCameraYTexture.surface);
    GX2InitTextureRegs(&DEMODRCCameraYTexture);

    // Set up another linear UV8 texture
    GX2InitTexture(&DEMODRCCameraUVTexture,
                   CAMERA_STREAM_WIDTH/2,  // width
                   CAMERA_STREAM_HEIGHT/2,  // height
                   1,      // depth
                   1,      // num mips
                   GX2_SURFACE_FORMAT_TC_R8_G8_UNORM,
                   GX2_SURFACE_DIM_2D);
    DEMODRCCameraUVTexture.surface.tileMode = GX2_TILE_MODE_LINEAR_ALIGNED;
    // Recalculate, reinit due to tileMode change
    GX2CalcSurfaceSizeAndAlignment(&DEMODRCCameraUVTexture.surface);
    GX2InitTextureRegs(&DEMODRCCameraUVTexture);

    DEMODRCCameraSurface[0].imagePtr =
        DEMODRCCameraMemAlloc(CAMERA_YUV_BUFFER_SIZE,
                                  CAMERA_YUV_BUFFER_ALIGNMENT);
    ASSERT(NULL != DEMODRCCameraSurface[0].imagePtr  && "Unable to allocate memory");
    DEMODRCCameraSurface[0].imageSize = CAMERA_YUV_BUFFER_SIZE;
    DEMODRCCameraSurface[0].alignment = CAMERA_YUV_BUFFER_ALIGNMENT;

    DEMODRCCameraSurface[1].imagePtr =
        DEMODRCCameraMemAlloc(CAMERA_YUV_BUFFER_SIZE,
                                  CAMERA_YUV_BUFFER_ALIGNMENT);
    ASSERT(NULL != DEMODRCCameraSurface[1].imagePtr  && "Unable to allocate memory");
    DEMODRCCameraSurface[1].imageSize = CAMERA_YUV_BUFFER_SIZE;
    DEMODRCCameraSurface[1].alignment = CAMERA_YUV_BUFFER_ALIGNMENT;

    DEMODRCCameraSetupInfo.StreamInfo.type   = CAMERA_STREAM_VIDEO;
    DEMODRCCameraSetupInfo.StreamInfo.width  = CAMERA_STREAM_WIDTH;
    DEMODRCCameraSetupInfo.StreamInfo.height = CAMERA_STREAM_HEIGHT;

    DEMODRCCameraSetupInfo.mode.display = DRC_CAMERA_DOWNSTREAM;
    DEMODRCCameraSetupInfo.mode.fps = fps;

    total_size = CAMGetMemReq(&DEMODRCCameraSetupInfo.StreamInfo);

    DEMODRCCameraSetupInfo.WorkMem.pMem =
        DEMODRCCameraMemAlloc(total_size, BUFFER_ALIGNMENT);
    DEMODRCCameraSetupInfo.WorkMem.size = total_size;
    ASSERT(NULL != DEMODRCCameraSetupInfo.WorkMem.pMem);

    DEMODRCCameraSetupInfo.ThreadAffinity = CAM_THREAD_ATTR_AFFINITY_CORE1;  //Core 1

    DEMOCameraHandle = CAMInit(CAMERA_INSTANCE_0, &DEMODRCCameraSetupInfo, pErr);
    if (DEMOCameraHandle < 0)
    {
        OSReport("Error: CAMInit returned %d\n", err);
        ASSERT(!"CAMInit returned bad handle");
    }
}

void DEMODRCCameraShutdown()
{
    CAMExit(DEMOCameraHandle);
    DEMOFree(DEMODRCCameraSurface[0].imagePtr);
    DEMOFree(DEMODRCCameraSurface[1].imagePtr);
    DEMOFree(DEMODRCCameraSetupInfo.WorkMem.pMem);
}

void DEMODRCCameraOpen()
{
    s32             err;

    err = CAMOpen(DEMOCameraHandle);
    if(err != CAMERA_ERROR_NONE)
    {
        if(err != CAMERA_ERROR_DEVICE_IN_USE)
            OSReport("Error: CAMOpen returned %d\n", err);
    }
}

void DEMODRCCameraClose()
{
    s32             err;
    err = CAMClose(DEMOCameraHandle);
    if(err != CAMERA_ERROR_NONE)
    {
        if(err != CAMERA_ERROR_UNIINITIALIZED)
            OSReport("CAMClose returned %d\n", err);
    }
}