alex/esp-idf
1
0
Fork 0
mirror of https://github.com/espressif/esp-idf.git synced 2025-10-03 03:58:12 +00:00
Code Issues Packages Projects Releases Wiki Activity

exclude rom headers in examples

Browse Source 
1. avoid including rom headers directly in examples
2. add common API interface for CRC calculation in esp_common component
This commit is contained in:
suda-morris
2019-05-22 20:21:11 +08:00
parent 5e39718c22
commit b1497f2187
19 changed files with 1292 additions and 92 deletions
Download Patch File Download Diff File Expand all files Collapse all files

124
examples/peripherals/spi_master/main/decode_image.c
View File

@@ -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);