From 23e23b697ca4796d62c017736a131f2c15f44ada Mon Sep 17 00:00:00 2001 From: SalimTerryLi Date: Fri, 27 Aug 2021 15:28:48 +0800 Subject: [PATCH] rom/tjpgd: unify library & add rom patch remove external tjpgd library inside example enable tjpgd decoding on all chips --- components/esp_rom/CMakeLists.txt | 3 +- components/esp_rom/esp32/ld/esp32.rom.api.ld | 5 + .../esp_rom/esp32c3/ld/esp32c3.rom.api.ld | 6 + components/esp_rom/esp32c3/ld/esp32c3.rom.ld | 4 +- .../esp_rom/esp32h2/ld/esp32h2.rom.api.ld | 3 + components/esp_rom/esp32h2/ld/esp32h2.rom.ld | 4 +- .../esp_rom/esp32s3/ld/esp32s3.rom.api.ld | 5 + components/esp_rom/esp32s3/ld/esp32s3.rom.ld | 4 +- components/esp_rom/include/esp_rom_tjpgd.h | 152 ++++++++++++ .../esp_rom/patches/esp_rom_tjpgd.c | 219 ++++++++++-------- components/esp_rom/test/CMakeLists.txt | 14 +- components/esp_rom/test/test_tjpgd.c | 20 +- .../lcd/tjpgd/components/tjpgd/CMakeLists.txt | 4 - .../lcd/tjpgd/components/tjpgd/component.mk | 3 - .../tjpgd/components/tjpgd/include/tjpgd.h | 88 ------- .../peripherals/lcd/tjpgd/main/CMakeLists.txt | 6 +- .../peripherals/lcd/tjpgd/main/decode_image.c | 12 +- .../lcd/tjpgd/main/pretty_effect.c | 17 -- 18 files changed, 319 insertions(+), 250 deletions(-) create mode 100644 components/esp_rom/include/esp_rom_tjpgd.h rename examples/peripherals/lcd/tjpgd/components/tjpgd/src/tjpgd.c => components/esp_rom/patches/esp_rom_tjpgd.c (84%) delete mode 100644 examples/peripherals/lcd/tjpgd/components/tjpgd/CMakeLists.txt delete mode 100644 examples/peripherals/lcd/tjpgd/components/tjpgd/component.mk delete mode 100644 examples/peripherals/lcd/tjpgd/components/tjpgd/include/tjpgd.h diff --git a/components/esp_rom/CMakeLists.txt b/components/esp_rom/CMakeLists.txt index b8584fe51d..47a8a284d1 100644 --- a/components/esp_rom/CMakeLists.txt +++ b/components/esp_rom/CMakeLists.txt @@ -15,7 +15,8 @@ else() list(APPEND include_dirs "${target}") list(APPEND sources "patches/esp_rom_crc.c" "patches/esp_rom_sys.c" - "patches/esp_rom_uart.c") + "patches/esp_rom_uart.c" + "patches/esp_rom_tjpgd.c") list(APPEND private_required_comp soc hal) endif() diff --git a/components/esp_rom/esp32/ld/esp32.rom.api.ld b/components/esp_rom/esp32/ld/esp32.rom.api.ld index be023b85d3..afd3cc04eb 100644 --- a/components/esp_rom/esp32/ld/esp32.rom.api.ld +++ b/components/esp_rom/esp32/ld/esp32.rom.api.ld @@ -2,6 +2,11 @@ * ROM APIs */ +/* user may provide newer version of tjpgd */ +/* so here directly assign the symbols with the ROM API address to make sure one from rom is correctly linked */ +PROVIDE ( esp_rom_tjpgd_decomp = 0x400613e8 ); +PROVIDE ( esp_rom_tjpgd_prepare = 0x40060fa8 ); + PROVIDE ( esp_rom_crc32_le = crc32_le ); PROVIDE ( esp_rom_crc16_le = crc16_le ); PROVIDE ( esp_rom_crc8_le = crc8_le ); diff --git a/components/esp_rom/esp32c3/ld/esp32c3.rom.api.ld b/components/esp_rom/esp32c3/ld/esp32c3.rom.api.ld index 5530bf0dce..e05d9b8aa4 100644 --- a/components/esp_rom/esp32c3/ld/esp32c3.rom.api.ld +++ b/components/esp_rom/esp32c3/ld/esp32c3.rom.api.ld @@ -1,5 +1,11 @@ /** ROM APIs */ + +/* user may provide newer version of tjpgd */ +/* so here directly assign the symbols with the ROM API address to make sure one from rom is correctly linked */ +PROVIDE ( esp_rom_tjpgd_decomp = 0x40000108 ); +PROVIDE ( esp_rom_tjpgd_prepare = 0x40000104 ); + PROVIDE ( esp_rom_crc32_le = crc32_le ); PROVIDE ( esp_rom_crc16_le = crc16_le ); PROVIDE ( esp_rom_crc8_le = crc8_le ); diff --git a/components/esp_rom/esp32c3/ld/esp32c3.rom.ld b/components/esp_rom/esp32c3/ld/esp32c3.rom.ld index a146d8f39d..4b42f866e5 100644 --- a/components/esp_rom/esp32c3/ld/esp32c3.rom.ld +++ b/components/esp_rom/esp32c3/ld/esp32c3.rom.ld @@ -89,8 +89,8 @@ tinfl_decompress_mem_to_mem = 0x40000100; ***************************************/ /* Functions */ -jd_prepare = 0x40000104; -jd_decomp = 0x40000108; +PROVIDE( jd_prepare = 0x40000104 ); +PROVIDE( jd_decomp = 0x40000108 ); /*************************************** diff --git a/components/esp_rom/esp32h2/ld/esp32h2.rom.api.ld b/components/esp_rom/esp32h2/ld/esp32h2.rom.api.ld index 5530bf0dce..588ac6b179 100644 --- a/components/esp_rom/esp32h2/ld/esp32h2.rom.api.ld +++ b/components/esp_rom/esp32h2/ld/esp32h2.rom.api.ld @@ -1,5 +1,8 @@ /** ROM APIs */ +PROVIDE ( esp_rom_tjpgd_decomp = 0x40000104 ); +PROVIDE ( esp_rom_tjpgd_prepare = 0x40000100 ); + PROVIDE ( esp_rom_crc32_le = crc32_le ); PROVIDE ( esp_rom_crc16_le = crc16_le ); PROVIDE ( esp_rom_crc8_le = crc8_le ); diff --git a/components/esp_rom/esp32h2/ld/esp32h2.rom.ld b/components/esp_rom/esp32h2/ld/esp32h2.rom.ld index acd5821d5a..fefad99c3d 100644 --- a/components/esp_rom/esp32h2/ld/esp32h2.rom.ld +++ b/components/esp_rom/esp32h2/ld/esp32h2.rom.ld @@ -88,8 +88,8 @@ tinfl_decompress_mem_to_mem = 0x400000fc; ***************************************/ /* Functions */ -jd_prepare = 0x40000100; -jd_decomp = 0x40000104; +PROVIDE( jd_prepare = 0x40000100 ); +PROVIDE( jd_decomp = 0x40000104 ); /*************************************** diff --git a/components/esp_rom/esp32s3/ld/esp32s3.rom.api.ld b/components/esp_rom/esp32s3/ld/esp32s3.rom.api.ld index 6d3b6d1b9f..4d45188393 100644 --- a/components/esp_rom/esp32s3/ld/esp32s3.rom.api.ld +++ b/components/esp_rom/esp32s3/ld/esp32s3.rom.api.ld @@ -2,6 +2,11 @@ * ROM APIs */ +/* user may provide newer version of tjpgd */ +/* so here directly assign the symbols with the ROM API address to make sure one from rom is correctly linked */ +PROVIDE ( esp_rom_tjpgd_decomp = 0x40000864 ); +PROVIDE ( esp_rom_tjpgd_prepare = 0x40000858 ); + PROVIDE ( esp_rom_crc32_le = crc32_le ); PROVIDE ( esp_rom_crc16_le = crc16_le ); PROVIDE ( esp_rom_crc8_le = crc8_le ); diff --git a/components/esp_rom/esp32s3/ld/esp32s3.rom.ld b/components/esp_rom/esp32s3/ld/esp32s3.rom.ld index 556b3eecc0..f78625b3b8 100644 --- a/components/esp_rom/esp32s3/ld/esp32s3.rom.ld +++ b/components/esp_rom/esp32s3/ld/esp32s3.rom.ld @@ -91,8 +91,8 @@ tinfl_decompress_mem_to_mem = 0x4000084c; ***************************************/ /* Functions */ -jd_prepare = 0x40000858; -jd_decomp = 0x40000864; +PROVIDE( jd_prepare = 0x40000858 ); +PROVIDE (jd_decomp = 0x40000864 ); /*************************************** diff --git a/components/esp_rom/include/esp_rom_tjpgd.h b/components/esp_rom/include/esp_rom_tjpgd.h new file mode 100644 index 0000000000..318519ba74 --- /dev/null +++ b/components/esp_rom/include/esp_rom_tjpgd.h @@ -0,0 +1,152 @@ +/* + * SPDX-FileCopyrightText: 2015-2021 Espressif Systems (Shanghai) CO LTD + * + * SPDX-License-Identifier: Apache-2.0 + */ + +/*-----------------------------------------------------------------------------/ +/ TJpgDec - Tiny JPEG Decompressor R0.01b (C)ChaN, 2012 +/-----------------------------------------------------------------------------/ +/ The TJpgDec is a generic JPEG decompressor module for tiny embedded systems. +/ This is a free software that opened for education, research and commercial +/ developments under license policy of following terms. +/ +/ Copyright (C) 2012, ChaN, all right reserved. +/ +/ * The TJpgDec module is a free software and there is NO WARRANTY. +/ * No restriction on use. You can use, modify and redistribute it for +/ personal, non-profit or commercial products UNDER YOUR RESPONSIBILITY. +/ * Redistributions of source code must retain the above copyright notice. +/ +/-----------------------------------------------------------------------------*/ + +#pragma once + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* Error code */ +typedef enum { + JDR_OK = 0, /* 0: Succeeded */ + JDR_INTR, /* 1: Interrupted by output function */ + JDR_INP, /* 2: Device error or wrong termination of input stream */ + JDR_MEM1, /* 3: Insufficient memory pool for the image */ + JDR_MEM2, /* 4: Insufficient stream input buffer */ + JDR_PAR, /* 5: Parameter error */ + JDR_FMT1, /* 6: Data format error (may be damaged data) */ + JDR_FMT2, /* 7: Right format but not supported */ + JDR_FMT3 /* 8: Not supported JPEG standard */ +} esp_rom_tjpgd_result_t; + +/* Rectangular structure */ +typedef struct { + uint16_t left; /* Left end */ + uint16_t right; /* Right end */ + uint16_t top; /* Top end */ + uint16_t bottom;/* Bottom end */ +} esp_rom_tjpgd_rect_t; + +typedef struct JDEC_s esp_rom_tjpgd_dec_t; + +/** + * @brief Type of user defined input function to read data from input stream + * @param dec Specifies the decompression object of the decompression session + * @param buffer Specifies the pointer to the read buffer to store the read data. A NULL specifies to remove the data from input stream + * @param ndata Specifies number of bytes to read/remove from the input stream + * + * @return number of bytes read/removed. When a zero is returned, the esp_rom_tjpgd_prepare and esp_rom_tjpgd_decomp function aborts with JDR_INP + */ +typedef uint32_t (*esp_rom_tjpgd_input_function_t)(esp_rom_tjpgd_dec_t *dec, uint8_t *buffer, uint32_t ndata); + +/** + * @brief User defined output function to write decompressed pixels to the output device + * + * This function is the data output interface of the TJpgDec module. + * The corresponding decompression session can be identified by the pointer to the device identifier jdec->device passed to the 5th argument of jd_prepare function. + * The bitmap is sent to the frame buffer or display device in this function. + * The first pixel in the bitmap is the left-top of the rectangular, the second one is next right and last pixel is the bottom-right of the rectangular. + * The size of rectangular varies from 1x1 to 16x16 depends on clipping, scaling and sampling factor of the image. + * If the rectangular is out of the frame buffer, it should be clipped in this function. + * + * The pixel format is currently configured to RGB888 + * + * @param dec Specifies the decompression object of the decompression session + * @param bitmap Specifies the RGB bitmap to be output + * @param rect Specifies rectangular region in the image to output the RGB bitmap + * + * @return Normally returns 1. It lets TJpgDec to continue the decompressing process. + * When a 0 is returned, the esp_rom_tjpgd_decomp function aborts with JDR_INTR. + * This is useful to interrupt the decompression process + */ +typedef uint32_t (*esp_rom_tjpgd_output_function_t)(esp_rom_tjpgd_dec_t *dec, void *bitmap, esp_rom_tjpgd_rect_t *rect); + +struct JDEC_s { + uint32_t dctr; /* Number of bytes available in the input buffer */ + uint8_t *dptr; /* Current data read ptr */ + uint8_t *inbuf; /* Bit stream input buffer */ + uint8_t dmsk; /* Current bit in the current read byte */ + uint8_t scale; /* Output scaling ratio */ + uint8_t msx, msy; /* MCU size in unit of block (width, height) */ + uint8_t qtid[3]; /* Quantization table ID of each component */ + int16_t dcv[3]; /* Previous DC element of each component */ + uint16_t nrst; /* Restart inverval */ + uint32_t width, height; /* Size of the input image (pixel) */ + uint8_t *huffbits[2][2]; /* Huffman bit distribution tables [id][dcac] */ + uint16_t *huffcode[2][2]; /* Huffman code word tables [id][dcac] */ + uint8_t *huffdata[2][2]; /* Huffman decoded data tables [id][dcac] */ + int32_t *qttbl[4]; /* Dequaitizer tables [id] */ + void *workbuf; /* Working buffer for IDCT and RGB output */ + uint8_t *mcubuf; /* Working buffer for the MCU */ + void *pool; /* Pointer to available memory pool */ + uint32_t sz_pool; /* Size of momory pool (bytes available) */ + esp_rom_tjpgd_input_function_t infunc; /* Pointer to jpeg stream input function */ + void *device; /* Pointer to I/O device identifiler for the session */ +}; + +/* TJpgDec API functions */ + +/** + * @brief Analyzes the JPEG data and create a decompression object for subsequent decompression process. + * @param dec Specifies the decompression object to be initialized. The decompression object is used for subsequent decompression process. + * @param infunc Specifies the user defined data input function. + * @param work Specifies pointer to the work area for this session. It should be aligned to word boundary or it can result an exception. + * @param sz_work Specifies size of the work area in unit of byte. + * TJpgDec requires upto 3092 bytes of work area depends on the built-in parameter tables of the JPEG image. + * Thus 3092 bytes of work area is sufficient for most case. + * @param dev Specifies pointer to the user defined device identifier for this session. + * It is stored to the member device in the decompression object. It can be referred by I/O functions to identify the current session. + * When I/O device is fixed in the project or this feature is not needed, set NULL and do not care about this. + * + * @return + * - JDR_OK Function succeeded and decompression object is valid. + * - JDR_INP An error occurred in input function due to hard error or wrong stream termination. + * - JDR_MEM1 Insufficient work area for this JPEG image. + * - JDR_MEM2 Insufficient input buffer for this JPEG image. JD_SZBUF may be too small. + * - JDR_PAR Parameter error. Given pointer to the work area is NULL. + * - JDR_FMT1 Data format error. The JPEG data can be collapsed. + * - JDR_FMT2 Right format but not supported. May be a grayscale image. + * - JDR_FMT3 Not supported JPEG standard. May be a progressive JPEG image. + */ +esp_rom_tjpgd_result_t esp_rom_tjpgd_prepare(esp_rom_tjpgd_dec_t *dec, esp_rom_tjpgd_input_function_t infunc, void *work, uint32_t sz_work, void *dev); + +/** + * @brief Decompress the JPEG image and output it as RGB data. + * @param dec Specifies the valid decompressor object. + * @param outfunc Specifies the user defined data output function. The esp_rom_tjpgd_decomp function calls this function to output the decompressed JPEG image in RGB form. + * @param scale Specifies scaling factor N for output. The output image is descaled to 1 / 2 ^ N (N = 0 to 3). + * + * @return + * - JDR_OK Function succeeded. + * - JDR_INTR The decompression process is interrupted by output function. + * - JDR_INP An error occured in input function due to hard error or wrong stream termination. + * - JDR_PAR Parameter error. Given scale factor is invalid. + * - JDR_FMT1 Data format error. The JPEG data can be collapted. + */ +esp_rom_tjpgd_result_t esp_rom_tjpgd_decomp(esp_rom_tjpgd_dec_t *dec, esp_rom_tjpgd_output_function_t outfunc, uint8_t scale); + +#ifdef __cplusplus +} +#endif diff --git a/examples/peripherals/lcd/tjpgd/components/tjpgd/src/tjpgd.c b/components/esp_rom/patches/esp_rom_tjpgd.c similarity index 84% rename from examples/peripherals/lcd/tjpgd/components/tjpgd/src/tjpgd.c rename to components/esp_rom/patches/esp_rom_tjpgd.c index 276dc1932c..8e0b8d2713 100644 --- a/examples/peripherals/lcd/tjpgd/components/tjpgd/src/tjpgd.c +++ b/components/esp_rom/patches/esp_rom_tjpgd.c @@ -1,11 +1,11 @@ /*----------------------------------------------------------------------------/ -/ TJpgDec - Tiny JPEG Decompressor R0.01c (C)ChaN, 2019 +/ TJpgDec - Tiny JPEG Decompressor R0.01b (C)ChaN, 2012 /-----------------------------------------------------------------------------/ / The TJpgDec is a generic JPEG decompressor module for tiny embedded systems. / This is a free software that opened for education, research and commercial / developments under license policy of following terms. / -/ Copyright (C) 2019, ChaN, all right reserved. +/ Copyright (C) 2012, ChaN, all right reserved. / / * The TJpgDec module is a free software and there is NO WARRANTY. / * No restriction on use. You can use, modify and redistribute it for @@ -13,13 +13,21 @@ / * Redistributions of source code must retain the above copyright notice. / /-----------------------------------------------------------------------------/ -/ Oct 04, 2011 R0.01 First release. -/ Feb 19, 2012 R0.01a Fixed decompression fails when scan starts with an escape seq. -/ Sep 03, 2012 R0.01b Added JD_TBLCLIP option. -/ Mar 16, 2019 R0.01c Supprted stdint.h. +/ Oct 04,'11 R0.01 First release. +/ Feb 19,'12 R0.01a Fixed decompression fails when scan starts with an escape seq. +/ Sep 03,'12 R0.01b Added JD_TBLCLIP option. /----------------------------------------------------------------------------*/ -#include "tjpgd.h" +#include "esp_rom_caps.h" + +#if !ESP_ROM_HAS_JPEG_DECODE + +#include "esp_rom_tjpgd.h" + +#define JD_SZBUF 512 /* Size of stream input buffer */ +#define JD_FORMAT 0 /* Output pixel format 0:RGB888 (3 BYTE/pix), 1:RGB565 (1 WORD/pix) */ +#define JD_USE_SCALE 1 /* Use descaling feature for output */ +#define JD_TBLCLIP 1 /* Use table for saturation (might be a bit faster but increases 1K bytes of code size) */ /*-----------------------------------------------*/ @@ -28,7 +36,8 @@ #define ZIG(n) Zig[n] -static const uint8_t Zig[64] = { /* Zigzag-order to raster-order conversion table */ +static +const uint8_t Zig[64] = { /* Zigzag-order to raster-order conversion table */ 0, 1, 8, 16, 9, 2, 3, 10, 17, 24, 32, 25, 18, 11, 4, 5, 12, 19, 26, 33, 40, 48, 41, 34, 27, 20, 13, 6, 7, 14, 21, 28, 35, 42, 49, 56, 57, 50, 43, 36, 29, 22, 15, 23, 30, 37, 44, 51, @@ -44,7 +53,8 @@ static const uint8_t Zig[64] = { /* Zigzag-order to raster-order conversion tabl #define IPSF(n) Ipsf[n] -static const uint16_t Ipsf[64] = { /* See also aa_idct.png */ +static +const uint16_t Ipsf[64] = { /* See also aa_idct.png */ (uint16_t)(1.00000*8192), (uint16_t)(1.38704*8192), (uint16_t)(1.30656*8192), (uint16_t)(1.17588*8192), (uint16_t)(1.00000*8192), (uint16_t)(0.78570*8192), (uint16_t)(0.54120*8192), (uint16_t)(0.27590*8192), (uint16_t)(1.38704*8192), (uint16_t)(1.92388*8192), (uint16_t)(1.81226*8192), (uint16_t)(1.63099*8192), (uint16_t)(1.38704*8192), (uint16_t)(1.08979*8192), (uint16_t)(0.75066*8192), (uint16_t)(0.38268*8192), (uint16_t)(1.30656*8192), (uint16_t)(1.81226*8192), (uint16_t)(1.70711*8192), (uint16_t)(1.53636*8192), (uint16_t)(1.30656*8192), (uint16_t)(1.02656*8192), (uint16_t)(0.70711*8192), (uint16_t)(0.36048*8192), @@ -63,9 +73,10 @@ static const uint16_t Ipsf[64] = { /* See also aa_idct.png */ #if JD_TBLCLIP -#define BYTECLIP(v) Clip8[(uint16_t)(v) & 0x3FF] +#define BYTECLIP(v) Clip8[(uint32_t)(v) & 0x3FF] -static const uint8_t Clip8[1024] = { +static +const uint8_t Clip8[1024] = { /* 0..255 */ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, @@ -106,8 +117,9 @@ static const uint8_t Clip8[1024] = { #else /* JD_TBLCLIP */ -inline uint8_t BYTECLIP ( - int16_t val +inline +uint8_t BYTECLIP ( + int32_t val ) { if (val < 0) val = 0; @@ -124,9 +136,10 @@ inline uint8_t BYTECLIP ( /* Allocate a memory block from memory pool */ /*-----------------------------------------------------------------------*/ -static void* alloc_pool ( /* Pointer to allocated memory block (NULL:no memory available) */ - JDEC* jd, /* Pointer to the decompressor object */ - uint16_t nd /* Number of bytes to allocate */ +static +void* alloc_pool ( /* Pointer to allocated memory block (NULL:no memory available) */ + esp_rom_tjpgd_dec_t* jd, /* Pointer to the decompressor object */ + uint32_t nd /* Number of bytes to allocate */ ) { char *rp = 0; @@ -150,13 +163,14 @@ static void* alloc_pool ( /* Pointer to allocated memory block (NULL:no memory a /* Create de-quantization and prescaling tables with a DQT segment */ /*-----------------------------------------------------------------------*/ -static int create_qt_tbl ( /* 0:OK, !0:Failed */ - JDEC* jd, /* Pointer to the decompressor object */ +static +uint32_t create_qt_tbl ( /* 0:OK, !0:Failed */ + esp_rom_tjpgd_dec_t* jd, /* Pointer to the decompressor object */ const uint8_t* data, /* Pointer to the quantizer tables */ - uint16_t ndata /* Size of input data */ + uint32_t ndata /* Size of input data */ ) { - uint16_t i; + uint32_t i; uint8_t d, z; int32_t *pb; @@ -186,13 +200,14 @@ static int create_qt_tbl ( /* 0:OK, !0:Failed */ /* Create huffman code tables with a DHT segment */ /*-----------------------------------------------------------------------*/ -static int create_huffman_tbl ( /* 0:OK, !0:Failed */ - JDEC* jd, /* Pointer to the decompressor object */ +static +uint32_t create_huffman_tbl ( /* 0:OK, !0:Failed */ + esp_rom_tjpgd_dec_t* jd, /* Pointer to the decompressor object */ const uint8_t* data, /* Pointer to the packed huffman tables */ - uint16_t ndata /* Size of input data */ + uint32_t ndata /* Size of input data */ ) { - uint16_t i, j, b, np, cls, num; + uint32_t i, j, b, np, cls, num; uint8_t d, *pb, *pd; uint16_t hc, *ph; @@ -201,15 +216,17 @@ static int create_huffman_tbl ( /* 0:OK, !0:Failed */ if (ndata < 17) return JDR_FMT1; /* Err: wrong data size */ ndata -= 17; d = *data++; /* Get table number and class */ + cls = (d >> 4); num = d & 0x0F; /* class = dc(0)/ac(1), table number = 0/1 */ if (d & 0xEE) return JDR_FMT1; /* Err: invalid class/number */ - cls = d >> 4; num = d & 0x0F; /* class = dc(0)/ac(1), table number = 0/1 */ pb = alloc_pool(jd, 16); /* Allocate a memory block for the bit distribution table */ if (!pb) return JDR_MEM1; /* Err: not enough memory */ jd->huffbits[num][cls] = pb; for (np = i = 0; i < 16; i++) { /* Load number of patterns for 1 to 16-bit code */ - np += (pb[i] = *data++); /* Get sum of code words for each code */ + pb[i] = b = *data++; + np += b; /* Get sum of code words for each code */ } - ph = alloc_pool(jd, (uint16_t)(np * sizeof (uint16_t)));/* Allocate a memory block for the code word table */ + + ph = alloc_pool(jd, np * sizeof (uint16_t));/* Allocate a memory block for the code word table */ if (!ph) return JDR_MEM1; /* Err: not enough memory */ jd->huffcode[num][cls] = ph; hc = 0; @@ -241,13 +258,14 @@ static int create_huffman_tbl ( /* 0:OK, !0:Failed */ /* Extract N bits from input stream */ /*-----------------------------------------------------------------------*/ -static int bitext ( /* >=0: extracted data, <0: error code */ - JDEC* jd, /* Pointer to the decompressor object */ - int nbit /* Number of bits to extract (1 to 11) */ +static +int32_t bitext ( /* >=0: extracted data, <0: error code */ + esp_rom_tjpgd_dec_t* jd, /* Pointer to the decompressor object */ + uint32_t nbit /* Number of bits to extract (1 to 11) */ ) { uint8_t msk, s, *dp; - uint16_t dc, v, f; + uint32_t dc, v, f; msk = jd->dmsk; dc = jd->dctr; dp = jd->dptr; /* Bit mask, number of data available, read ptr */ @@ -257,14 +275,14 @@ static int bitext ( /* >=0: extracted data, <0: error code */ if (!dc) { /* No input data is available, re-fill input buffer */ dp = jd->inbuf; /* Top of input buffer */ dc = jd->infunc(jd, dp, JD_SZBUF); - if (!dc) return 0 - (int16_t)JDR_INP; /* Err: read error or wrong stream termination */ + if (!dc) return 0 - (int32_t)JDR_INP; /* Err: read error or wrong stream termination */ } else { dp++; /* Next data ptr */ } dc--; /* Decrement number of available bytes */ if (f) { /* In flag sequence? */ f = 0; /* Exit flag sequence */ - if (*dp != 0) return 0 - (int16_t)JDR_FMT1; /* Err: unexpected flag is detected (may be collapted data) */ + if (*dp != 0) return 0 - (int32_t)JDR_FMT1; /* Err: unexpected flag is detected (may be collapted data) */ *dp = s = 0xFF; /* The flag is a data 0xFF */ } else { s = *dp; /* Get next data byte */ @@ -281,7 +299,7 @@ static int bitext ( /* >=0: extracted data, <0: error code */ } while (nbit); jd->dmsk = msk; jd->dctr = dc; jd->dptr = dp; - return (int)v; + return (int32_t)v; } @@ -291,15 +309,16 @@ static int bitext ( /* >=0: extracted data, <0: error code */ /* Extract a huffman decoded data from input stream */ /*-----------------------------------------------------------------------*/ -static int16_t huffext ( /* >=0: decoded data, <0: error code */ - JDEC* jd, /* Pointer to the decompressor object */ +static +int32_t huffext ( /* >=0: decoded data, <0: error code */ + esp_rom_tjpgd_dec_t* jd, /* Pointer to the decompressor object */ const uint8_t* hbits, /* Pointer to the bit distribution table */ const uint16_t* hcode, /* Pointer to the code word table */ const uint8_t* hdata /* Pointer to the data table */ ) { uint8_t msk, s, *dp; - uint16_t dc, v, f, bl, nd; + uint32_t dc, v, f, bl, nd; msk = jd->dmsk; dc = jd->dctr; dp = jd->dptr; /* Bit mask, number of data available, read ptr */ @@ -310,14 +329,15 @@ static int16_t huffext ( /* >=0: decoded data, <0: error code */ if (!dc) { /* No input data is available, re-fill input buffer */ dp = jd->inbuf; /* Top of input buffer */ dc = jd->infunc(jd, dp, JD_SZBUF); - if (!dc) return 0 - (int16_t)JDR_INP; /* Err: read error or wrong stream termination */ + if (!dc) return 0 - (int32_t)JDR_INP; /* Err: read error or wrong stream termination */ } else { dp++; /* Next data ptr */ } dc--; /* Decrement number of available bytes */ if (f) { /* In flag sequence? */ f = 0; /* Exit flag sequence */ - if (*dp != 0) return 0 - (int16_t)JDR_FMT1; /* Err: unexpected flag is detected (may be collapted data) */ + if (*dp != 0) + return 0 - (int32_t)JDR_FMT1; /* Err: unexpected flag is detected (may be collapted data) */ *dp = s = 0xFF; /* The flag is a data 0xFF */ } else { s = *dp; /* Get next data byte */ @@ -341,7 +361,7 @@ static int16_t huffext ( /* >=0: decoded data, <0: error code */ bl--; } while (bl); - return 0 - (int16_t)JDR_FMT1; /* Err: code not found (may be collapted data) */ + return 0 - (int32_t)JDR_FMT1; /* Err: code not found (may be collapted data) */ } @@ -351,7 +371,8 @@ static int16_t huffext ( /* >=0: decoded data, <0: error code */ /* Apply Inverse-DCT in Arai Algorithm (see also aa_idct.png) */ /*-----------------------------------------------------------------------*/ -static void block_idct ( +static +void block_idct ( int32_t* src, /* Input block data (de-quantized and pre-scaled for Arai Algorithm) */ uint8_t* dst /* Pointer to the destination to store the block as byte array */ ) @@ -359,7 +380,7 @@ static void block_idct ( const int32_t M13 = (int32_t)(1.41421*4096), M2 = (int32_t)(1.08239*4096), M4 = (int32_t)(2.61313*4096), M5 = (int32_t)(1.84776*4096); int32_t v0, v1, v2, v3, v4, v5, v6, v7; int32_t t10, t11, t12, t13; - uint16_t i; + uint32_t i; /* Process columns */ for (i = 0; i < 8; i++) { @@ -463,13 +484,14 @@ static void block_idct ( /* Load all blocks in the MCU into working buffer */ /*-----------------------------------------------------------------------*/ -static JRESULT mcu_load ( - JDEC* jd /* Pointer to the decompressor object */ +static +esp_rom_tjpgd_result_t mcu_load ( + esp_rom_tjpgd_dec_t* jd /* Pointer to the decompressor object */ ) { int32_t *tmp = (int32_t*)jd->workbuf; /* Block working buffer for de-quantize and IDCT */ - int b, d, e; - uint16_t blk, nby, nbc, i, z, id, cmp; + uint32_t blk, nby, nbc, i, z, id, cmp; + int32_t b, d, e; uint8_t *bp; const uint8_t *hb, *hd; const uint16_t *hc; @@ -503,7 +525,7 @@ static JRESULT mcu_load ( tmp[0] = d * dqf[0] >> 8; /* De-quantize, apply scale factor of Arai algorithm and descale 8 bits */ /* Extract following 63 AC elements from input stream */ - for (i = 1; i < 64; tmp[i++] = 0) ; /* Clear rest of elements */ + for (i = 1; i < 64; i++) tmp[i] = 0; /* Clear rest of elements */ hb = jd->huffbits[id][1]; /* Huffman table for the AC elements */ hc = jd->huffcode[id][1]; hd = jd->huffdata[id][1]; @@ -512,7 +534,7 @@ static JRESULT mcu_load ( b = huffext(jd, hb, hc, hd); /* Extract a huffman coded value (zero runs and bit length) */ if (b == 0) break; /* EOB? */ if (b < 0) return 0 - b; /* Err: invalid code or input error */ - z = (uint16_t)b >> 4; /* Number of leading zero elements */ + z = (uint32_t)b >> 4; /* Number of leading zero elements */ if (z) { i += z; /* Skip zero elements */ if (i >= 64) return JDR_FMT1; /* Too long zero run */ @@ -527,11 +549,10 @@ static JRESULT mcu_load ( } } while (++i < 64); /* Next AC element */ - if (JD_USE_SCALE && jd->scale == 3) { - *bp = (uint8_t)((*tmp / 256) + 128); /* If scale ratio is 1/8, IDCT can be ommited and only DC element is used */ - } else { + if (JD_USE_SCALE && jd->scale == 3) + *bp = (*tmp / 256) + 128; /* If scale ratio is 1/8, IDCT can be ommited and only DC element is used */ + else block_idct(tmp, bp); /* Apply IDCT and store the block to the MCU buffer */ - } bp += 64; /* Next block */ } @@ -546,18 +567,19 @@ static JRESULT mcu_load ( /* Output an MCU: Convert YCrCb to RGB and output it in RGB form */ /*-----------------------------------------------------------------------*/ -static JRESULT mcu_output ( - JDEC* jd, /* Pointer to the decompressor object */ - uint16_t (*outfunc)(JDEC*, void*, JRECT*), /* RGB output function */ - uint16_t x, /* MCU position in the image (left of the MCU) */ - uint16_t y /* MCU position in the image (top of the MCU) */ +static +esp_rom_tjpgd_result_t mcu_output ( + esp_rom_tjpgd_dec_t* jd, /* Pointer to the decompressor object */ + uint32_t (*outfunc)(esp_rom_tjpgd_dec_t*, void*, esp_rom_tjpgd_rect_t*), /* RGB output function */ + uint32_t x, /* MCU position in the image (left of the MCU) */ + uint32_t y /* MCU position in the image (top of the MCU) */ ) { - const int16_t CVACC = (sizeof (int16_t) > 2) ? 1024 : 128; - uint16_t ix, iy, mx, my, rx, ry; - int16_t yy, cb, cr; + const int32_t CVACC = (sizeof (int32_t) > 2) ? 1024 : 128; + uint32_t ix, iy, mx, my, rx, ry; + int32_t yy, cb, cr; uint8_t *py, *pc, *rgb24; - JRECT rect; + esp_rom_tjpgd_rect_t rect; mx = jd->msx * 8; my = jd->msy * 8; /* MCU size (pixel) */ @@ -597,15 +619,15 @@ static JRESULT mcu_output ( yy = *py++; /* Get Y component */ /* Convert YCbCr to RGB */ - *rgb24++ = /* R */ BYTECLIP(yy + ((int16_t)(1.402 * CVACC) * cr) / CVACC); - *rgb24++ = /* G */ BYTECLIP(yy - ((int16_t)(0.344 * CVACC) * cb + (int16_t)(0.714 * CVACC) * cr) / CVACC); - *rgb24++ = /* B */ BYTECLIP(yy + ((int16_t)(1.772 * CVACC) * cb) / CVACC); + *rgb24++ = /* R */ BYTECLIP(yy + ((int32_t)(1.402 * CVACC) * cr) / CVACC); + *rgb24++ = /* G */ BYTECLIP(yy - ((int32_t)(0.344 * CVACC) * cb + (int32_t)(0.714 * CVACC) * cr) / CVACC); + *rgb24++ = /* B */ BYTECLIP(yy + ((int32_t)(1.772 * CVACC) * cb) / CVACC); } } /* Descale the MCU rectangular if needed */ if (JD_USE_SCALE && jd->scale) { - uint16_t x, y, r, g, b, s, w, a; + uint32_t x, y, r, g, b, s, w, a; uint8_t *op; /* Get averaged RGB value of each square correcponds to a pixel */ @@ -647,9 +669,9 @@ static JRESULT mcu_output ( py += 64; /* Convert YCbCr to RGB */ - *rgb24++ = /* R */ BYTECLIP(yy + ((int16_t)(1.402 * CVACC) * cr / CVACC)); - *rgb24++ = /* G */ BYTECLIP(yy - ((int16_t)(0.344 * CVACC) * cb + (int16_t)(0.714 * CVACC) * cr) / CVACC); - *rgb24++ = /* B */ BYTECLIP(yy + ((int16_t)(1.772 * CVACC) * cb / CVACC)); + *rgb24++ = /* R */ BYTECLIP(yy + ((int32_t)(1.402 * CVACC) * cr / CVACC)); + *rgb24++ = /* G */ BYTECLIP(yy - ((int32_t)(0.344 * CVACC) * cb + (int32_t)(0.714 * CVACC) * cr) / CVACC); + *rgb24++ = /* B */ BYTECLIP(yy + ((int32_t)(1.772 * CVACC) * cb / CVACC)); } } } @@ -658,7 +680,7 @@ static JRESULT mcu_output ( mx >>= jd->scale; if (rx < mx) { uint8_t *s, *d; - uint16_t x, y; + uint32_t x, y; s = d = (uint8_t*)jd->workbuf; for (y = 0; y < ry; y++) { @@ -675,7 +697,7 @@ static JRESULT mcu_output ( if (JD_FORMAT == 1) { uint8_t *s = (uint8_t*)jd->workbuf; uint16_t w, *d = (uint16_t*)s; - uint16_t n = rx * ry; + uint32_t n = rx * ry; do { w = (*s++ & 0xF8) << 8; /* RRRRR----------- */ @@ -696,12 +718,13 @@ static JRESULT mcu_output ( /* Process restart interval */ /*-----------------------------------------------------------------------*/ -static JRESULT restart ( - JDEC* jd, /* Pointer to the decompressor object */ +static +esp_rom_tjpgd_result_t restart ( + esp_rom_tjpgd_dec_t* jd, /* Pointer to the decompressor object */ uint16_t rstn /* Expected restert sequense number */ ) { - uint16_t i, dc; + uint32_t i, dc; uint16_t d; uint8_t *dp; @@ -723,9 +746,8 @@ static JRESULT restart ( jd->dptr = dp; jd->dctr = dc; jd->dmsk = 0; /* Check the marker */ - if ((d & 0xFFD8) != 0xFFD0 || (d & 7) != (rstn & 7)) { + if ((d & 0xFFD8) != 0xFFD0 || (d & 7) != (rstn & 7)) return JDR_FMT1; /* Err: expected RSTn marker is not detected (may be collapted data) */ - } /* Reset DC offset */ jd->dcv[2] = jd->dcv[1] = jd->dcv[0] = 0; @@ -743,19 +765,19 @@ static JRESULT restart ( #define LDB_WORD(ptr) (uint16_t)(((uint16_t)*((uint8_t*)(ptr))<<8)|(uint16_t)*(uint8_t*)((ptr)+1)) -JRESULT jd_prepare ( - JDEC* jd, /* Blank decompressor object */ - uint16_t (*infunc)(JDEC*, uint8_t*, uint16_t), /* JPEG strem input function */ +esp_rom_tjpgd_result_t esp_rom_tjpgd_prepare ( + esp_rom_tjpgd_dec_t* jd, /* Blank decompressor object */ + uint32_t (*infunc)(esp_rom_tjpgd_dec_t*, uint8_t*, uint32_t), /* JPEG strem input function */ void* pool, /* Working buffer for the decompression session */ - uint16_t sz_pool, /* Size of working buffer */ + uint32_t sz_pool, /* Size of working buffer */ void* dev /* I/O device identifier for the session */ ) { uint8_t *seg, b; uint16_t marker; uint32_t ofs; - uint16_t n, i, j, len; - JRESULT rc; + uint32_t n, i, j, len; + esp_rom_tjpgd_result_t rc; if (!pool) return JDR_PAR; @@ -773,7 +795,7 @@ JRESULT jd_prepare ( jd->huffdata[i][j] = 0; } } - for (i = 0; i < 4; jd->qttbl[i++] = 0) ; + for (i = 0; i < 4; i++) jd->qttbl[i] = 0; jd->inbuf = seg = alloc_pool(jd, JD_SZBUF); /* Allocate stream input buffer */ if (!seg) return JDR_MEM1; @@ -805,9 +827,8 @@ JRESULT jd_prepare ( for (i = 0; i < 3; i++) { b = seg[7 + 3 * i]; /* Get sampling factor */ if (!i) { /* Y component */ - if (b != 0x11 && b != 0x22 && b != 0x21) { /* Check sampling factor */ + if (b != 0x11 && b != 0x22 && b != 0x21)/* Check sampling factor */ return JDR_FMT3; /* Err: Supports only 4:4:4, 4:2:0 or 4:2:2 */ - } jd->msx = b >> 4; jd->msy = b & 15; /* Size of MCU [blocks] */ } else { /* Cb/Cr component */ if (b != 0x11) return JDR_FMT3; /* Err: Sampling factor of Cr/Cb must be 1 */ @@ -861,12 +882,9 @@ JRESULT jd_prepare ( b = seg[2 + 2 * i]; /* Get huffman table ID */ if (b != 0x00 && b != 0x11) return JDR_FMT3; /* Err: Different table number for DC/AC element */ b = i ? 1 : 0; - if (!jd->huffbits[b][0] || !jd->huffbits[b][1]) { /* Check dc/ac huffman table for this component */ - return JDR_FMT1; /* Err: Nnot loaded */ - } - if (!jd->qttbl[jd->qtid[i]]) { /* Check dequantizer table for this component */ - return JDR_FMT1; /* Err: Not loaded */ - } + if (!jd->huffbits[b][0] || !jd->huffbits[b][1]) /* Check huffman table for this component */ + return JDR_FMT1; /* Err: Huffman table not loaded */ + if (!jd->qttbl[jd->qtid[i]]) return JDR_FMT1; /* Err: Dequantizer table not loaded */ } /* Allocate working buffer for MCU and RGB */ @@ -876,13 +894,13 @@ JRESULT jd_prepare ( if (len < 256) len = 256; /* but at least 256 byte is required for IDCT */ jd->workbuf = alloc_pool(jd, len); /* and it may occupy a part of following MCU working buffer for RGB output */ if (!jd->workbuf) return JDR_MEM1; /* Err: not enough memory */ - jd->mcubuf = (uint8_t*)alloc_pool(jd, (uint16_t)((n + 2) * 64)); /* Allocate MCU working buffer */ + jd->mcubuf = alloc_pool(jd, (n + 2) * 64); /* Allocate MCU working buffer */ if (!jd->mcubuf) return JDR_MEM1; /* Err: not enough memory */ /* Pre-load the JPEG data to extract it from the bit stream */ jd->dptr = seg; jd->dctr = 0; jd->dmsk = 0; /* Prepare to read bit stream */ if (ofs %= JD_SZBUF) { /* Align read offset to JD_SZBUF */ - jd->dctr = jd->infunc(jd, seg + ofs, (uint16_t)(JD_SZBUF - ofs)); + jd->dctr = jd->infunc(jd, seg + ofs, JD_SZBUF - (uint32_t)ofs); jd->dptr = seg + ofs - 1; } @@ -905,9 +923,8 @@ JRESULT jd_prepare ( default: /* Unknown segment (comment, exif or etc..) */ /* Skip segment data */ - if (jd->infunc(jd, 0, len) != len) { /* Null pointer specifies to skip bytes of stream */ + if (jd->infunc(jd, 0, len) != len) /* Null pointer specifies to skip bytes of stream */ return JDR_INP; - } } } } @@ -919,15 +936,15 @@ JRESULT jd_prepare ( /* Start to decompress the JPEG picture */ /*-----------------------------------------------------------------------*/ -JRESULT jd_decomp ( - JDEC* jd, /* Initialized decompression object */ - uint16_t (*outfunc)(JDEC*, void*, JRECT*), /* RGB output function */ - uint8_t scale /* Output de-scaling factor (0 to 3) */ +esp_rom_tjpgd_result_t esp_rom_tjpgd_decomp ( + esp_rom_tjpgd_dec_t* jd, /* Initialized decompression object */ + uint32_t (*outfunc)(esp_rom_tjpgd_dec_t*, void*, esp_rom_tjpgd_rect_t*), /* RGB output function */ + uint8_t scale /* Output de-scaling factor (0 to 3) */ ) { - uint16_t x, y, mx, my; + uint32_t x, y, mx, my; uint16_t rst, rsc; - JRESULT rc; + esp_rom_tjpgd_result_t rc; if (scale > (JD_USE_SCALE ? 3 : 0)) return JDR_PAR; @@ -955,3 +972,5 @@ JRESULT jd_decomp ( return rc; } + +#endif // ESP_ROM_HAS_JPEG_DECODE diff --git a/components/esp_rom/test/CMakeLists.txt b/components/esp_rom/test/CMakeLists.txt index 82049b5644..00ab63e913 100644 --- a/components/esp_rom/test/CMakeLists.txt +++ b/components/esp_rom/test/CMakeLists.txt @@ -2,11 +2,9 @@ idf_component_register(SRC_DIRS . PRIV_INCLUDE_DIRS . ${CMAKE_CURRENT_BINARY_DIR} PRIV_REQUIRES cmock test_utils) -if(IDF_TARGET STREQUAL "esp32") - add_custom_command(OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/test_tjpgd_logo.h" - COMMAND xxd -i "logo.jpg" "${CMAKE_CURRENT_BINARY_DIR}/test_tjpgd_logo.h" - WORKING_DIRECTORY ${COMPONENT_DIR} - DEPENDS "${CMAKE_CURRENT_LIST_DIR}/logo.jpg") - add_custom_target(test_logo DEPENDS "${CMAKE_CURRENT_BINARY_DIR}/test_tjpgd_logo.h") - add_dependencies(${COMPONENT_LIB} test_logo) -endif() +add_custom_command(OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/test_tjpgd_logo.h" + COMMAND xxd -i "logo.jpg" "${CMAKE_CURRENT_BINARY_DIR}/test_tjpgd_logo.h" + WORKING_DIRECTORY ${COMPONENT_DIR} + DEPENDS "${CMAKE_CURRENT_LIST_DIR}/logo.jpg") +add_custom_target(test_logo DEPENDS "${CMAKE_CURRENT_BINARY_DIR}/test_tjpgd_logo.h") +add_dependencies(${COMPONENT_LIB} test_logo) diff --git a/components/esp_rom/test/test_tjpgd.c b/components/esp_rom/test/test_tjpgd.c index 7a0439c0d0..673d91a358 100644 --- a/components/esp_rom/test/test_tjpgd.c +++ b/components/esp_rom/test/test_tjpgd.c @@ -5,9 +5,7 @@ #include "sdkconfig.h" #include "unity.h" -#if CONFIG_IDF_TARGET_ESP32 - -#include "esp32/rom/tjpgd.h" +#include "esp_rom_tjpgd.h" #include "test_tjpgd_logo.h" typedef struct { @@ -18,7 +16,7 @@ typedef struct { int outH; } JpegDev; -static UINT infunc(JDEC *decoder, BYTE *buf, UINT len) +static uint32_t infunc(esp_rom_tjpgd_dec_t *decoder, uint8_t *buf, uint32_t len) { JpegDev *jd = (JpegDev *)decoder->device; printf("Reading %d bytes from pos %d\n", len, jd->inPos); @@ -29,7 +27,7 @@ static UINT infunc(JDEC *decoder, BYTE *buf, UINT len) return len; } -static UINT outfunc(JDEC *decoder, void *bitmap, JRECT *rect) +static uint32_t outfunc(esp_rom_tjpgd_dec_t *decoder, void *bitmap, esp_rom_tjpgd_rect_t *rect) { unsigned char *in = (unsigned char *)bitmap; unsigned char *out; @@ -55,10 +53,10 @@ TEST_CASE("Test JPEG decompression library", "[rom][tjpgd]") char *work; int r; int x, y, v; - JDEC decoder; + esp_rom_tjpgd_dec_t decoder; JpegDev jd; - decoded = malloc(48 * 48 * 3); - for (x = 0; x < 48 * 48 * 3; x += 2) { + decoded = malloc(TESTW * TESTH * 3); + for (x = 0; x < TESTW * TESTH * 3; x += 2) { decoded[x] = 0; decoded[x + 1] = 0xff; } @@ -71,9 +69,9 @@ TEST_CASE("Test JPEG decompression library", "[rom][tjpgd]") jd.outW = TESTW; jd.outH = TESTH; - r = jd_prepare(&decoder, infunc, work, WORKSZ, (void *)&jd); + r = esp_rom_tjpgd_prepare(&decoder, infunc, work, WORKSZ, (void *)&jd); TEST_ASSERT_EQUAL(r, JDR_OK); - r = jd_decomp(&decoder, outfunc, 0); + r = esp_rom_tjpgd_decomp(&decoder, outfunc, 0); TEST_ASSERT_EQUAL(r, JDR_OK); p = decoded + 2; @@ -89,5 +87,3 @@ TEST_CASE("Test JPEG decompression library", "[rom][tjpgd]") free(work); free(decoded); } - -#endif // #if CONFIG_IDF_TARGET_ESP32 diff --git a/examples/peripherals/lcd/tjpgd/components/tjpgd/CMakeLists.txt b/examples/peripherals/lcd/tjpgd/components/tjpgd/CMakeLists.txt deleted file mode 100644 index cde4d0eed4..0000000000 --- a/examples/peripherals/lcd/tjpgd/components/tjpgd/CMakeLists.txt +++ /dev/null @@ -1,4 +0,0 @@ -set(tjpgd_srcs "src/tjpgd.c") - -idf_component_register(SRCS "${tjpgd_srcs}" - INCLUDE_DIRS "include") diff --git a/examples/peripherals/lcd/tjpgd/components/tjpgd/component.mk b/examples/peripherals/lcd/tjpgd/components/tjpgd/component.mk deleted file mode 100644 index 24cab8b637..0000000000 --- a/examples/peripherals/lcd/tjpgd/components/tjpgd/component.mk +++ /dev/null @@ -1,3 +0,0 @@ -COMPONENT_ADD_INCLUDEDIRS := include - -COMPONENT_SRCDIRS := src diff --git a/examples/peripherals/lcd/tjpgd/components/tjpgd/include/tjpgd.h b/examples/peripherals/lcd/tjpgd/components/tjpgd/include/tjpgd.h deleted file mode 100644 index abb9dd4803..0000000000 --- a/examples/peripherals/lcd/tjpgd/components/tjpgd/include/tjpgd.h +++ /dev/null @@ -1,88 +0,0 @@ -/*----------------------------------------------------------------------------/ -/ TJpgDec - Tiny JPEG Decompressor include file (C)ChaN, 2019 -/----------------------------------------------------------------------------*/ -#ifndef DEF_TJPGDEC -#define DEF_TJPGDEC -/*---------------------------------------------------------------------------*/ -/* System Configurations */ - -#define JD_SZBUF 512 /* Size of stream input buffer */ -#define JD_FORMAT 0 /* Output pixel format 0:RGB888 (3 BYTE/pix), 1:RGB565 (1 WORD/pix) */ -#define JD_USE_SCALE 1 /* Use descaling feature for output */ -#define JD_TBLCLIP 1 /* Use table for saturation (might be a bit faster but increases 1K bytes of code size) */ - -/*---------------------------------------------------------------------------*/ - -#ifdef __cplusplus -extern "C" { -#endif - -#if defined(_WIN32) /* Main development platform */ -typedef unsigned char uint8_t; -typedef unsigned short uint16_t; -typedef short int16_t; -typedef unsigned long uint32_t; -typedef long int32_t; -#else -#include "stdint.h" -#endif - -/* Error code */ -typedef enum { - JDR_OK = 0, /* 0: Succeeded */ - JDR_INTR, /* 1: Interrupted by output function */ - JDR_INP, /* 2: Device error or wrong termination of input stream */ - JDR_MEM1, /* 3: Insufficient memory pool for the image */ - JDR_MEM2, /* 4: Insufficient stream input buffer */ - JDR_PAR, /* 5: Parameter error */ - JDR_FMT1, /* 6: Data format error (may be damaged data) */ - JDR_FMT2, /* 7: Right format but not supported */ - JDR_FMT3 /* 8: Not supported JPEG standard */ -} JRESULT; - - - -/* Rectangular structure */ -typedef struct { - uint16_t left, right, top, bottom; -} JRECT; - - - -/* Decompressor object structure */ -typedef struct JDEC JDEC; -struct JDEC { - uint16_t dctr; /* Number of bytes available in the input buffer */ - uint8_t* dptr; /* Current data read ptr */ - uint8_t* inbuf; /* Bit stream input buffer */ - uint8_t dmsk; /* Current bit in the current read byte */ - uint8_t scale; /* Output scaling ratio */ - uint8_t msx, msy; /* MCU size in unit of block (width, height) */ - uint8_t qtid[3]; /* Quantization table ID of each component */ - int16_t dcv[3]; /* Previous DC element of each component */ - uint16_t nrst; /* Restart inverval */ - uint16_t width, height; /* Size of the input image (pixel) */ - uint8_t* huffbits[2][2]; /* Huffman bit distribution tables [id][dcac] */ - uint16_t* huffcode[2][2]; /* Huffman code word tables [id][dcac] */ - uint8_t* huffdata[2][2]; /* Huffman decoded data tables [id][dcac] */ - int32_t* qttbl[4]; /* Dequantizer tables [id] */ - void* workbuf; /* Working buffer for IDCT and RGB output */ - uint8_t* mcubuf; /* Working buffer for the MCU */ - void* pool; /* Pointer to available memory pool */ - uint16_t sz_pool; /* Size of momory pool (bytes available) */ - uint16_t (*infunc)(JDEC*, uint8_t*, uint16_t);/* Pointer to jpeg stream input function */ - void* device; /* Pointer to I/O device identifiler for the session */ -}; - - - -/* TJpgDec API functions */ -JRESULT jd_prepare (JDEC*, uint16_t(*)(JDEC*,uint8_t*,uint16_t), void*, uint16_t, void*); -JRESULT jd_decomp (JDEC*, uint16_t(*)(JDEC*,void*,JRECT*), uint8_t); - - -#ifdef __cplusplus -} -#endif - -#endif /* _TJPGDEC */ diff --git a/examples/peripherals/lcd/tjpgd/main/CMakeLists.txt b/examples/peripherals/lcd/tjpgd/main/CMakeLists.txt index f48fb7da8b..8abed53131 100644 --- a/examples/peripherals/lcd/tjpgd/main/CMakeLists.txt +++ b/examples/peripherals/lcd/tjpgd/main/CMakeLists.txt @@ -1,12 +1,8 @@ set(srcs "pretty_effect.c" "lcd_tjpgd_example_main.c" + "decode_image.c" ) -# Only ESP32 has enough memory to do jpeg decoding -if(IDF_TARGET STREQUAL "esp32") - list(APPEND srcs "decode_image.c") -endif() - idf_component_register(SRCS ${srcs} INCLUDE_DIRS "." EMBED_FILES image.jpg) diff --git a/examples/peripherals/lcd/tjpgd/main/decode_image.c b/examples/peripherals/lcd/tjpgd/main/decode_image.c index 179c3deb7a..a9a460bc39 100644 --- a/examples/peripherals/lcd/tjpgd/main/decode_image.c +++ b/examples/peripherals/lcd/tjpgd/main/decode_image.c @@ -18,7 +18,7 @@ format if you want to use a different image file. */ #include "decode_image.h" -#include "tjpgd.h" +#include "esp_rom_tjpgd.h" #include "esp_log.h" #include @@ -42,7 +42,7 @@ typedef struct { } JpegDev; //Input function for jpeg decoder. Just returns bytes from the inData field of the JpegDev structure. -static uint16_t infunc(JDEC *decoder, uint8_t *buf, uint16_t len) +static uint32_t infunc(esp_rom_tjpgd_dec_t *decoder, uint8_t *buf, uint32_t len) { //Read bytes from input file JpegDev *jd = (JpegDev *)decoder->device; @@ -55,7 +55,7 @@ static uint16_t infunc(JDEC *decoder, uint8_t *buf, uint16_t len) //Output function. Re-encodes the RGB888 data from the decoder as big-endian RGB565 and //stores it in the outData array of the JpegDev structure. -static uint16_t outfunc(JDEC *decoder, void *bitmap, JRECT *rect) +static uint32_t outfunc(esp_rom_tjpgd_dec_t *decoder, void *bitmap, esp_rom_tjpgd_rect_t *rect) { JpegDev *jd = (JpegDev *)decoder->device; uint8_t *in = (uint8_t *)bitmap; @@ -83,7 +83,7 @@ esp_err_t decode_image(uint16_t ***pixels) { char *work = NULL; int r; - JDEC decoder; + esp_rom_tjpgd_dec_t decoder; JpegDev jd; *pixels = NULL; esp_err_t ret = ESP_OK; @@ -120,13 +120,13 @@ esp_err_t decode_image(uint16_t ***pixels) jd.outH = IMAGE_H; //Prepare and decode the jpeg. - r = jd_prepare(&decoder, infunc, work, WORKSZ, (void *)&jd); + r = esp_rom_tjpgd_prepare(&decoder, infunc, work, WORKSZ, (void *)&jd); if (r != JDR_OK) { ESP_LOGE(TAG, "Image decoder: jd_prepare failed (%d)", r); ret = ESP_ERR_NOT_SUPPORTED; goto err; } - r = jd_decomp(&decoder, outfunc, 0); + r = esp_rom_tjpgd_decomp(&decoder, outfunc, 0); if (r != JDR_OK && r != JDR_FMT1) { ESP_LOGE(TAG, "Image decoder: jd_decode failed (%d)", r); ret = ESP_ERR_NOT_SUPPORTED; diff --git a/examples/peripherals/lcd/tjpgd/main/pretty_effect.c b/examples/peripherals/lcd/tjpgd/main/pretty_effect.c index 4d1c43bbee..89fea666b4 100644 --- a/examples/peripherals/lcd/tjpgd/main/pretty_effect.c +++ b/examples/peripherals/lcd/tjpgd/main/pretty_effect.c @@ -12,8 +12,6 @@ #include #include "pretty_effect.h" #include "sdkconfig.h" - -#ifdef CONFIG_IDF_TARGET_ESP32 #include "decode_image.h" uint16_t **pixels; @@ -26,15 +24,6 @@ static inline uint16_t get_bgnd_pixel(int x, int y) y+=8; return pixels[y][x]; } -#else -//esp32s2/c3 doesn't have enough memory to hold the decoded image, calculate instead -//TODO: add support for esp32s3 (IDF-3615) -static inline uint16_t get_bgnd_pixel(int x, int y) -{ - return ((x<<3)^(y<<3)^(x*y)); -} -#endif - //This variable is used to detect the next frame. static int prev_frame=-1; @@ -68,11 +57,5 @@ void pretty_effect_calc_lines(uint16_t *dest, int line, int frame, int linect) esp_err_t pretty_effect_init(void) { -#ifdef CONFIG_IDF_TARGET_ESP32 return decode_image(&pixels); -#else - //esp32s2/c3 doesn't have enough memory to hold the decoded image, calculate instead - //TODO: add support for esp32s3 (IDF-3615) - return ESP_OK; -#endif }