exclude rom headers in examples

1. avoid including rom headers directly in examples
2. add common API interface for CRC calculation in esp_common component

diff --git a/components/driver/include/driver/uart.h b/components/driver/include/driver/uart.h
index 4bf855c186a11db6e42df37f71571dfc7a934898..f25e21776e02132f3114ea6d2bbb6f2ce1889a23 100644 (file)
--- a/components/driver/include/driver/uart.h
+++ b/components/driver/include/driver/uart.h
@@ -841,6 +841,14 @@ esp_err_t uart_set_wakeup_threshold(uart_port_t uart_num, int wakeup_threshold);
  */
 esp_err_t uart_get_wakeup_threshold(uart_port_t uart_num, int* out_wakeup_threshold);
 
+/**
+  * @brief Wait until UART tx memory empty and the last char send ok (polling mode).
+  *
+  * @param uart_num UART number
+  *
+  */
+void uart_wait_tx_idle_polling(uart_port_t uart_num);
+
 #ifdef __cplusplus
 }
 #endif

diff --git a/components/driver/uart.c b/components/driver/uart.c
index 3367d1d04afabe0a0d40d110763f387bbc4d24b6..da215dde01a99103528e1ab7089b2cc5a3488570 100644 (file)
--- a/components/driver/uart.c
+++ b/components/driver/uart.c
@@ -81,7 +81,7 @@ typedef struct {
     intr_handle_t intr_handle;          /*!< UART interrupt handle*/
     uart_mode_t uart_mode;              /*!< UART controller actual mode set by uart_set_mode() */
     bool coll_det_flg;                  /*!< UART collision detection flag */
-    
+
     //rx parameters
     int rx_buffered_len;                  /*!< UART cached data length */
     SemaphoreHandle_t rx_mux;           /*!< UART RX data mutex*/
@@ -1007,13 +1007,13 @@ static void uart_rx_intr_handler_default(void *param)
             UART_ENTER_CRITICAL_ISR(&uart_spinlock[uart_num]);
             uart_reset_rx_fifo(uart_num);
             // Set collision detection flag
-            p_uart_obj[uart_num]->coll_det_flg = true; 
+            p_uart_obj[uart_num]->coll_det_flg = true;
             UART_EXIT_CRITICAL_ISR(&uart_spinlock[uart_num]);
             uart_event.type = UART_EVENT_MAX;
         } else if(uart_intr_status & UART_TX_DONE_INT_ST_M) {
             uart_disable_intr_mask_from_isr(uart_num, UART_TX_DONE_INT_ENA_M);
             uart_clear_intr_status(uart_num, UART_TX_DONE_INT_CLR_M);
-            // If RS485 half duplex mode is enable then reset FIFO and 
+            // If RS485 half duplex mode is enable then reset FIFO and
             // reset RTS pin to start receiver driver
             if (UART_IS_MODE_SET(uart_num, UART_MODE_RS485_HALF_DUPLEX)) {
                 UART_ENTER_CRITICAL_ISR(&uart_spinlock[uart_num]);
@@ -1489,11 +1489,11 @@ portMUX_TYPE *uart_get_selectlock(void)
     return &uart_selectlock;
 }
 // Set UART mode
-esp_err_t uart_set_mode(uart_port_t uart_num, uart_mode_t mode) 
+esp_err_t uart_set_mode(uart_port_t uart_num, uart_mode_t mode)
 {
     UART_CHECK((p_uart_obj[uart_num]), "uart driver error", ESP_ERR_INVALID_STATE);
     UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error", ESP_ERR_INVALID_ARG);
-    if ((mode == UART_MODE_RS485_COLLISION_DETECT) || (mode == UART_MODE_RS485_APP_CTRL) 
+    if ((mode == UART_MODE_RS485_COLLISION_DETECT) || (mode == UART_MODE_RS485_APP_CTRL)
             || (mode == UART_MODE_RS485_HALF_DUPLEX)) {
         UART_CHECK((UART[uart_num]->conf1.rx_flow_en != 1),
                 "disable hw flowctrl before using RS485 mode", ESP_ERR_INVALID_ARG);
@@ -1548,13 +1548,13 @@ esp_err_t uart_set_mode(uart_port_t uart_num, uart_mode_t mode)
     return ESP_OK;
 }
 
-esp_err_t uart_set_rx_timeout(uart_port_t uart_num, const uint8_t tout_thresh) 
+esp_err_t uart_set_rx_timeout(uart_port_t uart_num, const uint8_t tout_thresh)
 {
     UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error", ESP_ERR_INVALID_ARG);
     UART_CHECK((tout_thresh < 127), "tout_thresh max value is 126", ESP_ERR_INVALID_ARG);
     UART_ENTER_CRITICAL(&uart_spinlock[uart_num]);
-    // The tout_thresh = 1, defines TOUT interrupt timeout equal to  
-    // transmission time of one symbol (~11 bit) on current baudrate  
+    // The tout_thresh = 1, defines TOUT interrupt timeout equal to
+    // transmission time of one symbol (~11 bit) on current baudrate
     if (tout_thresh > 0) {
         //Hardware issue workaround: when using ref_tick, the rx timeout threshold needs increase to 10 times.
         //T_ref = T_apb * APB_CLK/(REF_TICK << CLKDIV_FRAG_BIT_WIDTH)
@@ -1575,8 +1575,8 @@ esp_err_t uart_get_collision_flag(uart_port_t uart_num, bool* collision_flag)
 {
     UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error", ESP_ERR_INVALID_ARG);
     UART_CHECK((collision_flag != NULL), "wrong parameter pointer", ESP_ERR_INVALID_ARG);
-    UART_CHECK((UART_IS_MODE_SET(uart_num, UART_MODE_RS485_HALF_DUPLEX) 
-                    || UART_IS_MODE_SET(uart_num, UART_MODE_RS485_COLLISION_DETECT)), 
+    UART_CHECK((UART_IS_MODE_SET(uart_num, UART_MODE_RS485_HALF_DUPLEX)
+                    || UART_IS_MODE_SET(uart_num, UART_MODE_RS485_COLLISION_DETECT)),
                     "wrong mode", ESP_ERR_INVALID_ARG);
     *collision_flag = p_uart_obj[uart_num]->coll_det_flg;
     return ESP_OK;
@@ -1601,3 +1601,12 @@ esp_err_t uart_get_wakeup_threshold(uart_port_t uart_num, int* out_wakeup_thresh
     *out_wakeup_threshold = UART[uart_num]->sleep_conf.active_threshold + UART_MIN_WAKEUP_THRESH;
     return ESP_OK;
 }
+
+void uart_wait_tx_idle_polling(uart_port_t uart_num)
+{
+    uint32_t status;
+    do {
+        status = READ_PERI_REG(UART_STATUS_REG(uart_num));
+        /* either tx count or state is non-zero */
+    } while ((status & (UART_ST_UTX_OUT_M | UART_TXFIFO_CNT_M)) != 0);
+}

diff --git a/components/esp_common/include/esp_crc.h b/components/esp_common/include/esp_crc.h
new file mode 100644 (file)
index 0000000..23a0487
--- /dev/null
+++ b/components/esp_common/include/esp_crc.h
@@ -0,0 +1,113 @@
+// Copyright 2015-2019 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+#include "sdkconfig.h"
+
+#if defined(CONFIG_IDF_TARGET_ESP32)
+#include "esp32/rom/crc.h"
+#endif
+
+/******************* Polynomials Used in the CRC APIs ****************************
+* CRC-8        x8+x2+x1+1                                              0x07
+* CRC16-CCITT  x16+x12+x5+1                                            0x1021
+* CRC32        x32+x26+x23+x22+x16+x12+x11+x10+x8+x7+x5+x4+x2+x1+1     0x04c11db7
+********************************************************************************/
+
+/**
+* @brief CRC32 value in little endian.
+*
+* @param crc: Initial CRC value (result of last calculation or 0 for the first time)
+* @param buf: Data buffer that used to calculate the CRC value
+* @param len: Length of the data buffer
+* @return CRC32 value
+*/
+static inline uint32_t esp_crc32_le(uint32_t crc, uint8_t const *buf, uint32_t len)
+{
+    return crc32_le(crc, buf, len);
+}
+
+/**
+* @brief CRC32 value in big endian.
+*
+* @param crc: Initial CRC value (result of last calculation or 0 for the first time)
+* @param buf: Data buffer that used to calculate the CRC value
+* @param len: Length of the data buffer
+* @return CRC32 value
+*/
+static inline uint32_t esp_crc32_be(uint32_t crc, uint8_t const *buf, uint32_t len)
+{
+    return crc32_be(crc, buf, len);
+}
+
+/**
+* @brief CRC16 value in little endian.
+*
+* @param crc: Initial CRC value (result of last calculation or 0 for the first time)
+* @param buf: Data buffer that used to calculate the CRC value
+* @param len: Length of the data buffer
+* @return CRC16 value
+*/
+static inline uint16_t esp_crc16_le(uint16_t crc, uint8_t const *buf, uint32_t len)
+{
+    return crc16_le(crc, buf, len);
+}
+
+/**
+* @brief CRC16 value in big endian.
+*
+* @param crc: Initial CRC value (result of last calculation or 0 for the first time)
+* @param buf: Data buffer that used to calculate the CRC value
+* @param len: Length of the data buffer
+* @return CRC16 value
+*/
+static inline uint16_t esp_crc16_be(uint16_t crc, uint8_t const *buf, uint32_t len)
+{
+    return crc16_be(crc, buf, len);
+}
+
+/**
+* @brief CRC8 value in little endian.
+*
+* @param crc: Initial CRC value (result of last calculation or 0 for the first time)
+* @param buf: Data buffer that used to calculate the CRC value
+* @param len: Length of the data buffer
+* @return CRC8 value
+*/
+static inline uint8_t esp_crc8_le(uint8_t crc, uint8_t const *buf, uint32_t len)
+{
+    return crc8_le(crc, buf, len);
+}
+
+/**
+* @brief CRC8 value in big endian.
+*
+* @param crc: Initial CRC value (result of last calculation or 0 for the first time)
+* @param buf: Data buffer that used to calculate the CRC value
+* @param len: Length of the data buffer
+* @return CRC8 value
+*/
+static inline uint8_t esp_crc8_be(uint8_t crc, uint8_t const *buf, uint32_t len)
+{
+    return crc8_be(crc, buf, len);
+}
+
+#ifdef __cplusplus
+}
+#endif

diff --git a/examples/bluetooth/bluedroid/ble/blufi/main/blufi_security.c b/examples/bluetooth/bluedroid/ble/blufi/main/blufi_security.c
index 64b989e7413a2c643531738483ca0e70d42d72d5..f790e58e5b34c3f790570efecccd823dad6d3196 100644 (file)
--- a/examples/bluetooth/bluedroid/ble/blufi/main/blufi_security.c
+++ b/examples/bluetooth/bluedroid/ble/blufi/main/blufi_security.c
@@ -28,7 +28,7 @@
 #include "mbedtls/aes.h"
 #include "mbedtls/dhm.h"
 #include "mbedtls/md5.h"
-#include "esp32/rom/crc.h"
+#include "esp_crc.h"
 
 /*
    The SEC_TYPE_xxx is for self-defined packet data type in the procedure of "BLUFI negotiate key"
@@ -124,7 +124,7 @@ void blufi_dh_negotiate_data_handler(uint8_t *data, int len, uint8_t **output_da
         mbedtls_md5(blufi_sec->share_key, blufi_sec->share_len, blufi_sec->psk);
 
         mbedtls_aes_setkey_enc(&blufi_sec->aes, blufi_sec->psk, 128);
-        
+
         /* alloc output data */
         *output_data = &blufi_sec->self_public_key[0];
         *output_len = blufi_sec->dhm.len;
@@ -178,7 +178,7 @@ int blufi_aes_decrypt(uint8_t iv8, uint8_t *crypt_data, int crypt_len)
 uint16_t blufi_crc_checksum(uint8_t iv8, uint8_t *data, int len)
 {
     /* This iv8 ignore, not used */
-    return crc16_be(0, data, len);
+    return esp_crc16_be(0, data, len);
 }
 
 esp_err_t blufi_security_init(void)

diff --git a/examples/peripherals/sdio/slave/main/app_main.c b/examples/peripherals/sdio/slave/main/app_main.c
index 147f4aba49bc6a90b3b1e9693a5a6abe242ea2cb..3a6a7c75930cb8b20f8b09541cf184e386d564d7 100644 (file)
--- a/examples/peripherals/sdio/slave/main/app_main.c
+++ b/examples/peripherals/sdio/slave/main/app_main.c
@@ -8,7 +8,6 @@
    */
 #include "driver/sdio_slave.h"
 #include "esp_log.h"
-#include "esp32/rom/lldesc.h"
 #include "sys/queue.h"
 #include "soc/soc.h"
 #include "freertos/task.h"

diff --git a/examples/peripherals/spi_master/components/tjpgd/CMakeLists.txt b/examples/peripherals/spi_master/components/tjpgd/CMakeLists.txt
new file mode 100644 (file)
index 0000000..cde4d0e
--- /dev/null
+++ b/examples/peripherals/spi_master/components/tjpgd/CMakeLists.txt
@@ -0,0 +1,4 @@
+set(tjpgd_srcs "src/tjpgd.c")
+
+idf_component_register(SRCS "${tjpgd_srcs}"
+                       INCLUDE_DIRS "include")

diff --git a/examples/peripherals/spi_master/components/tjpgd/component.mk b/examples/peripherals/spi_master/components/tjpgd/component.mk
new file mode 100644 (file)
index 0000000..24cab8b
--- /dev/null
+++ b/examples/peripherals/spi_master/components/tjpgd/component.mk
@@ -0,0 +1,3 @@
+COMPONENT_ADD_INCLUDEDIRS := include
+
+COMPONENT_SRCDIRS := src

diff --git a/examples/peripherals/spi_master/components/tjpgd/include/tjpgd.h b/examples/peripherals/spi_master/components/tjpgd/include/tjpgd.h
new file mode 100644 (file)
index 0000000..abb9dd4
--- /dev/null
+++ b/examples/peripherals/spi_master/components/tjpgd/include/tjpgd.h
@@ -0,0 +1,88 @@
+/*----------------------------------------------------------------------------/
+/ 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/spi_master/components/tjpgd/src/tjpgd.c b/examples/peripherals/spi_master/components/tjpgd/src/tjpgd.c
new file mode 100644 (file)
index 0000000..dc87fe0
--- /dev/null
+++ b/examples/peripherals/spi_master/components/tjpgd/src/tjpgd.c
@@ -0,0 +1,960 @@
+/*----------------------------------------------------------------------------/
+/ TJpgDec - Tiny JPEG Decompressor R0.01c                     (C)ChaN, 2019
+/-----------------------------------------------------------------------------/
+/ 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.
+/
+/ * 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.
+/
+/-----------------------------------------------------------------------------/
+/ 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.
+/----------------------------------------------------------------------------*/
+
+#include "tjpgd.h"
+
+
+/*-----------------------------------------------*/
+/* Zigzag-order to raster-order conversion table */
+/*-----------------------------------------------*/
+
+#define ZIG(n) Zig[n]
+
+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,
+       58, 59, 52, 45, 38, 31, 39, 46, 53, 60, 61, 54, 47, 55, 62, 63
+};
+
+
+
+/*-------------------------------------------------*/
+/* Input scale factor of Arai algorithm            */
+/* (scaled up 16 bits for fixed point operations)  */
+/*-------------------------------------------------*/
+
+#define IPSF(n)        Ipsf[n]
+
+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),
+       (uint16_t)(1.17588*8192), (uint16_t)(1.63099*8192), (uint16_t)(1.53636*8192), (uint16_t)(1.38268*8192), (uint16_t)(1.17588*8192), (uint16_t)(0.92388*8192), (uint16_t)(0.63638*8192), (uint16_t)(0.32442*8192),
+       (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)(0.78570*8192), (uint16_t)(1.08979*8192), (uint16_t)(1.02656*8192), (uint16_t)(0.92388*8192), (uint16_t)(0.78570*8192), (uint16_t)(0.61732*8192), (uint16_t)(0.42522*8192), (uint16_t)(0.21677*8192),
+       (uint16_t)(0.54120*8192), (uint16_t)(0.75066*8192), (uint16_t)(0.70711*8192), (uint16_t)(0.63638*8192), (uint16_t)(0.54120*8192), (uint16_t)(0.42522*8192), (uint16_t)(0.29290*8192), (uint16_t)(0.14932*8192),
+       (uint16_t)(0.27590*8192), (uint16_t)(0.38268*8192), (uint16_t)(0.36048*8192), (uint16_t)(0.32442*8192), (uint16_t)(0.27590*8192), (uint16_t)(0.21678*8192), (uint16_t)(0.14932*8192), (uint16_t)(0.07612*8192)
+};
+
+
+
+/*---------------------------------------------*/
+/* Conversion table for fast clipping process  */
+/*---------------------------------------------*/
+
+#if JD_TBLCLIP
+
+#define BYTECLIP(v) Clip8[(uint16_t)(v) & 0x3FF]
+
+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,
+       64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,
+       96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127,
+       128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,
+       160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191,
+       192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223,
+       224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255,
+       /* 256..511 */
+       255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+       255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+       255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+       255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+       255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+       255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+       255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+       255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+       /* -512..-257 */
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       /* -256..-1 */
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+};
+
+#else  /* JD_TBLCLIP */
+
+inline uint8_t BYTECLIP (
+       int16_t val
+)
+{
+       if (val < 0) val = 0;
+       if (val > 255) val = 255;
+
+       return (uint8_t)val;
+}
+
+#endif
+
+
+
+/*-----------------------------------------------------------------------*/
+/* 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 */
+)
+{
+       char *rp = 0;
+
+
+       nd = (nd + 3) & ~3;                     /* Align block size to the word boundary */
+
+       if (jd->sz_pool >= nd) {
+               jd->sz_pool -= nd;
+               rp = (char*)jd->pool;                   /* Get start of available memory pool */
+               jd->pool = (void*)(rp + nd);    /* Allocate requierd bytes */
+       }
+
+       return (void*)rp;       /* Return allocated memory block (NULL:no memory to allocate) */
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* 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 */
+       const uint8_t* data,    /* Pointer to the quantizer tables */
+       uint16_t ndata                  /* Size of input data */
+)
+{
+       uint16_t i;
+       uint8_t d, z;
+       int32_t *pb;
+
+
+       while (ndata) { /* Process all tables in the segment */
+               if (ndata < 65) return JDR_FMT1;        /* Err: table size is unaligned */
+               ndata -= 65;
+               d = *data++;                                                    /* Get table property */
+               if (d & 0xF0) return JDR_FMT1;                  /* Err: not 8-bit resolution */
+               i = d & 3;                                                              /* Get table ID */
+               pb = alloc_pool(jd, 64 * sizeof (int32_t));/* Allocate a memory block for the table */
+               if (!pb) return JDR_MEM1;                               /* Err: not enough memory */
+               jd->qttbl[i] = pb;                                              /* Register the table */
+               for (i = 0; i < 64; i++) {                              /* Load the table */
+                       z = ZIG(i);                                                     /* Zigzag-order to raster-order conversion */
+                       pb[z] = (int32_t)((uint32_t)*data++ * IPSF(z)); /* Apply scale factor of Arai algorithm to the de-quantizers */
+               }
+       }
+
+       return JDR_OK;
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Create huffman code tables with a DHT segment                         */
+/*-----------------------------------------------------------------------*/
+
+static int create_huffman_tbl (        /* 0:OK, !0:Failed */
+       JDEC* jd,                                       /* Pointer to the decompressor object */
+       const uint8_t* data,            /* Pointer to the packed huffman tables */
+       uint16_t ndata                          /* Size of input data */
+)
+{
+       uint16_t i, j, b, np, cls, num;
+       uint8_t d, *pb, *pd;
+       uint16_t hc, *ph;
+
+
+       while (ndata) { /* Process all tables in the segment */
+               if (ndata < 17) return JDR_FMT1;        /* Err: wrong data size */
+               ndata -= 17;
+               d = *data++;                                            /* Get table number and class */
+               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 */
+               }
+               ph = alloc_pool(jd, (uint16_t)(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;
+               for (j = i = 0; i < 16; i++) {          /* Re-build huffman code word table */
+                       b = pb[i];
+                       while (b--) ph[j++] = hc++;
+                       hc <<= 1;
+               }
+
+               if (ndata < np) return JDR_FMT1;        /* Err: wrong data size */
+               ndata -= np;
+               pd = alloc_pool(jd, np);                        /* Allocate a memory block for the decoded data */
+               if (!pd) return JDR_MEM1;                       /* Err: not enough memory */
+               jd->huffdata[num][cls] = pd;
+               for (i = 0; i < np; i++) {                      /* Load decoded data corresponds to each code ward */
+                       d = *data++;
+                       if (!cls && d > 11) return JDR_FMT1;
+                       *pd++ = d;
+               }
+       }
+
+       return JDR_OK;
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* 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) */
+)
+{
+       uint8_t msk, s, *dp;
+       uint16_t dc, v, f;
+
+
+       msk = jd->dmsk; dc = jd->dctr; dp = jd->dptr;   /* Bit mask, number of data available, read ptr */
+       s = *dp; v = f = 0;
+       do {
+               if (!msk) {                             /* Next byte? */
+                       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 */
+                       } 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) */
+                               *dp = s = 0xFF;                 /* The flag is a data 0xFF */
+                       } else {
+                               s = *dp;                                /* Get next data byte */
+                               if (s == 0xFF) {                /* Is start of flag sequence? */
+                                       f = 1; continue;        /* Enter flag sequence */
+                               }
+                       }
+                       msk = 0x80;             /* Read from MSB */
+               }
+               v <<= 1;        /* Get a bit */
+               if (s & msk) v++;
+               msk >>= 1;
+               nbit--;
+       } while (nbit);
+       jd->dmsk = msk; jd->dctr = dc; jd->dptr = dp;
+
+       return (int)v;
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* 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 */
+       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;
+
+
+       msk = jd->dmsk; dc = jd->dctr; dp = jd->dptr;   /* Bit mask, number of data available, read ptr */
+       s = *dp; v = f = 0;
+       bl = 16;        /* Max code length */
+       do {
+               if (!msk) {             /* Next byte? */
+                       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 */
+                       } 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) */
+                               *dp = s = 0xFF;                 /* The flag is a data 0xFF */
+                       } else {
+                               s = *dp;                                /* Get next data byte */
+                               if (s == 0xFF) {                /* Is start of flag sequence? */
+                                       f = 1; continue;        /* Enter flag sequence, get trailing byte */
+                               }
+                       }
+                       msk = 0x80;             /* Read from MSB */
+               }
+               v <<= 1;        /* Get a bit */
+               if (s & msk) v++;
+               msk >>= 1;
+
+               for (nd = *hbits++; nd; nd--) { /* Search the code word in this bit length */
+                       if (v == *hcode++) {            /* Matched? */
+                               jd->dmsk = msk; jd->dctr = dc; jd->dptr = dp;
+                               return *hdata;                  /* Return the decoded data */
+                       }
+                       hdata++;
+               }
+               bl--;
+       } while (bl);
+
+       return 0 - (int16_t)JDR_FMT1;   /* Err: code not found (may be collapted data) */
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Apply Inverse-DCT in Arai Algorithm (see also aa_idct.png)            */
+/*-----------------------------------------------------------------------*/
+
+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 */
+)
+{
+       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;
+
+       /* Process columns */
+       for (i = 0; i < 8; i++) {
+               v0 = src[8 * 0];        /* Get even elements */
+               v1 = src[8 * 2];
+               v2 = src[8 * 4];
+               v3 = src[8 * 6];
+
+               t10 = v0 + v2;          /* Process the even elements */
+               t12 = v0 - v2;
+               t11 = (v1 - v3) * M13 >> 12;
+               v3 += v1;
+               t11 -= v3;
+               v0 = t10 + v3;
+               v3 = t10 - v3;
+               v1 = t11 + t12;
+               v2 = t12 - t11;
+
+               v4 = src[8 * 7];        /* Get odd elements */
+               v5 = src[8 * 1];
+               v6 = src[8 * 5];
+               v7 = src[8 * 3];
+
+               t10 = v5 - v4;          /* Process the odd elements */
+               t11 = v5 + v4;
+               t12 = v6 - v7;
+               v7 += v6;
+               v5 = (t11 - v7) * M13 >> 12;
+               v7 += t11;
+               t13 = (t10 + t12) * M5 >> 12;
+               v4 = t13 - (t10 * M2 >> 12);
+               v6 = t13 - (t12 * M4 >> 12) - v7;
+               v5 -= v6;
+               v4 -= v5;
+
+               src[8 * 0] = v0 + v7;   /* Write-back transformed values */
+               src[8 * 7] = v0 - v7;
+               src[8 * 1] = v1 + v6;
+               src[8 * 6] = v1 - v6;
+               src[8 * 2] = v2 + v5;
+               src[8 * 5] = v2 - v5;
+               src[8 * 3] = v3 + v4;
+               src[8 * 4] = v3 - v4;
+
+               src++;  /* Next column */
+       }
+
+       /* Process rows */
+       src -= 8;
+       for (i = 0; i < 8; i++) {
+               v0 = src[0] + (128L << 8);      /* Get even elements (remove DC offset (-128) here) */
+               v1 = src[2];
+               v2 = src[4];
+               v3 = src[6];
+
+               t10 = v0 + v2;                          /* Process the even elements */
+               t12 = v0 - v2;
+               t11 = (v1 - v3) * M13 >> 12;
+               v3 += v1;
+               t11 -= v3;
+               v0 = t10 + v3;
+               v3 = t10 - v3;
+               v1 = t11 + t12;
+               v2 = t12 - t11;
+
+               v4 = src[7];                            /* Get odd elements */
+               v5 = src[1];
+               v6 = src[5];
+               v7 = src[3];
+
+               t10 = v5 - v4;                          /* Process the odd elements */
+               t11 = v5 + v4;
+               t12 = v6 - v7;
+               v7 += v6;
+               v5 = (t11 - v7) * M13 >> 12;
+               v7 += t11;
+               t13 = (t10 + t12) * M5 >> 12;
+               v4 = t13 - (t10 * M2 >> 12);
+               v6 = t13 - (t12 * M4 >> 12) - v7;
+               v5 -= v6;
+               v4 -= v5;
+
+               dst[0] = BYTECLIP((v0 + v7) >> 8);      /* Descale the transformed values 8 bits and output */
+               dst[7] = BYTECLIP((v0 - v7) >> 8);
+               dst[1] = BYTECLIP((v1 + v6) >> 8);
+               dst[6] = BYTECLIP((v1 - v6) >> 8);
+               dst[2] = BYTECLIP((v2 + v5) >> 8);
+               dst[5] = BYTECLIP((v2 - v5) >> 8);
+               dst[3] = BYTECLIP((v3 + v4) >> 8);
+               dst[4] = BYTECLIP((v3 - v4) >> 8);
+               dst += 8;
+
+               src += 8;       /* Next row */
+       }
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Load all blocks in the MCU into working buffer                        */
+/*-----------------------------------------------------------------------*/
+
+static JRESULT mcu_load (
+       JDEC* 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;
+       uint8_t *bp;
+       const uint8_t *hb, *hd;
+       const uint16_t *hc;
+       const int32_t *dqf;
+
+
+       nby = jd->msx * jd->msy;        /* Number of Y blocks (1, 2 or 4) */
+       nbc = 2;                                        /* Number of C blocks (2) */
+       bp = jd->mcubuf;                        /* Pointer to the first block */
+
+       for (blk = 0; blk < nby + nbc; blk++) {
+               cmp = (blk < nby) ? 0 : blk - nby + 1;  /* Component number 0:Y, 1:Cb, 2:Cr */
+               id = cmp ? 1 : 0;                                               /* Huffman table ID of the component */
+
+               /* Extract a DC element from input stream */
+               hb = jd->huffbits[id][0];                               /* Huffman table for the DC element */
+               hc = jd->huffcode[id][0];
+               hd = jd->huffdata[id][0];
+               b = huffext(jd, hb, hc, hd);                    /* Extract a huffman coded data (bit length) */
+               if (b < 0) return 0 - b;                                /* Err: invalid code or input */
+               d = jd->dcv[cmp];                                               /* DC value of previous block */
+               if (b) {                                                                /* If there is any difference from previous block */
+                       e = bitext(jd, b);                                      /* Extract data bits */
+                       if (e < 0) return 0 - e;                        /* Err: input */
+                       b = 1 << (b - 1);                                       /* MSB position */
+                       if (!(e & b)) e -= (b << 1) - 1;        /* Restore sign if needed */
+                       d += e;                                                         /* Get current value */
+                       jd->dcv[cmp] = (int16_t)d;                      /* Save current DC value for next block */
+               }
+               dqf = jd->qttbl[jd->qtid[cmp]];                 /* De-quantizer table ID for this component */
+               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 */
+               hb = jd->huffbits[id][1];                               /* Huffman table for the AC elements */
+               hc = jd->huffcode[id][1];
+               hd = jd->huffdata[id][1];
+               i = 1;                                  /* Top of the AC elements */
+               do {
+                       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 */
+                       if (z) {
+                               i += z;                                                 /* Skip zero elements */
+                               if (i >= 64) return JDR_FMT1;   /* Too long zero run */
+                       }
+                       if (b &= 0x0F) {                                        /* Bit length */
+                               d = bitext(jd, b);                              /* Extract data bits */
+                               if (d < 0) return 0 - d;                /* Err: input device */
+                               b = 1 << (b - 1);                               /* MSB position */
+                               if (!(d & b)) d -= (b << 1) - 1;/* Restore negative value if needed */
+                               z = ZIG(i);                                             /* Zigzag-order to raster-order converted index */
+                               tmp[z] = d * dqf[z] >> 8;               /* De-quantize, apply scale factor of Arai algorithm and descale 8 bits */
+                       }
+               } 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 {
+                       block_idct(tmp, bp);            /* Apply IDCT and store the block to the MCU buffer */
+               }
+
+               bp += 64;                               /* Next block */
+       }
+
+       return JDR_OK;  /* All blocks have been loaded successfully */
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* 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) */
+)
+{
+       const int16_t CVACC = (sizeof (int16_t) > 2) ? 1024 : 128;
+       uint16_t ix, iy, mx, my, rx, ry;
+       int16_t yy, cb, cr;
+       uint8_t *py, *pc, *rgb24;
+       JRECT rect;
+
+
+       mx = jd->msx * 8; my = jd->msy * 8;                                     /* MCU size (pixel) */
+       rx = (x + mx <= jd->width) ? mx : jd->width - x;        /* Output rectangular size (it may be clipped at right/bottom end) */
+       ry = (y + my <= jd->height) ? my : jd->height - y;
+       if (JD_USE_SCALE) {
+               rx >>= jd->scale; ry >>= jd->scale;
+               if (!rx || !ry) return JDR_OK;                                  /* Skip this MCU if all pixel is to be rounded off */
+               x >>= jd->scale; y >>= jd->scale;
+       }
+       rect.left = x; rect.right = x + rx - 1;                         /* Rectangular area in the frame buffer */
+       rect.top = y; rect.bottom = y + ry - 1;
+
+
+       if (!JD_USE_SCALE || jd->scale != 3) {  /* Not for 1/8 scaling */
+
+               /* Build an RGB MCU from discrete comopnents */
+               rgb24 = (uint8_t*)jd->workbuf;
+               for (iy = 0; iy < my; iy++) {
+                       pc = jd->mcubuf;
+                       py = pc + iy * 8;
+                       if (my == 16) {         /* Double block height? */
+                               pc += 64 * 4 + (iy >> 1) * 8;
+                               if (iy >= 8) py += 64;
+                       } else {                        /* Single block height */
+                               pc += mx * 8 + iy * 8;
+                       }
+                       for (ix = 0; ix < mx; ix++) {
+                               cb = pc[0] - 128;       /* Get Cb/Cr component and restore right level */
+                               cr = pc[64] - 128;
+                               if (mx == 16) {                                 /* Double block width? */
+                                       if (ix == 8) py += 64 - 8;      /* Jump to next block if double block heigt */
+                                       pc += ix & 1;                           /* Increase chroma pointer every two pixels */
+                               } else {                                                /* Single block width */
+                                       pc++;                                           /* Increase chroma pointer every pixel */
+                               }
+                               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);
+                       }
+               }
+
+               /* Descale the MCU rectangular if needed */
+               if (JD_USE_SCALE && jd->scale) {
+                       uint16_t x, y, r, g, b, s, w, a;
+                       uint8_t *op;
+
+                       /* Get averaged RGB value of each square correcponds to a pixel */
+                       s = jd->scale * 2;      /* Bumber of shifts for averaging */
+                       w = 1 << jd->scale;     /* Width of square */
+                       a = (mx - w) * 3;       /* Bytes to skip for next line in the square */
+                       op = (uint8_t*)jd->workbuf;
+                       for (iy = 0; iy < my; iy += w) {
+                               for (ix = 0; ix < mx; ix += w) {
+                                       rgb24 = (uint8_t*)jd->workbuf + (iy * mx + ix) * 3;
+                                       r = g = b = 0;
+                                       for (y = 0; y < w; y++) {       /* Accumulate RGB value in the square */
+                                               for (x = 0; x < w; x++) {
+                                                       r += *rgb24++;
+                                                       g += *rgb24++;
+                                                       b += *rgb24++;
+                                               }
+                                               rgb24 += a;
+                                       }                                                       /* Put the averaged RGB value as a pixel */
+                                       *op++ = (uint8_t)(r >> s);
+                                       *op++ = (uint8_t)(g >> s);
+                                       *op++ = (uint8_t)(b >> s);
+                               }
+                       }
+               }
+
+       } else {        /* For only 1/8 scaling (left-top pixel in each block are the DC value of the block) */
+
+               /* Build a 1/8 descaled RGB MCU from discrete comopnents */
+               rgb24 = (uint8_t*)jd->workbuf;
+               pc = jd->mcubuf + mx * my;
+               cb = pc[0] - 128;               /* Get Cb/Cr component and restore right level */
+               cr = pc[64] - 128;
+               for (iy = 0; iy < my; iy += 8) {
+                       py = jd->mcubuf;
+                       if (iy == 8) py += 64 * 2;
+                       for (ix = 0; ix < mx; ix += 8) {
+                               yy = *py;       /* Get Y component */
+                               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));
+                       }
+               }
+       }
+
+       /* Squeeze up pixel table if a part of MCU is to be truncated */
+       mx >>= jd->scale;
+       if (rx < mx) {
+               uint8_t *s, *d;
+               uint16_t x, y;
+
+               s = d = (uint8_t*)jd->workbuf;
+               for (y = 0; y < ry; y++) {
+                       for (x = 0; x < rx; x++) {      /* Copy effective pixels */
+                               *d++ = *s++;
+                               *d++ = *s++;
+                               *d++ = *s++;
+                       }
+                       s += (mx - rx) * 3;     /* Skip truncated pixels */
+               }
+       }
+
+       /* Convert RGB888 to RGB565 if needed */
+       if (JD_FORMAT == 1) {
+               uint8_t *s = (uint8_t*)jd->workbuf;
+               uint16_t w, *d = (uint16_t*)s;
+               uint16_t n = rx * ry;
+
+               do {
+                       w = (*s++ & 0xF8) << 8;         /* RRRRR----------- */
+                       w |= (*s++ & 0xFC) << 3;        /* -----GGGGGG----- */
+                       w |= *s++ >> 3;                         /* -----------BBBBB */
+                       *d++ = w;
+               } while (--n);
+       }
+
+       /* Output the RGB rectangular */
+       return outfunc(jd, jd->workbuf, &rect) ? JDR_OK : JDR_INTR;
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Process restart interval                                              */
+/*-----------------------------------------------------------------------*/
+
+static JRESULT restart (
+       JDEC* jd,               /* Pointer to the decompressor object */
+       uint16_t rstn   /* Expected restert sequense number */
+)
+{
+       uint16_t i, dc;
+       uint16_t d;
+       uint8_t *dp;
+
+
+       /* Discard padding bits and get two bytes from the input stream */
+       dp = jd->dptr; dc = jd->dctr;
+       d = 0;
+       for (i = 0; i < 2; i++) {
+               if (!dc) {      /* No input data is available, re-fill input buffer */
+                       dp = jd->inbuf;
+                       dc = jd->infunc(jd, dp, JD_SZBUF);
+                       if (!dc) return JDR_INP;
+               } else {
+                       dp++;
+               }
+               dc--;
+               d = (d << 8) | *dp;     /* Get a byte */
+       }
+       jd->dptr = dp; jd->dctr = dc; jd->dmsk = 0;
+
+       /* Check the marker */
+       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;
+
+       return JDR_OK;
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Analyze the JPEG image and Initialize decompressor object             */
+/*-----------------------------------------------------------------------*/
+
+#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 */
+       void* pool,                     /* Working buffer for the decompression session */
+       uint16_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;
+
+
+       if (!pool) return JDR_PAR;
+
+       jd->pool = pool;                /* Work memroy */
+       jd->sz_pool = sz_pool;  /* Size of given work memory */
+       jd->infunc = infunc;    /* Stream input function */
+       jd->device = dev;               /* I/O device identifier */
+       jd->nrst = 0;                   /* No restart interval (default) */
+
+       for (i = 0; i < 2; i++) {       /* Nulls pointers */
+               for (j = 0; j < 2; j++) {
+                       jd->huffbits[i][j] = 0;
+                       jd->huffcode[i][j] = 0;
+                       jd->huffdata[i][j] = 0;
+               }
+       }
+       for (i = 0; i < 4; jd->qttbl[i++] = 0) ;
+
+       jd->inbuf = seg = alloc_pool(jd, JD_SZBUF);             /* Allocate stream input buffer */
+       if (!seg) return JDR_MEM1;
+
+       if (jd->infunc(jd, seg, 2) != 2) return JDR_INP;/* Check SOI marker */
+       if (LDB_WORD(seg) != 0xFFD8) return JDR_FMT1;   /* Err: SOI is not detected */
+       ofs = 2;
+
+       for (;;) {
+               /* Get a JPEG marker */
+               if (jd->infunc(jd, seg, 4) != 4) return JDR_INP;
+               marker = LDB_WORD(seg);         /* Marker */
+               len = LDB_WORD(seg + 2);        /* Length field */
+               if (len <= 2 || (marker >> 8) != 0xFF) return JDR_FMT1;
+               len -= 2;               /* Content size excluding length field */
+               ofs += 4 + len; /* Number of bytes loaded */
+
+               switch (marker & 0xFF) {
+               case 0xC0:      /* SOF0 (baseline JPEG) */
+                       /* Load segment data */
+                       if (len > JD_SZBUF) return JDR_MEM2;
+                       if (jd->infunc(jd, seg, len) != len) return JDR_INP;
+
+                       jd->width = LDB_WORD(seg+3);            /* Image width in unit of pixel */
+                       jd->height = LDB_WORD(seg+1);           /* Image height in unit of pixel */
+                       if (seg[5] != 3) return JDR_FMT3;       /* Err: Supports only Y/Cb/Cr format */
+
+                       /* Check three image components */
+                       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 */
+                                               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 */
+                               }
+                               b = seg[8 + 3 * i];                                                     /* Get dequantizer table ID for this component */
+                               if (b > 3) return JDR_FMT3;                                     /* Err: Invalid ID */
+                               jd->qtid[i] = b;
+                       }
+                       break;
+
+               case 0xDD:      /* DRI */
+                       /* Load segment data */
+                       if (len > JD_SZBUF) return JDR_MEM2;
+                       if (jd->infunc(jd, seg, len) != len) return JDR_INP;
+
+                       /* Get restart interval (MCUs) */
+                       jd->nrst = LDB_WORD(seg);
+                       break;
+
+               case 0xC4:      /* DHT */
+                       /* Load segment data */
+                       if (len > JD_SZBUF) return JDR_MEM2;
+                       if (jd->infunc(jd, seg, len) != len) return JDR_INP;
+
+                       /* Create huffman tables */
+                       rc = create_huffman_tbl(jd, seg, len);
+                       if (rc) return rc;
+                       break;
+
+               case 0xDB:      /* DQT */
+                       /* Load segment data */
+                       if (len > JD_SZBUF) return JDR_MEM2;
+                       if (jd->infunc(jd, seg, len) != len) return JDR_INP;
+
+                       /* Create de-quantizer tables */
+                       rc = create_qt_tbl(jd, seg, len);
+                       if (rc) return rc;
+                       break;
+
+               case 0xDA:      /* SOS */
+                       /* Load segment data */
+                       if (len > JD_SZBUF) return JDR_MEM2;
+                       if (jd->infunc(jd, seg, len) != len) return JDR_INP;
+
+                       if (!jd->width || !jd->height) return JDR_FMT1; /* Err: Invalid image size */
+
+                       if (seg[0] != 3) return JDR_FMT3;                               /* Err: Supports only three color components format */
+
+                       /* Check if all tables corresponding to each components have been loaded */
+                       for (i = 0; i < 3; i++) {
+                               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 */
+                               }
+                       }
+
+                       /* Allocate working buffer for MCU and RGB */
+                       n = jd->msy * jd->msx;                                          /* Number of Y blocks in the MCU */
+                       if (!n) return JDR_FMT1;                                        /* Err: SOF0 has not been loaded */
+                       len = n * 64 * 2 + 64;                                          /* Allocate buffer for IDCT and RGB output */
+                       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 */
+                       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->dptr = seg + ofs - 1;
+                       }
+
+                       return JDR_OK;          /* Initialization succeeded. Ready to decompress the JPEG image. */
+
+               case 0xC1:      /* SOF1 */
+               case 0xC2:      /* SOF2 */
+               case 0xC3:      /* SOF3 */
+               case 0xC5:      /* SOF5 */
+               case 0xC6:      /* SOF6 */
+               case 0xC7:      /* SOF7 */
+               case 0xC9:      /* SOF9 */
+               case 0xCA:      /* SOF10 */
+               case 0xCB:      /* SOF11 */
+               case 0xCD:      /* SOF13 */
+               case 0xCE:      /* SOF14 */
+               case 0xCF:      /* SOF15 */
+               case 0xD9:      /* EOI */
+                       return JDR_FMT3;        /* Unsuppoted JPEG standard (may be progressive JPEG) */
+
+               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 */
+                               return JDR_INP;
+                       }
+               }
+       }
+}
+
+
+
+
+/*-----------------------------------------------------------------------*/
+/* 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) */
+)
+{
+       uint16_t x, y, mx, my;
+       uint16_t rst, rsc;
+       JRESULT rc;
+
+
+       if (scale > (JD_USE_SCALE ? 3 : 0)) return JDR_PAR;
+       jd->scale = scale;
+
+       mx = jd->msx * 8; my = jd->msy * 8;                     /* Size of the MCU (pixel) */
+
+       jd->dcv[2] = jd->dcv[1] = jd->dcv[0] = 0;       /* Initialize DC values */
+       rst = rsc = 0;
+
+       rc = JDR_OK;
+       for (y = 0; y < jd->height; y += my) {          /* Vertical loop of MCUs */
+               for (x = 0; x < jd->width; x += mx) {   /* Horizontal loop of MCUs */
+                       if (jd->nrst && rst++ == jd->nrst) {    /* Process restart interval if enabled */
+                               rc = restart(jd, rsc++);
+                               if (rc != JDR_OK) return rc;
+                               rst = 1;
+                       }
+                       rc = mcu_load(jd);                                      /* Load an MCU (decompress huffman coded stream and apply IDCT) */
+                       if (rc != JDR_OK) return rc;
+                       rc = mcu_output(jd, outfunc, x, y);     /* Output the MCU (color space conversion, scaling and output) */
+                       if (rc != JDR_OK) return rc;
+               }
+       }
+
+       return rc;
+}
+
+
+

