libs/rt-thread
libs
/
rt-thread
4
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
rt-thread/bsp/nuvoton/libraries/n9h30/rtt_port/drv_jpegcodec.c

1413 lines
42 KiB
C
Raw Normal View History

Update N9H30 porting.
2021-05-12 19:15:17 +08:00
/**************************************************************************//**
*
* @copyright (C) 2020 Nuvoton Technology Corp. All rights reserved.
*
* SPDX-License-Identifier: Apache-2.0
*
* Change Logs:
* Date Author Notes
* 2021-4-16 Wayne First version
*
******************************************************************************/
#include "rtthread.h"
#include "NuMicro.h"
#include "nu_jpeg.h"
#include "drv_sys.h"
struct nu_jpeg
{
struct rt_device dev;
char *name;
IRQn_Type irqn;
E_SYS_IPRST rstidx;
E_SYS_IPCLK clkidx;
struct rt_mutex lock;
};
typedef struct nu_jpeg *nu_jpeg_t;
static BOOL volatile g_bWait = FALSE, g_jpegError = FALSE, g_bScale = FALSE, g_OutputWait = FALSE, g_InputWait = FALSE, g_u32WindowDec = FALSE, g_bEncThumbnailDownScale = FALSE, g_bEncPrimaryDownScale = FALSE;
static UINT32 volatile g_u32Stride, g_u32ScaleWidth, g_u32ScaleHeight, g_u32OpMode, g_u32EncRotate = 0;
static UINT32 volatile g_u32BufferCount, g_u32DecInputWaitAddr;
static UINT16 volatile g_u16BufferSize, g_u16ReserveSize;
static UINT32 volatile g_u32OutputFormat, g_u32windowSizeX, g_u32windowSizeY;
static PFN_JPEG_CALLBACK pfnJpegDecodeComplete = NULL;
static PFN_JPEG_CALLBACK pfnJpegDecodeError = NULL;
static PFN_JPEG_CALLBACK pfnJpegEncodeComplete = NULL;
static PFN_JPEG_HEADERDECODE_CALLBACK pfnJpegHeaderDecode = NULL;
static PFN_JPEG_DECWAIT_CALLBACK pfnJpegDecInputWait = NULL;
static PFN_JPEG_DECWAIT_CALLBACK pfnJpegDecOutputWait = NULL;
static JPEG_INFO_T jpegInfo;
/* Default Quantization-Table 0 ~ 2 */
static UINT8 g_au8QTable0[64] = { 0x06, 0x04, 0x04, 0x05, 0x04, 0x04, 0x06, 0x05,
0x05, 0x05, 0x06, 0x06, 0x06, 0x07, 0x08, 0x0E,
0x09, 0x08, 0x08, 0x08, 0x08, 0x11, 0x0C, 0x0D,
0x0A, 0x0E, 0x14, 0x11, 0x15, 0x14, 0x13, 0x11,
0x13, 0x13, 0x16, 0x18, 0x1F, 0x1A, 0x16, 0x17,
0x1D, 0x17, 0x13, 0x13, 0x1B, 0x25, 0x1B, 0x1D,
0x20, 0x21, 0x23, 0x23, 0x23, 0x15, 0x1A, 0x26,
0x29, 0x26, 0x22, 0x28, 0x1F, 0x22, 0x23, 0x21
},
g_au8QTable1[64] = { 0x06, 0x06, 0x06, 0x08, 0x07, 0x08, 0x10, 0x09,
0x09, 0x10, 0x21, 0x16, 0x13, 0x16, 0x21, 0x21,
0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21,
0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21,
0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21,
0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21,
0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21,
0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21
};
static struct nu_jpeg g_sNuJpeg =
{
.name = "jpegcodec",
.irqn = JPEG_IRQn,
.rstidx = JPEGRST,
.clkidx = JPEGCKEN
};
/* Interrupt Service Routine for H/W JPEG CODEC */
static void nu_jpeg_isr(int vector, void *param)
{
UINT32 u32interruptStatus;
/* Get the interrupt status */
u32interruptStatus = JPEG_GET_INT_STATUS();
/* It's Header Decode Complete Interrupt */
if (u32interruptStatus & DHE_INTS)
{
UINT32 u32YuvFormat;
UINT16 u16Height, u16Width, UVHeight, UVWidth;
UINT16 u16WidthTmp, u16HeightTmp;
/* Get the JPEG format */
u32YuvFormat = JPEG_DEC_GET_DECODED_IMAGE_FORMAT();
/* Get the decoded image dimension */
jpegGetDecodedDimension(&u16Height, &u16Width);
jpegInfo.jpeg_width = u16Width;
jpegInfo.jpeg_height = u16Height;
jpegInfo.yuvformat = u32YuvFormat;
if (pfnJpegHeaderDecode != NULL)
{
if (!pfnJpegHeaderDecode())
{
jpegInit();
g_bWait = FALSE;
return;
}
}
if (g_bScale)
{
UINT16 u16RatioH, u16RatioW;
if (jpegCalScalingFactor(
g_u32OpMode, //Up / Down Scaling
u16Height, //Original Height
u16Width, //Original Width
g_u32ScaleHeight, //Scaled Height
g_u32ScaleWidth, //Scaled Width
&u16RatioH, //Horizontal Ratio
&u16RatioW //Vertical Ratio
) != E_SUCCESS)
{
g_bWait = FALSE;
g_jpegError = TRUE;
}
else
{
jpegSetScalingFactor(g_u32OpMode, u16RatioH, u16RatioW);
u16Width = g_u32ScaleWidth;
u16Height = g_u32ScaleHeight;
}
}
else
{
if (u32YuvFormat == JPEG_DEC_YUV411)
{
/* 32-pixel alignment for YUV411 raw data */
if (u16Width % 32)
u16Width = (u16Width & 0xFFFFFFE0) + 32;
}
else if ((u32YuvFormat == JPEG_DEC_YUV444) || (u32YuvFormat == JPEG_DEC_YUV422T))
{
/* 8-pixel alignment for YUV444 raw data */
if (u16Width % 8)
u16Width = (u16Width & 0xFFFFFFF8) + 8;
}
else
{
/* 16-pixel alignment for YUV422 or YUV420 raw data */
if (u16Width % 16)
u16Width = (u16Width & 0xFFFFFFF0) + 16;
}
}
if (g_u32Stride >= u16Width)
{
jpegInfo.stride = g_u32Stride;
g_u32Stride = g_u32Stride - u16Width;
JPEG_SET_YSTRIDE(g_u32Stride);
u16Width = jpegInfo.stride;
}
else
{
g_u32Stride = 0;
JPEG_SET_YSTRIDE(0);
jpegInfo.stride = 0;
}
if (g_u32OutputFormat == JPEG_DEC_PRIMARY_PLANAR_YUV || g_u32OutputFormat == JPEG_DEC_THUMBNAIL_PLANAR_YUV)
{
if (g_u32WindowDec)
{
u16WidthTmp = u16Width;
u16HeightTmp = u16Height;
u16Width = g_u32windowSizeX;
u16Height = g_u32windowSizeY;
}
if (u32YuvFormat == JPEG_DEC_YUV411)
{
/* For YUV411 raw data */
UVWidth = u16Width / 4;
}
else if ((u32YuvFormat == JPEG_DEC_YUV444) || (u32YuvFormat == JPEG_DEC_YUV422T))
{
/* For YUV444 raw data */
UVWidth = u16Width;
}
/* Set the U-component and V-componente width for YUV422 or YUV420 raw data */
else if (u16Width % 2)
UVWidth = u16Width / 2 + 1;
else
UVWidth = u16Width / 2;
/* Sets the height of U and V for YUV420 image */
if (u32YuvFormat == JPEG_DEC_YUV420)
{
/* 16-pixel alignment for YUV422 or YUV420 raw data */
if (u16Height % 16)
u16Height = (u16Height & 0xFFFFFFF0) + 16;
UVHeight = u16Height / 2;
}
else if (u32YuvFormat == JPEG_DEC_YUV422)
{
/* 8-pixel alignment for YUV444 raw data */
if (u16Height % 8)
u16Height = (u16Height & 0xFFFFFFF8) + 8;
UVHeight = u16Height;
}
else if (u32YuvFormat == JPEG_DEC_YUV444)
{
/* 8-pixel alignment for YUV444 raw data */
if (u16Height % 8)
u16Height = (u16Height & 0xFFFFFFF8) + 8;
UVHeight = u16Height;
}
else if (u32YuvFormat == JPEG_DEC_YUV411)
{
/* 8-pixel alignment for YUV411 raw data */
if (u16Height % 8)
u16Height = (u16Height & 0xFFFFFFF8) + 8;
UVHeight = u16Height;
}
else if (u32YuvFormat == JPEG_DEC_YUV422T)
{
/* 16-pixel alignment for YUV422 or YUV420 raw data */
if (u16Height % 16)
u16Height = (u16Height & 0xFFFFFFF0) + 16;
UVHeight = u16Height / 2;
}
else
{
/* 8-pixel alignment for raw data */
if (u16Height % 8)
u16Height = (u16Height & 0xFFFFFFF8) + 8;
UVHeight = u16Height;
}
JPEG_SET_UADDR(JPEG_GET_YADDR() + u16Width * u16Height);
JPEG_SET_VADDR(JPEG_GET_UADDR() + UVWidth * UVHeight);
if (u32YuvFormat == JPEG_DEC_GRAY)
jpegInfo.image_size[0] = u16Width * u16Height;
else
jpegInfo.image_size[0] = u16Width * u16Height + 2 * UVWidth * UVHeight;
if (g_u32WindowDec)
{
u16Width = u16WidthTmp;
u16Height = u16HeightTmp;
}
}
else
{
if (g_u32WindowDec)
{
u16WidthTmp = u16Width;
u16HeightTmp = u16Height;
u16Width = g_u32windowSizeX;
u16Height = g_u32windowSizeY;
}
if (jpegInfo.stride)
jpegInfo.image_size[0] = jpegInfo.stride * u16Height;
else
jpegInfo.image_size[0] = u16Width * u16Height;
if (g_u32OutputFormat == JPEG_DEC_PRIMARY_PACKET_RGB888)
jpegInfo.image_size[0] = 4 * jpegInfo.image_size[0];
else
jpegInfo.image_size[0] = 2 * jpegInfo.image_size[0];
if (g_u32WindowDec)
{
u16Width = u16WidthTmp;
u16Height = u16HeightTmp;
}
}
/* Set the image dimension */
jpegSetDimension(u16Height, u16Width);
outp32(JITCR, inp32(JITCR) | Dec_Scatter_Gather);
/* Clear interrupt status */
JPEG_CLEAR_INT(DHE_INTS);
}
/* It's Decode Output Wait Interrupt */
else if (u32interruptStatus & JPG_DOW_INTS)
{
if (pfnJpegDecOutputWait != NULL)
{
pfnJpegDecOutputWait(inp32(JYADDR0), inp32(JDOWFBS));
}
JPEG_CLEAR_INT(JPG_DOW_INTS);
outp32(JITCR, inp32(JITCR) | Dec_Scatter_Gather);
}
/* It's Encode Complete Interrupt */
else if (u32interruptStatus & ENC_INTS)
{
/* Get the Encode Bit stream length */
jpegInfo.image_size[0] = JPEG_GET_ENC_PRIMARY_BITSTREAM_SIZE();
jpegInfo.image_size[1] = JPEG_GET_ENC_THUMBNAIL_BITSTREAM_SIZE();
/* Clear interrupt status */
JPEG_CLEAR_INT(ENC_INTS);
g_bWait = FALSE;
if (pfnJpegEncodeComplete != NULL)
pfnJpegEncodeComplete();
}
/* It's Decode Complete Interrupt */
else if (u32interruptStatus & DEC_INTS)
{
UINT16 imageWidth, imageHeight;
/* Get the image dimension */
jpegGetDimension(&imageHeight, &imageWidth);
if (g_u32Stride != 0)
{
imageWidth = imageWidth - g_u32Stride;
}
jpegInfo.width = imageWidth;
jpegInfo.height = imageHeight;
/* Clear interrupt status */
JPEG_CLEAR_INT(DEC_INTS);
JPEG_CLEAR_INT(JPG_DOW_INTS);
g_bWait = FALSE;
if (pfnJpegDecodeComplete != NULL)
pfnJpegDecodeComplete();
}
/* It's Decode Error Interrupt */
else if (u32interruptStatus & DER_INTS)
{
/* Clear interrupt status */
JPEG_CLEAR_INT(DER_INTS);
g_bWait = FALSE;
g_jpegError = TRUE;
if (pfnJpegDecodeError != NULL)
pfnJpegDecodeError();
}
else if (u32interruptStatus & IPW_INTS)
{
/* Clear interrupt status */
JPEG_CLEAR_INT(IPW_INTS);
JPEG_DEC_RESUME_INPUT_WAIT();
if (pfnJpegDecInputWait != NULL)
{
if (!pfnJpegDecInputWait((g_u32DecInputWaitAddr + (g_u32BufferCount % 2) * g_u16BufferSize), g_u16BufferSize))
{
jpegInit();
g_bWait = FALSE;
return;
}
g_u32BufferCount++;
}
else
while (1);
}
}
static INT jpegAdjustQTAB(UINT8 u8Mode, UINT8 u8Qadjust, UINT8 u8Qscaling)
{
UINT32 u32Addr;
if (u8Mode == JPEG_ENC_PRIMARY)
u32Addr = REG_JPRIQC;
else if (u8Mode == JPEG_ENC_THUMBNAIL)
u32Addr = REG_JTHBQC;
else
return E_JPEG_INVALID_PARAM;
outp32(u32Addr, ((u8Qadjust & 0xF) << 4) | (u8Qscaling & 0xF));
return E_SUCCESS;
}
#if 0
//Poll the interrupt status and get if the interrupt is generated
static BOOL jpegPollInt(UINT32 u32Intflag)
{
if (JPEG_GET_INT_STATUS() & u32Intflag)
return 1;
else
return 0;
}
static UINT32 jpegPower(UINT32 u32Index, UINT32 u32Exp)
{
if (u32Exp == 0)
return 1;
else
{
UINT32 u32Idx;
for (u32Idx = 1; u32Idx < u32Exp; u32Idx = u32Idx + 1)
{
u32Index = 2 * u32Index;
}
}
return u32Index;
}
static VOID jpegGetScalingFactor(
UINT8 u8Mode, //Up / Down Scaling
PUINT16 pu16FactorH, //Vertical Scaling Factor
PUINT16 pu16FactorW //Horizontal Scaling Factor
)
{
if (u8Mode == JPEG_DEC_PLANAR_DOWNSCALE_MODE)
{
*pu16FactorH = inp32(REG_JPSCALD) & 0x3F;
*pu16FactorW = (inp32(REG_JPSCALD) >> 8) & 0x1F;
}
else
{
*pu16FactorH = (inp32(REG_JUPRAT) >> 16) & 0x3FFF;
*pu16FactorW = inp32(REG_JUPRAT) & 0x3FFF;
}
}
#endif
static INT jpegSetEncodeMode(UINT8 u8SourceFormat, UINT16 u16JpegFormat)
{
UINT8 u8Gray = 0;
switch (u16JpegFormat)
{
case JPEG_ENC_PRIMARY_YUV420:
case JPEG_ENC_PRIMARY_YUV422:
case JPEG_ENC_THUMBNAIL_YUV420:
case JPEG_ENC_THUMBNAIL_YUV422:
case (JPEG_ENC_PRIMARY_YUV420 | JPEG_ENC_THUMBNAIL_YUV420):
case (JPEG_ENC_PRIMARY_YUV422 | JPEG_ENC_THUMBNAIL_YUV422):
outp32(REG_JMCR, (inp32(REG_JMCR) & WIN_DEC) | u16JpegFormat);
u8Gray = 0;
break;
case JPEG_ENC_PRIMARY_GRAY:
case JPEG_ENC_THUMBNAIL_GRAY:
case (JPEG_ENC_PRIMARY_GRAY | JPEG_ENC_THUMBNAIL_GRAY):
if (u8SourceFormat == JPEG_ENC_SOURCE_PACKET)
return E_JPEG_INVALID_PARAM;
else
{
if (u16JpegFormat == (JPEG_ENC_PRIMARY_GRAY | JPEG_ENC_THUMBNAIL_GRAY))
outp32(REG_JMCR, 0xB0);
else
outp32(REG_JMCR, 0xA0);
}
u8Gray = EY_ONLY;
break;
default:
return E_JPEG_INVALID_PARAM;
}
g_u32OpMode = JPEG_ENC_UPSCALE_MODE;
if (g_bEncPrimaryDownScale)
g_u32OpMode = JPEG_ENC_PLANAR_PRIMARY_DOWNSCALE_MODE;
if (g_bEncThumbnailDownScale)
g_u32OpMode = JPEG_ENC_PLANAR_THUMBNAIL_DOWNSCALE_MODE;
if (u8SourceFormat == JPEG_ENC_SOURCE_PLANAR)
outp32(REG_JITCR, (inp32(REG_JITCR) & (0x8 | ROTATE)) | PLANAR_ON | u8Gray);
else if (u8SourceFormat == JPEG_ENC_SOURCE_PACKET)
outp32(REG_JITCR, inp32(REG_JITCR) & ~(PLANAR_ON | ROTATE));
else
return E_JPEG_INVALID_PARAM;
return E_SUCCESS;
}
static INT jpegSetDecodeMode(UINT32 u32OutputFormat)
{
switch (u32OutputFormat)
{
case JPEG_DEC_PRIMARY_PLANAR_YUV:
case JPEG_DEC_PRIMARY_PACKET_YUV422:
case JPEG_DEC_PRIMARY_PACKET_RGB555:
case JPEG_DEC_PRIMARY_PACKET_RGB555R1:
case JPEG_DEC_PRIMARY_PACKET_RGB555R2:
case JPEG_DEC_THUMBNAIL_PLANAR_YUV:
case JPEG_DEC_THUMBNAIL_PACKET_YUV422:
case JPEG_DEC_THUMBNAIL_PACKET_RGB555:
case JPEG_DEC_PRIMARY_PACKET_RGB565:
case JPEG_DEC_PRIMARY_PACKET_RGB565R1:
case JPEG_DEC_PRIMARY_PACKET_RGB565R2:
case JPEG_DEC_PRIMARY_PACKET_RGB888:
outp32(REG_JITCR, u32OutputFormat);
outp32(REG_JMCR, inp32(REG_JMCR) & ~ENC_DEC);
g_u32OpMode = JPEG_DEC_PACKET_DOWNSCALE_MODE;
g_u32OutputFormat = u32OutputFormat;
if (u32OutputFormat == JPEG_DEC_PRIMARY_PLANAR_YUV || u32OutputFormat == JPEG_DEC_THUMBNAIL_PLANAR_YUV)
g_u32OpMode = JPEG_DEC_PLANAR_DOWNSCALE_MODE;
break;
default:
return E_JPEG_INVALID_PARAM;
}
return E_SUCCESS;
}
static VOID jpegDecodeTrigger(void)
{
g_bWait = TRUE;
g_jpegError = FALSE;
rt_memset(&jpegInfo, 0, sizeof(jpegInfo));
/* Decode Complete /Decode Header End/Decode Error Interrupt Enable and clear the Decode Complete /Decode Header End/Decode Error Interrupt */
if (g_InputWait)
{
g_u32BufferCount = 0;
g_u32DecInputWaitAddr = JPEG_GET_BITSTREAM_ADDR();
if (g_OutputWait)
JPEG_INT_ENABLE(DEC_INTE | DER_INTE | DHE_INTE | IPW_INTE | JPG_DOW_INTE);
else
JPEG_INT_ENABLE(DEC_INTE | DER_INTE | DHE_INTE | IPW_INTE);
}
else if (g_OutputWait)
{
JPEG_INT_ENABLE(DEC_INTE | DER_INTE | DHE_INTE | JPG_DOW_INTE);
}
else
JPEG_INT_ENABLE(DEC_INTE | DER_INTE | DHE_INTE);
JPEG_CLEAR_INT(DEC_INTS | JPEG_DER_INTS | JPEG_DHE_INTS | JPEG_IPW_INTS | JPG_DOW_INTS);
outp32(REG_JMCR, JPG_EN | inp32(REG_JMCR));
outp32(REG_JMCR, ~JPG_EN & inp32(REG_JMCR));
}
static VOID jpegEncodeTrigger(void)
{
g_bWait = TRUE;
g_jpegError = FALSE;
g_u32OpMode = JPEG_ENC_UPSCALE_MODE;
if (g_bEncPrimaryDownScale)
g_u32OpMode = JPEG_ENC_PLANAR_PRIMARY_DOWNSCALE_MODE;
if (g_bEncThumbnailDownScale)
g_u32OpMode = JPEG_ENC_PLANAR_THUMBNAIL_DOWNSCALE_MODE;
rt_memset(&jpegInfo, 0, sizeof(jpegInfo));
if (g_u32EncRotate != 0)
{
UINT16 u16Height, u16Width;
if (((inp32(REG_JITCR) & (PLANAR_ON | EY_ONLY)) != (PLANAR_ON)) && ((inp32(REG_JMCR) & EY422) != 0))
{
g_jpegError = TRUE;
g_bWait = FALSE;
return;
}
jpegGetDimension(&u16Width, &u16Height);
if (g_u32EncRotate == JPEG_IOCTL_SET_ENCODE_PRIMARY_ROTATE_LEFT)
{
JPEG_SET_YADDR((JPEG_GET_YADDR() + (u16Width - 1)));
JPEG_SET_UADDR((JPEG_GET_UADDR() + (u16Width / 2 - 1)));
JPEG_SET_VADDR((JPEG_GET_VADDR() + (u16Width / 2 - 1)));
}
else
{
JPEG_SET_YADDR((JPEG_GET_YADDR() + ((u16Height - 1) * u16Width)));
u16Width = JPEG_GET_USTRIDE();
JPEG_SET_UADDR((JPEG_GET_UADDR() + ((u16Height - 2) * u16Width / 2)));
JPEG_SET_VADDR((JPEG_GET_VADDR() + ((u16Height - 2) * u16Width / 2)));
}
}
if (g_bScale)
{
UINT16 u16Height, u16Width, u16ratioH, u16ratioW;
if (g_u32EncRotate != 0)
jpegGetDimension(&u16Width, &u16Height);
else
jpegGetDimension(&u16Height, &u16Width);
if (jpegCalScalingFactor(
g_u32OpMode, //Up / Down Scaling
u16Height, //Original Height
u16Width, //Original Width
g_u32ScaleHeight, //Scaled Height
g_u32ScaleWidth, //Scaled Width
&u16ratioH, //Horizontal Ratio
&u16ratioW //Vertical Ratio
) != E_SUCCESS)
{
g_jpegError = TRUE;
g_bWait = FALSE;
return;
}
else
{
jpegSetScalingFactor(g_u32OpMode, u16ratioH, u16ratioW);
if (g_bEncThumbnailDownScale)
outp32(REG_JTHBWH, ((g_u32ScaleHeight & 0x1FFF) << 16) | (g_u32ScaleWidth & 0x1FFF));
else
{
if (g_u32EncRotate != 0)
jpegSetDimension(g_u32ScaleWidth, g_u32ScaleHeight);
else
jpegSetDimension(g_u32ScaleHeight, g_u32ScaleWidth);
}
}
}
/* Encode Complete Interrupt Enable and clear the Encode Complete Interrupt */
JPEG_INT_ENABLE(ENC_INTE);
JPEG_CLEAR_INT(ENC_INTS);
outp32(REG_JMCR, JPG_EN | inp32(REG_JMCR));
outp32(REG_JMCR, ~JPG_EN & inp32(REG_JMCR));
}
static INT jpegCalScalingFactor(
UINT8 u8Mode, //Up / Down Scaling
UINT16 u16Height, //Original Height
UINT16 u16Width, //Original Width
UINT16 u16ScalingHeight, //Scaled Height
UINT16 u16ScalingWidth, //Scaled Width
PUINT16 pu16RatioH, //Horizontal Ratio
PUINT16 pu16RatioW //Vertical Ratio
)
{
if (u8Mode == JPEG_ENC_UPSCALE_MODE)
{
if (u16ScalingHeight < u16Height || u16ScalingWidth < u16Width)
return E_JPEG_INVALID_PARAM;
*pu16RatioW = (UINT32)((float)(u16ScalingWidth - 1) / (float)(u16Width - 2) * 1024);
*pu16RatioH = (UINT32)((float)(u16ScalingHeight - 1) / (float)(u16Height - 2) * 1024);
}
else if (u8Mode == JPEG_DEC_PACKET_DOWNSCALE_MODE)
{
if (u16ScalingHeight > u16Height || u16ScalingWidth > u16Width)
return E_JPEG_INVALID_PARAM;
*pu16RatioW = (UINT32)(((float)(u16ScalingWidth) / (u16Width - 1) * 8192));
if (*pu16RatioW > 8192)
*pu16RatioW = 8192;
*pu16RatioH = (UINT32)((float)(u16ScalingHeight) / (u16Height - 1) * 8192);
if (*pu16RatioH > 8192)
*pu16RatioH = 8192;
}
else if (u8Mode == JPEG_DEC_PLANAR_DOWNSCALE_MODE || u8Mode == JPEG_ENC_PLANAR_PRIMARY_DOWNSCALE_MODE || u8Mode == JPEG_ENC_PLANAR_THUMBNAIL_DOWNSCALE_MODE)
{
UINT16 u16RatioW, u16RatioH;
if (u16ScalingHeight > u16Height || u16ScalingWidth > u16Width)
return E_JPEG_INVALID_PARAM;
if (u16Height % u16ScalingHeight)
return E_JPEG_INVALID_PARAM;
if (u16Width % u16ScalingWidth)
return E_JPEG_INVALID_PARAM;
u16RatioW = u16Width / u16ScalingWidth;
u16RatioW = u16RatioW / 2 - 1;
if ((u16RatioW != 0) && (u16RatioW != 1) && (u16RatioW != 3))
return E_JPEG_INVALID_PARAM;
u16RatioH = u16Height / u16ScalingHeight - 1;
if ((u16RatioH != 0) && (u16RatioH != 1) && (u16RatioH != 3) && (u16RatioH != 7))
return E_JPEG_INVALID_PARAM;
*pu16RatioW = u16RatioW;
*pu16RatioH = u16RatioH;
}
else
return E_JPEG_INVALID_PARAM;
return E_SUCCESS;
}
static INT jpegSetScalingFactor(
UINT8 u8Mode, //Up / Down Scaling
UINT16 u16FactorH, //Vertical Scaling Factor
UINT16 u16FactorW //Horizontal Scaling Factor
)
{
if (u8Mode == JPEG_ENC_UPSCALE_MODE)
{
JPEG_DEC_DISABLE_DOWNSCALING();
JPEG_ENC_ENABLE_UPSCALING();
}
else if (u8Mode == JPEG_DEC_PACKET_DOWNSCALE_MODE || u8Mode == JPEG_DEC_PLANAR_DOWNSCALE_MODE || u8Mode == JPEG_ENC_PLANAR_PRIMARY_DOWNSCALE_MODE)
{
JPEG_DEC_ENABLE_DOWNSCALING();
JPEG_ENC_DISABLE_UPSCALING();
}
else if (u8Mode == JPEG_ENC_PLANAR_THUMBNAIL_DOWNSCALE_MODE)
{
outp32(REG_JTSCALD, TSX_ON);
}
if (u8Mode == JPEG_DEC_PLANAR_DOWNSCALE_MODE || u8Mode == JPEG_ENC_PLANAR_PRIMARY_DOWNSCALE_MODE)
outp32(REG_JPSCALD, (inp32(REG_JPSCALD) & ~(PSCALX_F | PSCALY_F)) | ((u16FactorW & 0x1F) << 8) | (u16FactorH & 0x1F));
else if (u8Mode == JPEG_ENC_PLANAR_THUMBNAIL_DOWNSCALE_MODE)
outp32(REG_JTSCALD, (inp32(REG_JTSCALD) & ~(TSCALX_F | TSCALY_F)) | ((u16FactorW & 0x1F) << 8) | (u16FactorH & 0x1F));
else
{
outp32(REG_JPSCALD, inp32(REG_JPSCALD) & ~(PSCALX_F | PSCALY_F));
outp32(REG_JUPRAT, ((u16FactorH & 0x3FFF) << 16) | (u16FactorW & 0x3FFF));
}
return E_SUCCESS;
}
static VOID jpegGetDecodedDimension(
PUINT16 pu16Height, //Decode/Encode Height
PUINT16 pu16Width //Decode/Encode Width
)
{
*pu16Width = inp32(REG_JDECWH) & 0x0000FFFF;
*pu16Height = inp32(REG_JDECWH) >> 16;
}
static VOID jpegSetDimension(
UINT16 u16Height, //Decode/Encode Height
UINT16 u16Width //Decode/Encode Width
)
{
outp32(REG_JPRIWH, ((u16Height & 0x1FFF) << 16) | (u16Width & 0x1FFF));
}
static VOID jpegGetDimension(
PUINT16 pu16Height, //Decoded Height from bit stream
PUINT16 pu16Width //Decoded Width from bit stream
)
{
*pu16Height = inp32(REG_JPRIWH) >> 16;
*pu16Width = inp32(REG_JPRIWH) & 0x1FFF;
}
static INT jpegSetWindowDecode(
UINT16 u16StartMCUX, //Start X MCU
UINT16 u16StartMCUY, //Horizontal Scaling Factor
UINT16 u16EndMCUX, //Vertical Scaling Factor
UINT16 u16EndMCUY, //Horizontal Scaling Factor
UINT32 u32Stride //Decode Output Stride
)
{
if (u16StartMCUX >= u16EndMCUX || u16StartMCUY >= u16EndMCUY)
return E_JPEG_INVALID_PARAM;
outp32(REG_JWINDEC0, u16StartMCUY << 16 | u16StartMCUX);
outp32(REG_JWINDEC1, u16EndMCUY << 16 | u16EndMCUX);
outp32(REG_JWINDEC2, u32Stride);
outp32(REG_JMCR, WIN_DEC);
//sysprintf("\tJWINDEC0 0x%X\n", inp32(REG_JWINDEC0));
//sysprintf("\tJWINDEC1 0x%X\n", inp32(REG_JWINDEC1));
//sysprintf("\tJWINDEC2 0x%X\n", inp32(REG_JWINDEC2));
return E_SUCCESS;
}
/**
* @brief The function is used to set JPEG Q Table.
*
* @param[in] puQTable0: Q Table 0
* @param[in] puQTable1: Q Table 1
* @param[in] puQTable2: Q Table 2
* @param[in] u8num: Q Table number
*
* @return E_JPEG_TIMEOUT: Time-out \n
* E_SUCCESS: success
*/
static INT _jpegSetQTAB(PUINT8 puQTable0, PUINT8 puQTable1, PUINT8 puQTable2, UINT8 u8num)
{
UINT32 u32value;
UINT32 u32TimeOut;
int i;
u32TimeOut = 0xFFFFFF;
for (i = 0; i < 64; i = i + 4)
{
while ((inp32(REG_JMCR) & QT_BUSY) & u32TimeOut)
u32TimeOut--;
if (!u32TimeOut)
return E_JPEG_TIMEOUT;
u32value = puQTable0[i] | (puQTable0[i + 1] << 8) | (puQTable0[i + 2] << 16) | (puQTable0[i + 3] << 24);
outp32((REG_JQTAB0 + i), u32value);
}
u32TimeOut = 0xFFFFFF;
for (i = 0; i < 64; i = i + 4)
{
while ((inp32(REG_JMCR) & QT_BUSY) & u32TimeOut)
u32TimeOut--;
if (!u32TimeOut)
return E_JPEG_TIMEOUT;
u32value = puQTable1[i] | (puQTable1[i + 1] << 8) | (puQTable1[i + 2] << 16) | (puQTable1[i + 3] << 24);
outp32((REG_JQTAB1 + i), u32value);
}
if (u8num < 3)
return E_SUCCESS;
outp32(JITCR, inp32(JITCR) | 0x8);
u32TimeOut = 0xFFFFFF;
for (i = 0; i < 64; i = i + 4)
{
while ((inp32(REG_JMCR) & QT_BUSY) & u32TimeOut)
u32TimeOut--;
if (!u32TimeOut)
return E_JPEG_TIMEOUT;
u32value = puQTable2[i] | (puQTable2[i + 1] << 8) | (puQTable2[i + 2] << 16) | (puQTable2[i + 3] << 24);
outp32((REG_JQTAB2 + i), u32value);
}
u32TimeOut = 0xFFFFFF;
while ((inp32(REG_JMCR) & QT_BUSY) & u32TimeOut)
u32TimeOut--;
if (!u32TimeOut)
return E_JPEG_TIMEOUT;
else
return E_SUCCESS;
}
INT jpegSetQTAB(PUINT8 puQTable0, PUINT8 puQTable1, PUINT8 puQTable2, UINT8 u8num)
{
INT ret = 0;
struct nu_jpeg_ioctl sNuJpegIoctl = {0};
struct nu_jpeg_qtab sNuJpegQTab = {0};
sNuJpegQTab.puQTable0 = puQTable0;
sNuJpegQTab.puQTable1 = puQTable1;
sNuJpegQTab.puQTable2 = puQTable2;
sNuJpegQTab.u8num = u8num;
sNuJpegIoctl.arg0 = (UINT32)&sNuJpegQTab;
sNuJpegIoctl.arg1 = (UINT32)&ret;
rt_device_control(&g_sNuJpeg.dev, JPEG_IOCTL_SET_QTAB, (void *)&sNuJpegIoctl);
return ret;
}
/// @endcond HIDDEN_SYMBOLS
/** @addtogroup N9H30_JPEG_EXPORTED_FUNCTIONS JPEG Exported Functions
@{
*/
/**
* @brief The function is used to initial device parameters and register.
*
* @return 0
*/
static VOID _jpegInit(void)
{
/* Set the default values of the JPEG registers */
g_bScale = FALSE;
g_u32Stride = 0;
g_u32BufferCount = 0;
g_u16ReserveSize = 0;
g_u32WindowDec = FALSE;
g_u32windowSizeX = 0;
g_u32windowSizeY = 0;
g_InputWait = FALSE;
g_bEncThumbnailDownScale = FALSE;
g_bEncPrimaryDownScale = FALSE;
g_OutputWait = FALSE;
g_u32EncRotate = 0;
pfnJpegHeaderDecode = NULL;
pfnJpegDecInputWait = NULL;
pfnJpegDecOutputWait = NULL;
outp32(REG_JPRIQC, 0x000000F4);
outp32(REG_JTHBQC, 0x000000F4);
outp32(REG_JPRST, 0x00000004);
outp32(REG_JTRST, 0x00000004);
outp32(REG_JITCR, 0x00000000);
outp32(REG_JINTCR, 0x00000000);
outp32(JDOWFBS, 0xFFFFFFFF);
// Disable the Primary Up-scaling & Scaling-down
outp32(REG_JPSCALU, 0x00000000);
outp32(REG_JPSCALD, 0x00000000);
// Reset JUPRAT and JSRCH
outp32(REG_JUPRAT, 0x00000000);
outp32(REG_JSRCH, 0x00000FFF);
//-------------------------------------------
/* Reset JPEG (JMCR [1]) */
outp32(REG_JMCR, 0x00000002);
outp32(REG_JMCR, 0x00000000);
outp32(REG_JMACR, 0x00400000); //Can't use single buffer
}
VOID jpegInit(void)
{
rt_device_control(&g_sNuJpeg.dev, JPEG_IOCTL_INITIAL_CODEC, (void *)RT_NULL);
}
/**
* @brief The function is used to check JPEG engine not busy.
*
* @return TRUE: JPEG engine busy \n
* FALSE: JPEG engine not busy
*/
static BOOL _jpegIsReady(void)
{
if (g_bWait == FALSE)
return TRUE;
else
return FALSE;
}
BOOL jpegIsReady(void)
{
UINT32 u32IsReady = 0;
struct nu_jpeg_ioctl sNuJpegIoctl = {0};
sNuJpegIoctl.arg0 = (UINT32)&u32IsReady;
rt_device_control(&g_sNuJpeg.dev, JPEG_IOCTL_IS_READY, (void *)&sNuJpegIoctl);
return (BOOL)u32IsReady;
}
/**
* @brief The function is used to get JPEG information.
*
* @param[out] *info: JPEG encode/decode information.
*
* @return 0
*/
static VOID _jpegGetInfo(JPEG_INFO_T *info)
{
rt_memcpy(info, &jpegInfo, sizeof(JPEG_INFO_T));
}
VOID jpegGetInfo(JPEG_INFO_T *info)
{
struct nu_jpeg_ioctl sNuJpegIoctl = {0};
sNuJpegIoctl.arg0 = (UINT32)info;
rt_device_control(&g_sNuJpeg.dev, JPEG_IOCTL_GET_INFO, (void *)&sNuJpegIoctl);
}
/**
* @brief The function is used to wait JPEG engine, until JPEG engine not busy.
*
* @return E_SUCCESS: JPEG engine encode/decode complete \n
* FALSE: JPEG engine error
*/
static INT _jpegWait(void)
{
while (1)
{
if (g_bWait == FALSE)
break;
}
if (g_jpegError)
return E_FAIL;
return E_SUCCESS;
}
INT jpegWait(void)
{
INT ret = 0;
struct nu_jpeg_ioctl sNuJpegIoctl;
sNuJpegIoctl.arg0 = (UINT32)&ret;
sNuJpegIoctl.arg1 = 0;
rt_device_control(&g_sNuJpeg.dev, JPEG_IOCTL_WAITDONE, (void *)&sNuJpegIoctl);
return ret;
}
/**
* @brief The function is used to config and reset JPEG IP.
*
* @return E_SUCCESS: success
*/
INT jpegOpen(void)
{
return (rt_device_open(&g_sNuJpeg.dev, RT_DEVICE_FLAG_RDWR) == RT_EOK) ? E_SUCCESS : E_FAIL;
}
/**
* @brief Support some JPEG driver commands for application.
*
* @param[in] cmd: Command.
*
* @param[in] arg0: Arguments for the command.
*
* @param[in] arg1: Arguments for the command.
*
* @return 0
*
*/
VOID jpegIoctl(UINT32 cmd, UINT32 arg0, UINT32 arg1)
{
struct nu_jpeg_ioctl sNuJpegIoctl;
sNuJpegIoctl.arg0 = arg0;
sNuJpegIoctl.arg1 = arg1;
rt_device_control(&g_sNuJpeg.dev, cmd, (void *)&sNuJpegIoctl);
}
/**
* @brief JPEG function close.
*
* @return 0
*
*/
VOID jpegClose(void)
{
rt_device_close(&g_sNuJpeg.dev);
}
static rt_err_t nu_jpeg_init(rt_device_t dev)
{
UINT32 u32JPGDiv = 0;
UINT32 u32JPGSource;
UINT32 u32HclkHz;
nu_jpeg_t psNuJpeg = (nu_jpeg_t)dev;
RT_ASSERT(dev != RT_NULL);
/* Set JPEG engine clock */
u32HclkHz = sysGetClock(SYS_HCLK234) * 1000000;
u32JPGSource = u32HclkHz / (((inp32(REG_CLK_DIVCTL3) & 0xf0000000) >> 28) + 1);
if (u32JPGSource > 75000000)
{
if (u32JPGSource % 75000000)
{
u32JPGDiv = (u32JPGSource / 75000000);
}
else
u32JPGDiv = (u32JPGSource / 75000000) - 1;
}
outp32(REG_CLK_DIVCTL3, (inp32(REG_CLK_DIVCTL3) & ~(0xf0000000)) | ((u32JPGDiv & 0xf) << 28));
rt_kprintf("JPEG Engine clock frequency is %d MHz\n", u32JPGSource / (u32JPGDiv + 1) / 1000000);
/* Register ISR and Response JPEG Interrupt. */
rt_hw_interrupt_install(psNuJpeg->irqn, nu_jpeg_isr, (void *)psNuJpeg, psNuJpeg->name);
rt_hw_interrupt_umask(psNuJpeg->irqn);
return RT_EOK;
}
static rt_err_t nu_jpeg_open(rt_device_t dev, rt_uint16_t oflag)
{
rt_err_t result;
nu_jpeg_t psNuJpeg = (nu_jpeg_t)dev;
result = rt_mutex_take(&psNuJpeg->lock, RT_WAITING_FOREVER);
RT_ASSERT(result == RT_EOK);
/* Enable JPEG engine clock */
nu_sys_ipclk_enable(psNuJpeg->clkidx);
/* Reset JPEG codec and internal variables. */
nu_sys_ip_reset(psNuJpeg->rstidx);
jpegInit();
result = rt_mutex_release(&psNuJpeg->lock);
RT_ASSERT(result == RT_EOK);
return RT_EOK;
}
static rt_err_t nu_jpeg_close(rt_device_t dev)
{
rt_err_t result;
nu_jpeg_t psNuJpeg = (nu_jpeg_t)dev;
RT_ASSERT(dev != RT_NULL);
result = rt_mutex_take(&psNuJpeg->lock, RT_WAITING_FOREVER);
RT_ASSERT(result == RT_EOK);
/* Reset JPEG (JMCR [1]) */
outp32(REG_JMCR, 0x00000002);
outp32(REG_JMCR, 0x00000000);
/* Disable JPEG engine clock */
nu_sys_ipclk_disable(psNuJpeg->clkidx);
result = rt_mutex_release(&psNuJpeg->lock);
RT_ASSERT(result == RT_EOK);
return RT_EOK;
}
static rt_err_t nu_jpeg_control(rt_device_t dev, int cmd, void *args)
{
JPEG_WINDOW_DECODE_T *winDecode;
PUINT32 pu32Tmp;
UINT32 arg0 = 0, arg1 = 0;
rt_err_t result;
nu_jpeg_t psNuJpeg = (nu_jpeg_t)dev;
nu_jpeg_ioctl_t psNuJpegIoctl = (nu_jpeg_ioctl_t)args;
RT_ASSERT(dev != RT_NULL);
result = rt_mutex_take(&psNuJpeg->lock, RT_WAITING_FOREVER);
RT_ASSERT(result == RT_EOK);
if (psNuJpegIoctl != RT_NULL)
{
arg0 = psNuJpegIoctl->arg0;
arg1 = psNuJpegIoctl->arg1;
}
switch (cmd)
{
case JPEG_IOCTL_SET_YADDR:
JPEG_SET_YADDR(arg0);
break;
case JPEG_IOCTL_SET_UADDR:
JPEG_SET_UADDR(arg0);
break;
case JPEG_IOCTL_SET_VADDR:
JPEG_SET_VADDR(arg0);
break;
case JPEG_IOCTL_SET_YSTRIDE:
JPEG_SET_YSTRIDE(arg0);
break;
case JPEG_IOCTL_SET_USTRIDE:
JPEG_SET_USTRIDE(arg0);
break;
case JPEG_IOCTL_SET_VSTRIDE:
JPEG_SET_VSTRIDE(arg0);
break;
case JPEG_IOCTL_SET_BITSTREAM_ADDR:
JPEG_SET_BITSTREAM_ADDR(arg0);
break;
case JPEG_IOCTL_SET_SOURCE_IMAGE_HEIGHT:
JPEG_SET_SOURCE_IMAGE_HEIGHT(arg0);
break;
case JPEG_IOCTL_ENC_SET_HEADER_CONTROL:
JPEG_ENC_SET_HEADER_CONTROL(arg0);
break;
case JPEG_IOCTL_SET_DEFAULT_QTAB:
jpegSetQTAB(g_au8QTable0, g_au8QTable1, 0, 2);
break;
case JPEG_IOCTL_SET_DECODE_MODE:
jpegSetDecodeMode(arg0);
break;
case JPEG_IOCTL_SET_ENCODE_MODE:
jpegSetEncodeMode(arg0, arg1);
break;
case JPEG_IOCTL_SET_DIMENSION:
jpegSetDimension(arg0, arg1);
break;
case JPEG_IOCTL_ENCODE_TRIGGER:
jpegEncodeTrigger();
if (g_u16ReserveSize != 0)
{
UINT32 u32Addr = JPEG_GET_BITSTREAM_ADDR();
outp8(u32Addr + 2, 0xFF);
outp8(u32Addr + 3, 0xE0);
outp8(u32Addr + 4, ((g_u16ReserveSize - 4) & 0xFF00) >> 8);
outp8(u32Addr + 5, (g_u16ReserveSize - 4) & 0xFF);
}
break;
case JPEG_IOCTL_DECODE_TRIGGER:
jpegDecodeTrigger();
break;
case JPEG_IOCTL_WINDOW_DECODE:
winDecode = (JPEG_WINDOW_DECODE_T *)arg0;
jpegSetWindowDecode(winDecode->u16StartMCUX, winDecode->u16StartMCUY,
winDecode->u16EndMCUX, winDecode->u16EndMCUY, winDecode->u32Stride);
g_u32WindowDec = TRUE;
g_u32windowSizeX = winDecode->u32Stride;
g_u32windowSizeY = 16 * (winDecode->u16EndMCUY - winDecode->u16StartMCUY + 1);
break;
case JPEG_IOCTL_SET_DECODE_STRIDE:
g_u32Stride = arg0;
break;
case JPEG_IOCTL_SET_DECODE_DOWNSCALE:
g_bScale = TRUE;
g_u32ScaleWidth = arg1;
g_u32ScaleHeight = arg0;
break;
case JPEG_IOCTL_SET_ENCODE_UPSCALE:
g_bScale = TRUE;
g_u32ScaleWidth = arg1;
g_u32ScaleHeight = arg0;
break;
case JPEG_IOCTL_SET_HEADERDECODE_CALBACKFUN:
pfnJpegHeaderDecode = (PFN_JPEG_HEADERDECODE_CALLBACK) arg0;
break;
case JPEG_IOCTL_SET_DECINPUTWAIT_CALBACKFUN:
g_InputWait = TRUE;
pfnJpegDecInputWait = (PFN_JPEG_DECWAIT_CALLBACK) arg0;
JPEG_DEC_SET_INPUT_WAIT(((UINT16) arg1 / 2048));
g_u16BufferSize = arg1 / 2;
break;
case JPEG_IOCTL_ADJUST_QTAB:
jpegAdjustQTAB(arg0, ((arg1 & 0xFF00) >> 4), (arg1 & 0xFF));
break;
case JPEG_IOCTL_ENC_RESERVED_FOR_SOFTWARE:
if (arg0 > 0)
{
UINT32 u32Tmp;
u32Tmp = arg0 + 4;
if (u32Tmp % 2)
u32Tmp++;
if ((u32Tmp % 4) == 0)
u32Tmp += 2;
if (u32Tmp >= 0xFFFF)
u32Tmp = 65534;
outp32(REG_JPSCALU, inp32(REG_JPSCALU) | A_JUMP);
outp32(JRESERVE, u32Tmp);
g_u16ReserveSize = u32Tmp;
}
break;
case JPEG_IOCTL_SET_ENCODE_PRIMARY_RESTART_INTERVAL:
outp32(REG_JPRST, arg0);
break;
case JPEG_IOCTL_SET_ENCODE_THUMBNAIL_RESTART_INTERVAL:
outp32(REG_JTRST, arg0);
break;
case JPEG_IOCTL_GET_ENCODE_PRIMARY_RESTART_INTERVAL:
pu32Tmp = (PUINT32) arg0;
*pu32Tmp = inp32(REG_JPRST);
break;
case JPEG_IOCTL_GET_ENCODE_THUMBNAIL_RESTART_INTERVAL:
pu32Tmp = (PUINT32) arg0;
*pu32Tmp = inp32(REG_JTRST);
break;
case JPEG_IOCTL_SET_THUMBNAIL_DIMENSION:
outp32(REG_JTHBWH, ((arg0 & 0x1FFF) << 16) | (arg1 & 0x1FFF));
break;
case JPEG_IOCTL_SET_ENCODE_SW_OFFSET:
outp32(REG_JOFFSET, arg0);
break;
case JPEG_IOCTL_GET_THUMBNAIL_DIMENSION:
pu32Tmp = (PUINT32) arg0;
*pu32Tmp = inp32(REG_JTHBWH) >> 16;
pu32Tmp = (PUINT32) arg1;
*pu32Tmp = inp32(REG_JTHBWH) & 0x1FFF;
break;
case JPEG_IOCTL_GET_ENCODE_SW_OFFSET:
pu32Tmp = (PUINT32) arg0;
*pu32Tmp = inp32(REG_JOFFSET);
break;
case JPEG_IOCTL_SET_ENCODE_PRIMARY_DOWNSCALE:
g_bScale = TRUE;
g_bEncPrimaryDownScale = TRUE;
g_u32ScaleWidth = arg1;
g_u32ScaleHeight = arg0;
break;
case JPEG_IOCTL_SET_ENCODE_THUMBNAIL_DOWNSCALE:
g_bScale = TRUE;
g_bEncThumbnailDownScale = TRUE;
g_u32ScaleWidth = arg1;
g_u32ScaleHeight = arg0;
break;
case JPEG_IOCTL_SET_ENCODE_PRIMARY_ROTATE_RIGHT:
g_u32EncRotate = JPEG_IOCTL_SET_ENCODE_PRIMARY_ROTATE_RIGHT;
outp32(REG_JITCR, (inp32(REG_JITCR) & ~ROTATE) | ROTATE);
break;
case JPEG_IOCTL_SET_ENCODE_PRIMARY_ROTATE_LEFT:
g_u32EncRotate = JPEG_IOCTL_SET_ENCODE_PRIMARY_ROTATE_LEFT;
outp32(REG_JITCR, (inp32(REG_JITCR) & ~ROTATE) | 0x1000);
break;
case JPEG_IOCTL_SET_ENCODE_PRIMARY_ROTATE_NORMAL:
g_u32EncRotate = 0;
outp32(REG_JITCR, (inp32(REG_JITCR) & ~ROTATE));
break;
case JPEG_IOCTL_SET_DECOUTPUTWAIT_CALBACKFUN:
pfnJpegDecOutputWait = (PFN_JPEG_DECWAIT_CALLBACK) arg0;
break;
case JPEG_IOCTL_SET_DECOUTPUTWAIT:
outp32(JYADDR0, arg0);
outp32(JDOWFBS, arg1);
g_OutputWait = TRUE;
break;
case JPEG_IOCTL_GET_DECOUTPUTWAIT_ADDR:
pu32Tmp = (PUINT32) arg0;
*pu32Tmp = inp32(JYADDR0);
break;
case JPEG_IOCTL_GET_DECOUTPUTWAIT_SIZE:
pu32Tmp = (PUINT32) arg0;
*pu32Tmp = inp32(JDOWFBS);
break;
case JPEG_IOCTL_SET_DECODE_COMPLETE_CALBACKFUN:
pfnJpegDecodeComplete = (PFN_JPEG_CALLBACK) arg0;
break;
case JPEG_IOCTL_SET_ENCODE_COMPLETE_CALBACKFUN:
pfnJpegEncodeComplete = (PFN_JPEG_CALLBACK) arg0;
break;
case JPEG_IOCTL_SET_DECODE_ERROR_CALBACKFUN:
pfnJpegDecodeError = (PFN_JPEG_CALLBACK) arg0;
break;
/* Extended IOCTL command */
case JPEG_IOCTL_SET_QTAB:
{
nu_jpeg_qtab_t psJpegQtab = (nu_jpeg_qtab_t)arg0;
INT *pi32ret = (INT *)arg1;
*pi32ret = _jpegSetQTAB(psJpegQtab->puQTable0, psJpegQtab->puQTable1, psJpegQtab->puQTable2, psJpegQtab->u8num);
}
break;
case JPEG_IOCTL_INITIAL_CODEC:
_jpegInit();
break;
case JPEG_IOCTL_GET_INFO:
_jpegGetInfo((JPEG_INFO_T *)arg0);
break;
case JPEG_IOCTL_IS_READY:
{
UINT32 *pu32ret = (UINT32 *)arg0;
*pu32ret = _jpegIsReady();
}
break;
case JPEG_IOCTL_WAITDONE:
{
INT *pi32ret = (INT *)arg0;
*pi32ret = _jpegWait();
}
break;
default:
break;
}
result = rt_mutex_release(&psNuJpeg->lock);
RT_ASSERT(result == RT_EOK);
return RT_EOK;
}
/* Hardward JPEG codec init */
static int rt_hw_jpeg_init(void)
{
rt_err_t ret = RT_EOK;
/* Register sdcard device */
g_sNuJpeg.dev.type = RT_Device_Class_Miscellaneous;
g_sNuJpeg.dev.init = nu_jpeg_init;
g_sNuJpeg.dev.open = nu_jpeg_open;
g_sNuJpeg.dev.close = nu_jpeg_close;
g_sNuJpeg.dev.read = RT_NULL;
g_sNuJpeg.dev.write = RT_NULL;
g_sNuJpeg.dev.control = nu_jpeg_control;
/* Private */
g_sNuJpeg.dev.user_data = (void *)&g_sNuJpeg;
ret = rt_mutex_init(&g_sNuJpeg.lock, "jpeg_lock", RT_IPC_FLAG_PRIO);
RT_ASSERT(ret == RT_EOK);
/* Only support single opening. */
ret = rt_device_register(&g_sNuJpeg.dev, g_sNuJpeg.name, RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_STANDALONE);
RT_ASSERT(ret == RT_EOK);
return (int)ret;
}
INIT_DEVICE_EXPORT(rt_hw_jpeg_init);