/*------------------------------------------------------------------------------
|
-- --
|
-- This software is confidential and proprietary and may be used --
|
-- only as expressly authorized by a licensing agreement from --
|
-- --
|
-- Rockchip Products . --
|
-- --
|
-- (C) COPYRIGHT 2014 ROCKCHIP PRODUCTS --
|
-- ALL RIGHTS RESERVED --
|
-- --
|
-- The entire notice above must be reproduced --
|
-- on all copies and should not be removed. --
|
-- --
|
--------------------------------------------------------------------------------
|
--
|
-- Description : Jpeg decoder header decoding source code
|
--
|
------------------------------------------------------------------------------
|
--
|
--
|
--
|
|
------------------------------------------------------------------------------*/
|
/*------------------------------------------------------------------------------
|
|
Table of contents
|
|
1. Include headers
|
2. External compiler flags
|
3. Module defines
|
4. Local function prototypes
|
5. Functions
|
- JpegDecDecodeFrame
|
- JpegDecDecodeQuantTables
|
- JpegDecDecodeHuffmanTables
|
|
------------------------------------------------------------------------------*/
|
|
/*------------------------------------------------------------------------------
|
1. Include headers
|
------------------------------------------------------------------------------*/
|
#include "jpegdechdrs.h"
|
#include "jpegdecutils.h"
|
#include "jpegdecmarkers.h"
|
#include "jpegdecinternal.h"
|
#include "jpegdecscan.h"
|
#include "jpegdecapi.h"
|
#include "dwl.h"
|
#include <stdint.h>
|
/*------------------------------------------------------------------------------
|
2. External compiler flags
|
--------------------------------------------------------------------------------
|
|
--------------------------------------------------------------------------------
|
3. Module defines
|
------------------------------------------------------------------------------*/
|
|
/*------------------------------------------------------------------------------
|
4. Local function prototypes
|
------------------------------------------------------------------------------*/
|
|
/*------------------------------------------------------------------------------
|
5. Functions
|
------------------------------------------------------------------------------*/
|
|
/*------------------------------------------------------------------------------
|
|
Function name: JpegDecDecodeFrame
|
|
Functional description:
|
Decodes frame headers
|
|
Inputs:
|
JpegDecContainer *pDecData Pointer to JpegDecContainer structure
|
|
Outputs:
|
OK/NOK
|
|
------------------------------------------------------------------------------*/
|
JpegDecRet JpegDecDecodeFrameHdr(JpegDecContainer * pDecData)
|
{
|
RK_U32 i;
|
RK_U32 width, height;
|
RK_U32 tmp1, tmp2;
|
RK_U32 Hmax = 0;
|
RK_U32 Vmax = 0;
|
RK_U32 size = 0;
|
JpegDecRet retCode;
|
|
retCode = JPEGDEC_OK;
|
|
/* frame header length */
|
pDecData->frame.Lf = JpegDecGet2Bytes(&(pDecData->stream));
|
|
/* check if there is enough data */
|
if (((pDecData->stream.readBits / 8) + pDecData->frame.Lf) >
|
pDecData->stream.streamLength)
|
return (JPEGDEC_STRM_ERROR);
|
|
/* Sample precision */
|
pDecData->frame.P = JpegDecGetByte(&(pDecData->stream));
|
if (pDecData->frame.P != 8) {
|
JPEGDEC_TRACE_INTERNAL(("if ( pDecData->frame.P != 8)\n"));
|
return (JPEGDEC_UNSUPPORTED);
|
}
|
/* Number of Lines */
|
pDecData->frame.Y = JpegDecGet2Bytes(&(pDecData->stream));
|
if (pDecData->frame.Y < 1) {
|
return (JPEGDEC_UNSUPPORTED);
|
}
|
pDecData->frame.hwY = pDecData->frame.Y;
|
|
/* round up to next multiple-of-16 */
|
pDecData->frame.hwY += 0xf;
|
pDecData->frame.hwY &= ~(0xf);
|
|
/* Number of samples per line */
|
pDecData->frame.X = JpegDecGet2Bytes(&(pDecData->stream));
|
if (pDecData->frame.X < 1) {
|
return (JPEGDEC_UNSUPPORTED);
|
}
|
pDecData->frame.hwX = pDecData->frame.X;
|
|
/* round up to next multiple-of-16 */
|
pDecData->frame.hwX += 0xf;
|
pDecData->frame.hwX &= ~(0xf);
|
|
/* for internal() */
|
pDecData->info.X = pDecData->frame.hwX;
|
pDecData->info.Y = pDecData->frame.hwY;
|
|
/* check for minimum and maximum dimensions */
|
if (pDecData->frame.hwX < pDecData->minSupportedWidth ||
|
pDecData->frame.hwY < pDecData->minSupportedHeight ||
|
pDecData->frame.hwX > pDecData->maxSupportedWidth ||
|
pDecData->frame.hwY > pDecData->maxSupportedHeight ||
|
(pDecData->frame.hwX * pDecData->frame.hwY) >
|
pDecData->maxSupportedPixelAmount) {
|
JPEGDEC_TRACE_INTERNAL(("FRAME: Unsupported size\n"));
|
return (JPEGDEC_UNSUPPORTED);
|
}
|
|
/* Number of components */
|
pDecData->frame.Nf = JpegDecGetByte(&(pDecData->stream));
|
if ((pDecData->frame.Nf != 3) && (pDecData->frame.Nf != 1)) {
|
JPEGDEC_TRACE_INTERNAL(("pDecData->frame.Nf != 3 && pDecData->frame.Nf != 1\n"));
|
return (JPEGDEC_UNSUPPORTED);
|
}
|
|
/* save component specific data */
|
/* Nf == number of components */
|
for (i = 0; i < pDecData->frame.Nf; i++) {
|
pDecData->frame.component[i].C = JpegDecGetByte(&(pDecData->stream));
|
if (i == 0) { /* for the first component */
|
/* if first component id is something else than 1 (jfif) */
|
pDecData->scan.index = pDecData->frame.component[i].C;
|
} else {
|
/* if component ids 'jumps' */
|
if ((pDecData->frame.component[i - 1].C + 1) !=
|
pDecData->frame.component[i].C) {
|
JPEGDEC_TRACE_INTERNAL(("component ids 'jumps'\n"));
|
return (JPEGDEC_UNSUPPORTED);
|
}
|
}
|
tmp1 = JpegDecGetByte(&(pDecData->stream));
|
pDecData->frame.component[i].H = tmp1 >> 4;
|
if (pDecData->frame.component[i].H > Hmax) {
|
Hmax = pDecData->frame.component[i].H;
|
}
|
pDecData->frame.component[i].V = tmp1 & 0xF;
|
if (pDecData->frame.component[i].V > Vmax) {
|
Vmax = pDecData->frame.component[i].V;
|
}
|
|
pDecData->frame.component[i].Tq = JpegDecGetByte(&(pDecData->stream));
|
}
|
|
if (pDecData->frame.Nf == 1) {
|
Hmax = Vmax = 1;
|
pDecData->frame.component[0].H = 1;
|
pDecData->frame.component[0].V = 1;
|
} else if (Hmax == 0 || Vmax == 0) {
|
JPEGDEC_TRACE_INTERNAL(("Hmax == 0 || Vmax == 0 \n"));
|
return (JPEGDEC_UNSUPPORTED);
|
}
|
|
/* JPEG_YCBCR411 horizontal size has to be multiple of 32 pels */
|
if (Hmax == 4 && (pDecData->frame.hwX & 0x1F)) {
|
/* round up to next multiple-of-32 */
|
pDecData->frame.hwX += 16;
|
pDecData->info.X = pDecData->frame.hwX;
|
|
/* check for minimum and maximum dimensions */
|
if (pDecData->frame.hwX > pDecData->maxSupportedWidth ||
|
(pDecData->frame.hwX * pDecData->frame.hwY) >
|
pDecData->maxSupportedPixelAmount) {
|
JPEGDEC_TRACE_INTERNAL(("FRAME: Unsupported size\n"));
|
return (JPEGDEC_UNSUPPORTED);
|
}
|
}
|
|
/* set image pointers, calculate pixelPerRow for each component */
|
width = ((pDecData->frame.hwX + Hmax * 8 - 1) / (Hmax * 8)) * Hmax * 8;
|
height = ((pDecData->frame.hwY + Vmax * 8 - 1) / (Vmax * 8)) * Vmax * 8;
|
|
/* calculate numMcuInRow and numMcuInFrame */
|
ASSERT(Hmax != 0);
|
ASSERT(Vmax != 0);
|
pDecData->frame.numMcuInRow = width / (8 * Hmax);
|
pDecData->frame.numMcuInFrame = pDecData->frame.numMcuInRow *
|
(height / (8 * Vmax));
|
|
/* reset mcuNumbers */
|
pDecData->frame.mcuNumber = 0;
|
pDecData->frame.row = pDecData->frame.col = 0;
|
|
for (i = 0; i < pDecData->frame.Nf; i++) {
|
|
ASSERT(i <= 2);
|
|
tmp1 = (width * pDecData->frame.component[i].H + Hmax - 1) / Hmax;
|
tmp2 = (height * pDecData->frame.component[i].V + Vmax - 1) / Vmax;
|
size += tmp1 * tmp2;
|
/* pixels per row */
|
|
pDecData->image.pixelsPerRow[i] = tmp1;
|
pDecData->image.columns[i] = tmp2;
|
pDecData->frame.numBlocks[i] =
|
(((pDecData->frame.hwX * pDecData->frame.component[i].H) / Hmax +
|
7) >> 3) * (((pDecData->frame.hwY *
|
pDecData->frame.component[i].V) / Vmax + 7) >> 3);
|
|
if (i == 0) {
|
pDecData->image.sizeLuma = size;
|
}
|
}
|
|
pDecData->image.size = size;
|
pDecData->image.sizeChroma = size - pDecData->image.sizeLuma;
|
|
/* set YUV mode & calculate rlc tmp size */
|
retCode = JpegDecMode(pDecData);
|
if (retCode != JPEGDEC_OK) {
|
return (retCode);
|
}
|
|
return (JPEGDEC_OK);
|
}
|
|
/*------------------------------------------------------------------------------
|
|
Function name: JpegDecDecodeQuantTables
|
|
Functional description:
|
Decodes quantisation tables from the stream
|
|
Inputs:
|
JpegDecContainer *pDecData Pointer to JpegDecContainer structure
|
|
Outputs:
|
OK (0)
|
NOK (-1)
|
|
------------------------------------------------------------------------------*/
|
|
JpegDecRet JpegDecDecodeQuantTables(JpegDecContainer * pDecData)
|
{
|
RK_U32 t, tmp, i;
|
StreamStorage *pStream = &(pDecData->stream);
|
|
pDecData->quant.Lq = JpegDecGet2Bytes(pStream);
|
|
/* check if there is enough data for tables */
|
if (((pStream->readBits / 8) + pDecData->quant.Lq) > pStream->streamLength)
|
return (JPEGDEC_STRM_ERROR);
|
|
t = 4;
|
|
while (t < pDecData->quant.Lq) {
|
/* Tq value selects what table the components use */
|
|
/* read tables and write to decData->quant */
|
tmp = JpegDecGetByte(pStream);
|
t++;
|
/* supporting only 8 bits / sample */
|
if ((tmp >> 4) != 0) {
|
return (JPEGDEC_UNSUPPORTED);
|
}
|
tmp &= 0xF;
|
/* set the quantisation table pointer */
|
|
if (tmp == 0) {
|
JPEGDEC_TRACE_INTERNAL(("qtable0\n"));
|
pDecData->quant.table = pDecData->quant.table0;
|
} else if (tmp == 1) {
|
JPEGDEC_TRACE_INTERNAL(("qtable1\n"));
|
pDecData->quant.table = pDecData->quant.table1;
|
} else if (tmp == 2) {
|
JPEGDEC_TRACE_INTERNAL(("qtable2\n"));
|
pDecData->quant.table = pDecData->quant.table2;
|
} else if (tmp == 3) {
|
JPEGDEC_TRACE_INTERNAL(("qtable3\n"));
|
pDecData->quant.table = pDecData->quant.table3;
|
} else {
|
return (JPEGDEC_UNSUPPORTED);
|
}
|
for (i = 0; i < 64; i++) {
|
pDecData->quant.table[i] = JpegDecGetByte(pStream);
|
t++;
|
}
|
|
}
|
|
return (JPEGDEC_OK);
|
}
|
|
/*------------------------------------------------------------------------------
|
|
Function name: JpegDecDecodeHuffmanTables
|
|
Functional description:
|
Decodes huffman tables from the stream
|
|
Inputs:
|
DecData *JpegDecContainer Pointer to JpegDecContainer structure
|
|
Outputs:
|
OK (0)
|
NOK (-1)
|
|
------------------------------------------------------------------------------*/
|
JpegDecRet JpegDecDecodeHuffmanTables(JpegDecContainer * pDecData)
|
{
|
RK_U32 i, len, Tc, Th, tmp;
|
RK_S32 j;
|
StreamStorage *pStream = &(pDecData->stream);
|
|
pDecData->vlc.Lh = JpegDecGet2Bytes(pStream);
|
|
/* check if there is enough data for tables */
|
if (((pStream->readBits / 8) + pDecData->vlc.Lh) > pStream->streamLength)
|
return (JPEGDEC_STRM_ERROR);
|
|
/* four bytes already read in */
|
len = 4;
|
|
while (len < pDecData->vlc.Lh) {
|
tmp = JpegDecGetByte(pStream);
|
len++;
|
Tc = tmp >> 4; /* Table class */
|
if (Tc != 0 && Tc != 1) {
|
return (JPEGDEC_UNSUPPORTED);
|
}
|
Th = tmp & 0xF; /* Huffman table identifier */
|
/* only two tables in baseline allowed */
|
if ((pDecData->frame.codingType == SOF0) && (Th > 1)) {
|
return (JPEGDEC_UNSUPPORTED);
|
}
|
/* four tables in progressive allowed */
|
if ((pDecData->frame.codingType == SOF2) && (Th > 3)) {
|
return (JPEGDEC_UNSUPPORTED);
|
}
|
/* set the table pointer */
|
if (Tc) {
|
/* Ac table */
|
switch (Th) {
|
case 0:
|
JPEGDEC_TRACE_INTERNAL(("ac0\n"));
|
pDecData->vlc.table = &(pDecData->vlc.acTable0);
|
break;
|
case 1:
|
JPEGDEC_TRACE_INTERNAL(("ac1\n"));
|
pDecData->vlc.table = &(pDecData->vlc.acTable1);
|
break;
|
case 2:
|
JPEGDEC_TRACE_INTERNAL(("ac2\n"));
|
pDecData->vlc.table = &(pDecData->vlc.acTable2);
|
break;
|
case 3:
|
JPEGDEC_TRACE_INTERNAL(("ac3\n"));
|
pDecData->vlc.table = &(pDecData->vlc.acTable3);
|
break;
|
default:
|
return (JPEGDEC_UNSUPPORTED);
|
}
|
} else {
|
/* Dc table */
|
switch (Th) {
|
case 0:
|
JPEGDEC_TRACE_INTERNAL(("dc0\n"));
|
pDecData->vlc.table = &(pDecData->vlc.dcTable0);
|
break;
|
case 1:
|
JPEGDEC_TRACE_INTERNAL(("dc1\n"));
|
pDecData->vlc.table = &(pDecData->vlc.dcTable1);
|
break;
|
case 2:
|
JPEGDEC_TRACE_INTERNAL(("dc2\n"));
|
pDecData->vlc.table = &(pDecData->vlc.dcTable2);
|
break;
|
case 3:
|
JPEGDEC_TRACE_INTERNAL(("dc3\n"));
|
pDecData->vlc.table = &(pDecData->vlc.dcTable3);
|
break;
|
default:
|
return (JPEGDEC_UNSUPPORTED);
|
}
|
}
|
|
tmp = 0;
|
/* read in the values of list BITS */
|
for (i = 0; i < 16; i++) {
|
tmp += pDecData->vlc.table->bits[i] = JpegDecGetByte(pStream);
|
len++;
|
}
|
/* allocate memory for HUFFVALs */
|
if (pDecData->vlc.table->vals != NULL) {
|
/* free previously reserved table */
|
DWLfree(pDecData->vlc.table->vals);
|
}
|
|
pDecData->vlc.table->vals = (RK_U32 *) DWLmalloc(sizeof(RK_U32) * tmp);
|
|
/* set the table length */
|
pDecData->vlc.table->tableLength = tmp;
|
/* read in the HUFFVALs */
|
for (i = 0; i < tmp; i++) {
|
pDecData->vlc.table->vals[i] = JpegDecGetByte(pStream);
|
len++;
|
}
|
/* first and last lengths */
|
for (i = 0; i < 16; i++) {
|
if (pDecData->vlc.table->bits[i] != 0) {
|
pDecData->vlc.table->start = i;
|
break;
|
}
|
}
|
for (j = 15; j >= 0; j--) {
|
if (pDecData->vlc.table->bits[j] != 0) {
|
pDecData->vlc.table->last = ((RK_U32) j + 1);
|
break;
|
}
|
}
|
}
|
|
return (JPEGDEC_OK);
|
}
|
|
/*------------------------------------------------------------------------------
|
|
Function name: JpegDefaultHuffmanTables
|
|
Functional description:
|
if jpeg file not find huffman table, use it!
|
|
Inputs:
|
DecData *JpegDecContainer Pointer to JpegDecContainer structure
|
|
Outputs:
|
OK (0)
|
NOK (-1)
|
|
------------------------------------------------------------------------------*/
|
JpegDecRet JpegDefaultHuffmanTables(JpegDecContainer * pDecData)
|
{
|
|
/* Set up the standard Huffman tables (cf. JPEG standard section K.3) */
|
/* IMPORTANT: these are only valid for 8-bit data precision! */
|
uint8_t ff_mjpeg_bits_dc_luminance[17] =
|
{ /* 0-base */ 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 };
|
uint8_t ff_mjpeg_val_dc[12] = //luminance and chrominance all use it
|
{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
|
|
uint8_t ff_mjpeg_bits_dc_chrominance[17] =
|
{ /* 0-base */ 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 };
|
|
uint8_t ff_mjpeg_bits_ac_luminance[17] =
|
{ /* 0-base */ 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d };
|
uint8_t ff_mjpeg_val_ac_luminance[] = {
|
0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
|
0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
|
0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
|
0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
|
0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
|
0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
|
0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
|
0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
|
0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
|
0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
|
0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
|
0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
|
0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
|
0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
|
0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
|
0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
|
0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
|
0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
|
0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
|
0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
|
0xf9, 0xfa
|
};
|
|
uint8_t ff_mjpeg_bits_ac_chrominance[17] =
|
{ /* 0-base */ 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77 };
|
|
uint8_t ff_mjpeg_val_ac_chrominance[] = {
|
0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
|
0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
|
0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
|
0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
|
0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
|
0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
|
0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
|
0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
|
0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
|
0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
|
0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
|
0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
|
0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
|
0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
|
0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
|
0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
|
0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
|
0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
|
0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
|
0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
|
0xf9, 0xfa
|
};
|
|
RK_U32 i, len, tmp, k;
|
RK_S32 j;
|
uint8_t *bitstable[4] = {ff_mjpeg_bits_dc_luminance, ff_mjpeg_bits_ac_luminance, ff_mjpeg_bits_dc_chrominance, ff_mjpeg_bits_ac_chrominance};
|
uint8_t *valtable[4] = {ff_mjpeg_val_dc, ff_mjpeg_val_ac_luminance, ff_mjpeg_val_dc, ff_mjpeg_val_ac_chrominance};
|
uint8_t *bitstmp;
|
uint8_t *valtmp;
|
|
for (k = 0; k < 4; k++) {
|
bitstmp = bitstable[k];
|
valtmp = valtable[k];
|
|
if (k == 0)
|
pDecData->vlc.table = &(pDecData->vlc.dcTable0);
|
else if (k == 1)
|
pDecData->vlc.table = &(pDecData->vlc.acTable0);
|
else if (k == 2)
|
pDecData->vlc.table = &(pDecData->vlc.dcTable1);
|
else
|
pDecData->vlc.table = &(pDecData->vlc.acTable1);
|
|
tmp = 0;
|
/* read in the values of list BITS */
|
for (i = 0; i < 16; i++) {
|
tmp += pDecData->vlc.table->bits[i] = bitstmp[i + 1];
|
len++;
|
}
|
/* allocate memory for HUFFVALs */
|
if (pDecData->vlc.table->vals != NULL) {
|
/* free previously reserved table */
|
DWLfree(pDecData->vlc.table->vals);
|
}
|
|
pDecData->vlc.table->vals = (RK_U32 *) DWLmalloc(sizeof(RK_U32) * tmp);
|
|
/* set the table length */
|
pDecData->vlc.table->tableLength = tmp;
|
/* read in the HUFFVALs */
|
for (i = 0; i < tmp; i++) {
|
pDecData->vlc.table->vals[i] = valtmp[i];
|
len++;
|
}
|
/* first and last lengths */
|
for (i = 0; i < 16; i++) {
|
if (pDecData->vlc.table->bits[i] != 0) {
|
pDecData->vlc.table->start = i;
|
break;
|
}
|
}
|
for (j = 15; j >= 0; j--) {
|
if (pDecData->vlc.table->bits[j] != 0) {
|
pDecData->vlc.table->last = ((RK_U32) j + 1);
|
break;
|
}
|
}
|
}
|
|
return (JPEGDEC_OK);
|
}
|
|
/*------------------------------------------------------------------------------
|
|
Function name: JpegDecMode
|
|
Functional description:
|
check YCBCR mode
|
|
Inputs:
|
JpegDecContainer *pDecData Pointer to JpegDecContainer structure
|
|
Outputs:
|
OK/NOK
|
|
------------------------------------------------------------------------------*/
|
JpegDecRet JpegDecMode(JpegDecContainer * pDecData)
|
{
|
/* check input format */
|
if (pDecData->frame.Nf == 3) {
|
/* JPEG_YCBCR420 */
|
if (pDecData->frame.component[0].H == 2 &&
|
pDecData->frame.component[0].V == 2 &&
|
pDecData->frame.component[1].H == 1 &&
|
pDecData->frame.component[1].V == 1 &&
|
pDecData->frame.component[2].H == 1 &&
|
pDecData->frame.component[2].V == 1) {
|
pDecData->info.yCbCrMode = JPEGDEC_YUV420;
|
pDecData->info.X = pDecData->frame.hwX;
|
pDecData->info.Y = pDecData->frame.hwY;
|
|
/* calculate new output size if slice mode used */
|
if (pDecData->info.sliceMbSetValue) {
|
/* Y */
|
pDecData->image.sizeLuma = (pDecData->info.X *
|
(pDecData->info.sliceMbSetValue *
|
16));
|
|
/* CbCr */
|
pDecData->image.sizeChroma = pDecData->image.sizeLuma / 2;
|
|
}
|
}
|
/* JPEG_YCBCR422 */
|
else if (pDecData->frame.component[0].H == 2 &&
|
pDecData->frame.component[0].V == 1 &&
|
pDecData->frame.component[1].H == 1 &&
|
pDecData->frame.component[1].V == 1 &&
|
pDecData->frame.component[2].H == 1 &&
|
pDecData->frame.component[2].V == 1) {
|
pDecData->info.yCbCrMode = JPEGDEC_YUV422;
|
pDecData->info.X = (pDecData->frame.hwX);
|
pDecData->info.Y = (pDecData->frame.hwY);
|
|
/* check if fill needed */
|
if ((pDecData->frame.Y & 0xF) && (pDecData->frame.Y & 0xF) <= 8)
|
pDecData->info.fillBottom = 1;
|
|
/* calculate new output size if slice mode used */
|
if (pDecData->info.sliceMbSetValue) {
|
/* Y */
|
pDecData->image.sizeLuma = (pDecData->info.X *
|
(pDecData->info.sliceMbSetValue *
|
16));
|
|
/* CbCr */
|
pDecData->image.sizeChroma = pDecData->image.sizeLuma;
|
}
|
}
|
/* JPEG_YCBCR440 */
|
else if (pDecData->frame.component[0].H == 1 &&
|
pDecData->frame.component[0].V == 2 &&
|
pDecData->frame.component[1].H == 1 &&
|
pDecData->frame.component[1].V == 1 &&
|
pDecData->frame.component[2].H == 1 &&
|
pDecData->frame.component[2].V == 1) {
|
pDecData->info.yCbCrMode = JPEGDEC_YUV440;
|
pDecData->info.X = (pDecData->frame.hwX);
|
pDecData->info.Y = (pDecData->frame.hwY);
|
|
/* check if fill needed */
|
if ((pDecData->frame.X & 0xF) && (pDecData->frame.X & 0xF) <= 8)
|
pDecData->info.fillRight = 1;
|
|
/* calculate new output size if slice mode used */
|
if (pDecData->info.sliceMbSetValue) {
|
/* Y */
|
pDecData->image.sizeLuma = (pDecData->info.X *
|
(pDecData->info.sliceMbSetValue *
|
16));
|
|
/* CbCr */
|
pDecData->image.sizeChroma = pDecData->image.sizeLuma;
|
}
|
}
|
/* JPEG_YCBCR444 : NOT SUPPORTED */
|
else if (pDecData->frame.component[0].H == 1 &&
|
pDecData->frame.component[0].V == 1 &&
|
pDecData->frame.component[1].H == 1 &&
|
pDecData->frame.component[1].V == 1 &&
|
pDecData->frame.component[2].H == 1 &&
|
pDecData->frame.component[2].V == 1) {
|
pDecData->info.yCbCrMode = JPEGDEC_YUV444;
|
pDecData->info.X = pDecData->frame.hwX;
|
pDecData->info.Y = pDecData->frame.hwY;
|
|
/* check if fill needed */
|
if ((pDecData->frame.X & 0xF) && (pDecData->frame.X & 0xF) <= 8)
|
pDecData->info.fillRight = 1;
|
|
if ((pDecData->frame.Y & 0xF) && (pDecData->frame.Y & 0xF) <= 8)
|
pDecData->info.fillBottom = 1;
|
|
/* calculate new output size if slice mode used */
|
if (pDecData->info.sliceMbSetValue) {
|
/* Y */
|
pDecData->image.sizeLuma = (pDecData->info.X *
|
(pDecData->info.sliceMbSetValue *
|
16));
|
|
/* CbCr */
|
pDecData->image.sizeChroma = pDecData->image.sizeLuma * 2;
|
}
|
}
|
/* JPEG_YCBCR411 */
|
else if (pDecData->frame.component[0].H == 4 &&
|
pDecData->frame.component[0].V == 1 &&
|
pDecData->frame.component[1].H == 1 &&
|
pDecData->frame.component[1].V == 1 &&
|
pDecData->frame.component[2].H == 1 &&
|
pDecData->frame.component[2].V == 1) {
|
pDecData->info.yCbCrMode = JPEGDEC_YUV411;
|
pDecData->info.X = (pDecData->frame.hwX);
|
pDecData->info.Y = (pDecData->frame.hwY);
|
|
/* check if fill needed */
|
if ((pDecData->frame.Y & 0xF) && (pDecData->frame.Y & 0xF) <= 8)
|
pDecData->info.fillBottom = 1;
|
|
/* calculate new output size if slice mode used */
|
if (pDecData->info.sliceMbSetValue) {
|
/* Y */
|
pDecData->image.sizeLuma = (pDecData->info.X *
|
(pDecData->info.sliceMbSetValue *
|
16));
|
|
/* CbCr */
|
pDecData->image.sizeChroma = pDecData->image.sizeLuma / 2;
|
}
|
} else {
|
return (JPEGDEC_UNSUPPORTED);
|
}
|
} else if (pDecData->frame.Nf == 1) {
|
/* 4:0:0 */
|
if ((pDecData->frame.component[0].V == 1) ||
|
(pDecData->frame.component[0].H == 1)) {
|
pDecData->info.yCbCrMode = JPEGDEC_YUV400;
|
pDecData->info.X = (pDecData->frame.hwX);
|
pDecData->info.Y = (pDecData->frame.hwY);
|
|
/* check if fill needed */
|
if ((pDecData->frame.X & 0xF) && (pDecData->frame.X & 0xF) <= 8)
|
pDecData->info.fillRight = 1;
|
|
if ((pDecData->frame.Y & 0xF) && (pDecData->frame.Y & 0xF) <= 8)
|
pDecData->info.fillBottom = 1;
|
|
/* calculate new output size if slice mode used */
|
if (pDecData->info.sliceMbSetValue) {
|
/* Y */
|
pDecData->image.sizeLuma =
|
((((pDecData->info.X +
|
15) / 16) * 16) * (pDecData->info.sliceMbSetValue *
|
16));
|
|
/* CbCr */
|
pDecData->image.sizeChroma = 0;
|
}
|
} else {
|
return (JPEGDEC_UNSUPPORTED);
|
}
|
} else {
|
return (JPEGDEC_UNSUPPORTED);
|
}
|
|
#ifdef JPEGDEC_ERROR_RESILIENCE
|
if (pDecData->info.fillBottom) {
|
pDecData->info.Y -= 16;
|
pDecData->frame.hwY -= 16;
|
}
|
#endif /* JPEGDEC_ERROR_RESILIENCE */
|
|
/* save the original sampling format for progressive use */
|
pDecData->info.yCbCrModeOrig = pDecData->info.yCbCrMode;
|
|
return (JPEGDEC_OK);
|
}
|