diff --git a/examples/peripherals/spi_master/main/decode_image.c b/examples/peripherals/spi_master/main/decode_image.c
index 4a4b4daed93c25651f9b363cdced15dcece048cf..179c3deb7a271ad9532eb923c282b86901ea1f0a 100644 (file)
--- a/examples/peripherals/spi_master/main/decode_image.c
+++ b/examples/peripherals/spi_master/main/decode_image.c
@@ -7,72 +7,69 @@
    CONDITIONS OF ANY KIND, either express or implied.
 */
 
-
 /*
-The image used for the effect on the LCD in the SPI master example is stored in flash 
-as a jpeg file. This file contains the decode_image routine, which uses the tiny JPEG 
-decoder library in ROM to decode this JPEG into a format that can be sent to the display.
+The image used for the effect on the LCD in the SPI master example is stored in flash
+as a jpeg file. This file contains the decode_image routine, which uses the tiny JPEG
+decoder library to decode this JPEG into a format that can be sent to the display.
 
-Keep in mind that the decoder library cannot handle progressive files (will give 
+Keep in mind that the decoder library cannot handle progressive files (will give
 ``Image decoder: jd_prepare failed (8)`` as an error) so make sure to save in the correct
 format if you want to use a different image file.
 */
 
-
 #include "decode_image.h"
-#include "esp32/rom/tjpgd.h"
+#include "tjpgd.h"
 #include "esp_log.h"
 #include <string.h>
 
 //Reference the binary-included jpeg file
-extern const uint8_t image_jpg_start[]   asm("_binary_image_jpg_start");
-extern const uint8_t image_jpg_end[]     asm("_binary_image_jpg_end");
+extern const uint8_t image_jpg_start[] asm("_binary_image_jpg_start");
+extern const uint8_t image_jpg_end[] asm("_binary_image_jpg_end");
 //Define the height and width of the jpeg file. Make sure this matches the actual jpeg
 //dimensions.
 #define IMAGE_W 336
 #define IMAGE_H 256
 
-
-const char *TAG="ImageDec";
-
+const char *TAG = "ImageDec";
 
 //Data that is passed from the decoder function to the infunc/outfunc functions.
 typedef struct {
-    const unsigned char *inData;       //Pointer to jpeg data
-    int inPos;                                         //Current position in jpeg data
-    uint16_t **outData;                                //Array of IMAGE_H pointers to arrays of IMAGE_W 16-bit pixel values
-    int outW;                                          //Width of the resulting file
-    int outH;                                          //Height of the resulting file
+    const unsigned char *inData; //Pointer to jpeg data
+    uint16_t inPos;              //Current position in jpeg data
+    uint16_t **outData;          //Array of IMAGE_H pointers to arrays of IMAGE_W 16-bit pixel values
+    int outW;                    //Width of the resulting file
+    int outH;                    //Height of the resulting file
 } JpegDev;
 
-
 //Input function for jpeg decoder. Just returns bytes from the inData field of the JpegDev structure.
-static UINT infunc(JDEC *decoder, BYTE *buf, UINT len) 
+static uint16_t infunc(JDEC *decoder, uint8_t *buf, uint16_t len)
 {
     //Read bytes from input file
-    JpegDev *jd=(JpegDev*)decoder->device;
-    if (buf!=NULL) memcpy(buf, jd->inData+jd->inPos, len);
-    jd->inPos+=len;
+    JpegDev *jd = (JpegDev *)decoder->device;
+    if (buf != NULL) {
+        memcpy(buf, jd->inData + jd->inPos, len);
+    }
+    jd->inPos += len;
     return 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 UINT outfunc(JDEC *decoder, void *bitmap, JRECT *rect) 
+static uint16_t outfunc(JDEC *decoder, void *bitmap, JRECT *rect)
 {
-    JpegDev *jd=(JpegDev*)decoder->device;
-    uint8_t *in=(uint8_t*)bitmap;
-    for (int y=rect->top; y<=rect->bottom; y++) {
-        for (int x=rect->left; x<=rect->right; x++) {
+    JpegDev *jd = (JpegDev *)decoder->device;
+    uint8_t *in = (uint8_t *)bitmap;
+    for (int y = rect->top; y <= rect->bottom; y++) {
+        for (int x = rect->left; x <= rect->right; x++) {
             //We need to convert the 3 bytes in `in` to a rgb565 value.
-            uint16_t v=0;
-            v|=((in[0]>>3)<<11);
-            v|=((in[1]>>2)<<5);
-            v|=((in[2]>>3)<<0);
+            uint16_t v = 0;
+            v |= ((in[0] >> 3) << 11);
+            v |= ((in[1] >> 2) << 5);
+            v |= ((in[2] >> 3) << 0);
             //The LCD wants the 16-bit value in big-endian, so swap bytes
-            v=(v>>8)|(v<<8);
-            jd->outData[y][x]=v;
-            in+=3;
+            v = (v >> 8) | (v << 8);
+            jd->outData[y][x] = v;
+            in += 3;
         }
     }
     return 1;
@@ -82,68 +79,67 @@ static UINT outfunc(JDEC *decoder, void *bitmap, JRECT *rect)
 #define WORKSZ 3100
 
 //Decode the embedded image into pixel lines that can be used with the rest of the logic.
-esp_err_t decode_image(uint16_t ***pixels) 
+esp_err_t decode_image(uint16_t ***pixels)
 {
-    char *work=NULL;
+    char *work = NULL;
     int r;
     JDEC decoder;
     JpegDev jd;
-    *pixels=NULL;
-    esp_err_t ret=ESP_OK;
-
+    *pixels = NULL;
+    esp_err_t ret = ESP_OK;
 
     //Alocate pixel memory. Each line is an array of IMAGE_W 16-bit pixels; the `*pixels` array itself contains pointers to these lines.
-    *pixels=calloc(IMAGE_H, sizeof(uint16_t*));
-    if (*pixels==NULL) {
+    *pixels = calloc(IMAGE_H, sizeof(uint16_t *));
+    if (*pixels == NULL) {
         ESP_LOGE(TAG, "Error allocating memory for lines");
-        ret=ESP_ERR_NO_MEM;
+        ret = ESP_ERR_NO_MEM;
         goto err;
     }
-    for (int i=0; i<IMAGE_H; i++) {
-        (*pixels)[i]=malloc(IMAGE_W*sizeof(uint16_t));
-        if ((*pixels)[i]==NULL) {
+    for (int i = 0; i < IMAGE_H; i++) {
+        (*pixels)[i] = malloc(IMAGE_W * sizeof(uint16_t));
+        if ((*pixels)[i] == NULL) {
             ESP_LOGE(TAG, "Error allocating memory for line %d", i);
-            ret=ESP_ERR_NO_MEM;
+            ret = ESP_ERR_NO_MEM;
             goto err;
         }
     }
 
     //Allocate the work space for the jpeg decoder.
-    work=calloc(WORKSZ, 1);
-    if (work==NULL) {
+    work = calloc(WORKSZ, 1);
+    if (work == NULL) {
         ESP_LOGE(TAG, "Cannot allocate workspace");
-        ret=ESP_ERR_NO_MEM;
+        ret = ESP_ERR_NO_MEM;
         goto err;
     }
 
     //Populate fields of the JpegDev struct.
-    jd.inData=image_jpg_start;
-    jd.inPos=0;
-    jd.outData=*pixels;
-    jd.outW=IMAGE_W;
-    jd.outH=IMAGE_H;
-    
+    jd.inData = image_jpg_start;
+    jd.inPos = 0;
+    jd.outData = *pixels;
+    jd.outW = IMAGE_W;
+    jd.outH = IMAGE_H;
+
     //Prepare and decode the jpeg.
-    r=jd_prepare(&decoder, infunc, work, WORKSZ, (void*)&jd);
-    if (r!=JDR_OK) {
+    r = jd_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;
+        ret = ESP_ERR_NOT_SUPPORTED;
         goto err;
     }
-    r=jd_decomp(&decoder, outfunc, 0);
-    if (r!=JDR_OK) {
+    r = jd_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;
+        ret = ESP_ERR_NOT_SUPPORTED;
         goto err;
     }
-    
+
     //All done! Free the work area (as we don't need it anymore) and return victoriously.
     free(work);
     return ret;
 err:
     //Something went wrong! Exit cleanly, de-allocating everything we allocated.
-    if (*pixels!=NULL) {
-        for (int i=0; i<IMAGE_H; i++) {
+    if (*pixels != NULL) {
+        for (int i = 0; i < IMAGE_H; i++) {
             free((*pixels)[i]);
         }
         free(*pixels);

diff --git a/examples/peripherals/spi_slave/receiver/main/app_main.c b/examples/peripherals/spi_slave/receiver/main/app_main.c
index 3071e77d29e75c04646550240acdd15589d90eff..0defcb4ec5b68791fb50b51752af6edc4b608624 100644 (file)
--- a/examples/peripherals/spi_slave/receiver/main/app_main.c
+++ b/examples/peripherals/spi_slave/receiver/main/app_main.c
@@ -27,7 +27,6 @@
 #include "esp_event_loop.h"
 #include "nvs_flash.h"
 #include "soc/rtc_periph.h"
-#include "esp32/rom/cache.h"
 #include "driver/spi_slave.h"
 #include "esp_log.h"
 #include "esp_spi_flash.h"

diff --git a/examples/peripherals/spi_slave/sender/main/app_main.c b/examples/peripherals/spi_slave/sender/main/app_main.c
index 66323dad5504715e5c624af04371dbf0434feace..a8bcc6e0b67caafe7886358d59d3e8fdec149872 100644 (file)
--- a/examples/peripherals/spi_slave/sender/main/app_main.c
+++ b/examples/peripherals/spi_slave/sender/main/app_main.c
@@ -27,7 +27,6 @@
 #include "esp_event_loop.h"
 #include "nvs_flash.h"
 #include "soc/rtc_periph.h"
-#include "esp32/rom/cache.h"
 #include "driver/spi_master.h"
 #include "esp_log.h"
 #include "esp_spi_flash.h"
@@ -39,12 +38,12 @@
 /*
 SPI sender (master) example.
 
-This example is supposed to work together with the SPI receiver. It uses the standard SPI pins (MISO, MOSI, SCLK, CS) to 
+This example is supposed to work together with the SPI receiver. It uses the standard SPI pins (MISO, MOSI, SCLK, CS) to
 transmit data over in a full-duplex fashion, that is, while the master puts data on the MOSI pin, the slave puts its own
 data on the MISO pin.
 
 This example uses one extra pin: GPIO_HANDSHAKE is used as a handshake pin. The slave makes this pin high as soon as it is
-ready to receive/send data. This code connects this line to a GPIO interrupt which gives the rdySem semaphore. The main 
+ready to receive/send data. This code connects this line to a GPIO interrupt which gives the rdySem semaphore. The main
 task waits for this semaphore to be given before queueing a transmission.
 */
 
@@ -137,7 +136,7 @@ void app_main(void)
     ret=spi_bus_add_device(HSPI_HOST, &devcfg, &handle);
     assert(ret==ESP_OK);
 
-    //Assume the slave is ready for the first transmission: if the slave started up before us, we will not detect 
+    //Assume the slave is ready for the first transmission: if the slave started up before us, we will not detect
     //positive edge on the handshake line.
     xSemaphoreGive(rdySem);
 

diff --git a/examples/system/console/components/cmd_system/cmd_system.c b/examples/system/console/components/cmd_system/cmd_system.c
index caf8d70f231e92f6a0c36cb27718983f74fd94d9..e78e41bc1617c7ab4ab8b1cf00ca31f07b44c329 100644 (file)
--- a/examples/system/console/components/cmd_system/cmd_system.c
+++ b/examples/system/console/components/cmd_system/cmd_system.c
@@ -20,7 +20,6 @@
 #include "argtable3/argtable3.h"
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
-#include "esp32/rom/uart.h"
 #include "cmd_system.h"
 #include "sdkconfig.h"
 
@@ -292,7 +291,7 @@ static int light_sleep(int argc, char **argv)
         ESP_ERROR_CHECK( esp_sleep_enable_uart_wakeup(CONFIG_ESP_CONSOLE_UART_NUM) );
     }
     fflush(stdout);
-    uart_tx_wait_idle(CONFIG_ESP_CONSOLE_UART_NUM);
+    uart_wait_tx_idle_polling(CONFIG_ESP_CONSOLE_UART_NUM);
     esp_light_sleep_start();
     esp_sleep_wakeup_cause_t cause = esp_sleep_get_wakeup_cause();
     const char *cause_str;

diff --git a/examples/system/himem/main/himem_test_main.c b/examples/system/himem/main/himem_test_main.c
index 955046b2de8f0395c0566fb651f445514fdd1bbf..004409081b23748ebec7a747894bb668d56c5089 100644 (file)
--- a/examples/system/himem/main/himem_test_main.c
+++ b/examples/system/himem/main/himem_test_main.c
@@ -16,7 +16,6 @@
 #include "nvs_flash.h"
 #include "esp_heap_caps.h"
 #include "esp32/spiram.h"
-#include "esp32/rom/cache.h"
 #include "sdkconfig.h"
 #include "esp32/himem.h"
 

diff --git a/examples/system/light_sleep/main/light_sleep_example_main.c b/examples/system/light_sleep/main/light_sleep_example_main.c
index 8fb02b47bb10ec3a92d4faf15be3da3f8e45bdae..4b8dc171151e90098fc6b1af7326750d8c2465e4 100644 (file)
--- a/examples/system/light_sleep/main/light_sleep_example_main.c
+++ b/examples/system/light_sleep/main/light_sleep_example_main.c
@@ -16,7 +16,7 @@
 #include "freertos/task.h"
 #include "esp_sleep.h"
 #include "esp_log.h"
-#include "esp32/rom/uart.h"
+#include "driver/uart.h"
 #include "driver/rtc_io.h"
 
 /* Most development boards have "boot" button attached to GPIO0.
@@ -57,7 +57,7 @@ void app_main(void)
         /* To make sure the complete line is printed before entering sleep mode,
          * need to wait until UART TX FIFO is empty:
          */
-        uart_tx_wait_idle(CONFIG_ESP_CONSOLE_UART_NUM);
+        uart_wait_tx_idle_polling(CONFIG_ESP_CONSOLE_UART_NUM);
 
         /* Get timestamp before entering sleep */
         int64_t t_before_us = esp_timer_get_time();

diff --git a/examples/wifi/espnow/main/espnow_example_main.c b/examples/wifi/espnow/main/espnow_example_main.c
index fbfde5780caff9bf1d806c3af910097398e17f57..ad540eb33547fbc2be7ee37f466d8ac4b75a55e9 100644 (file)
--- a/examples/wifi/espnow/main/espnow_example_main.c
+++ b/examples/wifi/espnow/main/espnow_example_main.c
@@ -26,8 +26,7 @@
 #include "esp_log.h"
 #include "esp_system.h"
 #include "esp_now.h"
-#include "esp32/rom/ets_sys.h"
-#include "esp32/rom/crc.h"
+#include "esp_crc.h"
 #include "espnow_example.h"
 
 static const char *TAG = "espnow_example";
@@ -123,7 +122,7 @@ int example_espnow_data_parse(uint8_t *data, uint16_t data_len, uint8_t *state,
     *magic = buf->magic;
     crc = buf->crc;
     buf->crc = 0;
-    crc_cal = crc16_le(UINT16_MAX, (uint8_t const *)buf, data_len);
+    crc_cal = esp_crc16_le(UINT16_MAX, (uint8_t const *)buf, data_len);
 
     if (crc_cal == crc) {
         return buf->type;
@@ -146,7 +145,7 @@ void example_espnow_data_prepare(example_espnow_send_param_t *send_param)
     buf->magic = send_param->magic;
     /* Fill all remaining bytes after the data with random values */
     esp_fill_random(buf->payload, send_param->len - sizeof(example_espnow_data_t));
-    buf->crc = crc16_le(UINT16_MAX, (uint8_t const *)buf, send_param->len);
+    buf->crc = esp_crc16_le(UINT16_MAX, (uint8_t const *)buf, send_param->len);
 }
 
 static void example_espnow_task(void *pvParameter)

diff --git a/tools/ci/check_examples_rom_header.sh b/tools/ci/check_examples_rom_header.sh
new file mode 100755 (executable)
index 0000000..131723e
--- /dev/null
+++ b/tools/ci/check_examples_rom_header.sh
@@ -0,0 +1,19 @@
+#!/bin/bash
+
+# Examples shouldn't include rom headers directly
+
+output=$(find ${IDF_PATH}/examples -name "*.[chS]" -o -name "*.cpp" -not -path "**/build/**")
+files=$(grep ".*include.*rom.*h" ${output} | cut -d ":" -f 1)
+found_rom=0
+for file in ${files}
+do
+    echo "${file} contains rom headers!"
+    found_rom=`expr $found_rom + 1`;
+done
+
+if [ $found_rom -eq 0 ]; then
+    echo "No rom headers found in examples"
+    exit 0
+fi
+
+exit 1

diff --git a/tools/ci/config/check.yml b/tools/ci/config/check.yml
index ad4f71290c8af559c48d029cf74c3f6e8c7a9992..7507c47ed4912976d6df3002abad280cfb3b6aef 100644 (file)
--- a/tools/ci/config/check.yml
+++ b/tools/ci/config/check.yml
@@ -42,6 +42,11 @@ check_examples_cmake_make:
   script:
     - tools/ci/check_examples_cmake_make.sh
 
+check_examples_rom_header:
+  extends: .check_job_template_with_filter
+  script:
+    - tools/ci/check_examples_rom_header.sh
+
 check_python_style:
   extends: .check_job_template_with_filter
   artifacts:

diff --git a/tools/ci/executable-list.txt b/tools/ci/executable-list.txt
index 4e580c5a85040f9021d38e762143bbab0add1fe8..bcc257b3d4f4eb153469cee1d4a21cbab08869e3 100644 (file)
--- a/tools/ci/executable-list.txt
+++ b/tools/ci/executable-list.txt
@@ -35,6 +35,7 @@ tools/ci/build_examples_cmake.sh
 tools/ci/check-executable.sh
 tools/ci/check-line-endings.sh
 tools/ci/check_examples_cmake_make.sh
+tools/ci/check_examples_rom_header.sh
 tools/ci/check_idf_version.sh
 tools/ci/check_ut_cmake_make.sh
 tools/ci/checkout_project_ref.py