Mirrors/esp-idf
1
0
Fork 0
mirror of https://github.com/espressif/esp-idf.git synced 2026-10-02 03:00:34 +03:00
Code Issues Packages Projects Releases Wiki Activity

fix(jpeg): JPEG can encode and decode in encryption situation

Browse Source
This commit is contained in:
C.S.M
2026-07-22 19:46:38 +08:00
parent da4a2024f2
commit 0bcccf3206
24 changed files with 1293 additions and 548 deletions
Download Patch File Download Diff File Expand all files Collapse all files
examples/peripherals/jpeg/jpeg_encode/main/CMakeLists.txt
+4 -2
View File
@@ -1,3 +1,5 @@
idf_component_register(SRCS "jpeg_encode_main.c"
PRIV_REQUIRES fatfs esp_driver_jpeg
idf_component_register(SRCS "jpeg_encode_example_main.c"
PRIV_REQUIRES fatfs esp_driver_jpeg mbedtls esp_psram
INCLUDE_DIRS ".")
target_add_binary_data(${COMPONENT_LIB} "${CMAKE_CURRENT_LIST_DIR}/assets/esp720p.rgb" BINARY RENAME_TO "esp720p_rgb")
examples/peripherals/jpeg/jpeg_encode/main/Kconfig.projbuild
-18
View File
@@ -1,18 +0,0 @@
menu "JPEG Encode Example menu"
config EXAMPLE_FORMAT_IF_MOUNT_FAILED
bool "Format the card if mount failed"
default n
help
If this config item is set, format_if_mount_failed will be set to true and the card will be formatted if
the mount has failed.
config EXAMPLE_SDMMC_IO_POWER_INTERNAL_LDO
depends on SOC_SDMMC_IO_POWER_EXTERNAL
bool "SDMMC IO power supply comes from internal LDO (READ HELP!)"
default y
help
Please read the schematic first and check if the SDMMC VDD is connected to any internal LDO output.
If the SDMMC is powered by an external supplier, unselect me
endmenu
examples/peripherals/jpeg/jpeg_encode/main/assets/esp720p.rgb
+393
View File
File diff suppressed because one or more lines are too long
examples/peripherals/jpeg/jpeg_encode/main/jpeg_encode_example_main.c
+120
View File
@@ -0,0 +1,120 @@
/*
* SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Unlicense OR CC0-1.0
*/
#include <assert.h>
#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "mbedtls/base64.h"
#include "esp_check.h"
#include "driver/jpeg_encode.h"
#define EXAMPLE_WIDTH 1280
#define EXAMPLE_HEIGHT 720
#define EXAMPLE_RGB_FRAME_SIZE (EXAMPLE_WIDTH * EXAMPLE_HEIGHT * 3)
#define EXAMPLE_JPEG_BUFFER_SIZE (EXAMPLE_RGB_FRAME_SIZE / 10) /* Estimate output size with an approximately 10:1 JPEG compression ratio for this demo image. */
#define EXAMPLE_BASE64_CHUNK_LEN 96
#define EXAMPLE_JPEG_QUALITY 80
extern const uint8_t esp720p_rgb_start[] asm("_binary_esp720p_rgb_start");
extern const uint8_t esp720p_rgb_end[] asm("_binary_esp720p_rgb_end");
static void print_base64_payload(const unsigned char *encoded, size_t encoded_len)
{
/* Split the printable payload into short lines so it is easy to read in
* the serial monitor and robust for pytest to parse back into a JPEG. */
printf("JPEG_BASE64_BEGIN\n");
for (size_t offset = 0; offset < encoded_len; offset += EXAMPLE_BASE64_CHUNK_LEN) {
size_t chunk_len = encoded_len - offset;
if (chunk_len > EXAMPLE_BASE64_CHUNK_LEN) {
chunk_len = EXAMPLE_BASE64_CHUNK_LEN;
}
printf("JPEG_BASE64 %.*s\n", (int)chunk_len, (const char *)&encoded[offset]);
}
printf("JPEG_BASE64_END\n");
}
void app_main(void)
{
/* EMBED_FILES turns the raw asset into linker symbols, so the example can
* read the picture directly from flash without mounting a filesystem. */
const size_t embedded_size = esp720p_rgb_end - esp720p_rgb_start;
uint32_t jpeg_size = 0;
jpeg_encoder_handle_t jpeg_handle = NULL;
uint8_t *rgb_buf = NULL;
printf("Loading embedded BGR24 image from flash...\n");
printf("Embedded raw image size: %zu bytes\n", embedded_size);
assert(embedded_size == EXAMPLE_RGB_FRAME_SIZE);
/* Despite the enum name, the current driver maps
* JPEG_ENCODE_IN_FORMAT_RGB888 to a BGR24-style byte layout.
* Keep the embedded raw asset in bgr24 order or red/blue will swap. */
jpeg_encode_cfg_t enc_config = {
.src_type = JPEG_ENCODE_IN_FORMAT_RGB888,
.sub_sample = JPEG_DOWN_SAMPLING_YUV422,
.image_quality = EXAMPLE_JPEG_QUALITY,
.width = EXAMPLE_WIDTH,
.height = EXAMPLE_HEIGHT,
};
const uint8_t *rgb_src = esp720p_rgb_start;
#if CONFIG_SECURE_FLASH_ENC_ENABLED
size_t input_buffer_size = 0;
jpeg_encode_memory_alloc_cfg_t rx_mem_cfg = {
.buffer_direction = JPEG_ENC_ALLOC_INPUT_BUFFER,
};
rgb_buf = (uint8_t *)jpeg_alloc_encoder_mem(EXAMPLE_RGB_FRAME_SIZE, &rx_mem_cfg, &input_buffer_size);
assert(rgb_buf != NULL);
memcpy(rgb_buf, esp720p_rgb_start, EXAMPLE_RGB_FRAME_SIZE);
rgb_src = rgb_buf;
#endif
size_t result_buffer_size = 0;
/* The output JPEG is compressed, so the example does not need to reserve
* a full raw-frame worth of space for the bitstream. This 10:1 estimate
* is intentionally conservative for the bundled demo image and quality
* setting; real applications should size this buffer for their own worst
* case and handle "buffer too small" errors if needed. */
jpeg_encode_memory_alloc_cfg_t mem_cfg = {
.buffer_direction = JPEG_ENC_ALLOC_OUTPUT_BUFFER,
};
uint8_t *jpeg_buf = (uint8_t *)jpeg_alloc_encoder_mem(EXAMPLE_JPEG_BUFFER_SIZE, &mem_cfg, &result_buffer_size);
assert(jpeg_buf != NULL);
/* Create the encoder instance once, then feed it one full-frame request. */
jpeg_encode_engine_cfg_t encode_eng_cfg = {
.timeout_ms = 200,
};
ESP_ERROR_CHECK(jpeg_new_encoder_engine(&encode_eng_cfg, &jpeg_handle));
printf("Encoding BGR24(raw) -> JPEG...\n");
ESP_ERROR_CHECK(jpeg_encoder_process(jpeg_handle, &enc_config, rgb_src, EXAMPLE_RGB_FRAME_SIZE,
jpeg_buf, result_buffer_size, &jpeg_size));
printf("Encoded JPEG size: %" PRIu32 " bytes\n", jpeg_size);
size_t encoded_len = 0;
/* First call asks mbedTLS how big the base64 buffer must be, then the
* second call performs the actual binary-to-text conversion. */
int ret = mbedtls_base64_encode(NULL, 0, &encoded_len, jpeg_buf, jpeg_size);
ESP_ERROR_CHECK((ret == MBEDTLS_ERR_BASE64_BUFFER_TOO_SMALL) ? ESP_OK : ESP_FAIL);
unsigned char *encoded = calloc(encoded_len + 1, 1);
assert(encoded != NULL);
ESP_ERROR_CHECK(mbedtls_base64_encode(encoded, encoded_len + 1, &encoded_len, jpeg_buf, jpeg_size) == 0 ? ESP_OK : ESP_FAIL);
/* JPEG_META plus the chunked JPEG_BASE64 lines form a tiny text protocol
* that pytest understands and can reconstruct into a host-side .jpeg. */
printf("JPEG_META width=%u height=%u format=JPEG encoding=base64 size=%" PRIu32 "\n",
EXAMPLE_WIDTH, EXAMPLE_HEIGHT, jpeg_size);
print_base64_payload(encoded, encoded_len);
printf("JPEG encode demo done.\n");
ESP_ERROR_CHECK(jpeg_del_encoder_engine(jpeg_handle));
free(encoded);
free(jpeg_buf);
free(rgb_buf);
}
examples/peripherals/jpeg/jpeg_encode/main/jpeg_encode_main.c
-153
View File
@@ -1,153 +0,0 @@
/*
* SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Unlicense OR CC0-1.0
*/
#include <stdio.h>
#include <string.h>
#include "esp_heap_caps.h"
#include "esp_vfs_fat.h"
#include "sdmmc_cmd.h"
#include "driver/sdmmc_host.h"
#include "driver/jpeg_encode.h"
#include "sd_pwr_ctrl_by_on_chip_ldo.h"
static const char *TAG = "jpeg.example";
static sdmmc_card_t *s_card;
#define MOUNT_POINT "/sdcard"
const static char s_infile_1080p[] = "/sdcard/esp1080.rgb";
const static char s_outfile_1080p[] = "/sdcard/outjpg.jpg";
static esp_err_t sdcard_init(void)
{
esp_err_t ret = ESP_OK;
esp_vfs_fat_sdmmc_mount_config_t mount_config = {
#ifdef CONFIG_EXAMPLE_FORMAT_IF_MOUNT_FAILED
.format_if_mount_failed = true,
#else
.format_if_mount_failed = false,
#endif // EXAMPLE_FORMAT_IF_MOUNT_FAILED
.max_files = 5,
.allocation_unit_size = 16 * 1024
};
const char mount_point[] = MOUNT_POINT;
ESP_LOGI(TAG, "Initializing SD card");
sdmmc_host_t host = SDMMC_HOST_DEFAULT();
host.max_freq_khz = SDMMC_FREQ_HIGHSPEED;
#if CONFIG_EXAMPLE_SDMMC_IO_POWER_INTERNAL_LDO
sd_pwr_ctrl_ldo_config_t ldo_config = {
.ldo_chan_id = 4, // `LDO_VO4` is used as the SDMMC IO power
};
sd_pwr_ctrl_handle_t pwr_ctrl_handle = NULL;
ret = sd_pwr_ctrl_new_on_chip_ldo(&ldo_config, &pwr_ctrl_handle);
if (ret != ESP_OK) {
ESP_LOGE(TAG, "Failed to new an on-chip ldo power control driver");
return ret;
}
host.pwr_ctrl_handle = pwr_ctrl_handle;
#endif
// This initializes the slot without card detect (CD) and write protect (WP) signals.
// Modify slot_config.gpio_cd and slot_config.gpio_wp if your board has these signals.
sdmmc_slot_config_t slot_config = SDMMC_SLOT_CONFIG_DEFAULT();
slot_config.width = 4;
slot_config.flags |= SDMMC_SLOT_FLAG_INTERNAL_PULLUP;
ret = esp_vfs_fat_sdmmc_mount(mount_point, &host, &slot_config, &mount_config, &s_card);
if (ret != ESP_OK) {
if (ret == ESP_FAIL) {
ESP_LOGE(TAG, "Failed to mount filesystem. "
"If you want the card to be formatted, set the EXAMPLE_FORMAT_IF_MOUNT_FAILED menuconfig option.");
} else {
ESP_LOGE(TAG, "Failed to initialize the card (%s). "
"Make sure SD card lines have pull-up resistors in place.", esp_err_to_name(ret));
}
return ret;
}
// Card has been initialized, print its properties
sdmmc_card_print_info(stdout, s_card);
return ret;
}
static void sdcard_deinit(void)
{
const char mount_point[] = MOUNT_POINT;
esp_vfs_fat_sdcard_unmount(mount_point, s_card);
#if SOC_SDMMC_IO_POWER_EXTERNAL
esp_err_t ret = sd_pwr_ctrl_del_on_chip_ldo(s_card->host.pwr_ctrl_handle);
if (ret != ESP_OK) {
ESP_LOGE(TAG, "Failed to delete on-chip ldo power control driver");
return;
}
#endif
}
void app_main(void)
{
ESP_ERROR_CHECK(sdcard_init());
uint32_t raw_size_1080p;
uint32_t jpg_size_1080p;
jpeg_encoder_handle_t jpeg_handle;
FILE *file_raw_1080p = fopen(s_infile_1080p, "rb");
ESP_LOGI(TAG, "s_infile_1080p:%s", s_infile_1080p);
if (file_raw_1080p == NULL) {
ESP_LOGE(TAG, "fopen file_raw_1080p error");
return;
}
jpeg_encode_engine_cfg_t encode_eng_cfg = {
.timeout_ms = 70,
};
jpeg_encode_memory_alloc_cfg_t rx_mem_cfg = {
.buffer_direction = JPEG_DEC_ALLOC_OUTPUT_BUFFER,
};
jpeg_encode_memory_alloc_cfg_t tx_mem_cfg = {
.buffer_direction = JPEG_DEC_ALLOC_INPUT_BUFFER,
};
ESP_ERROR_CHECK(jpeg_new_encoder_engine(&encode_eng_cfg, &jpeg_handle));
// Read 1080p raw picture
fseek(file_raw_1080p, 0, SEEK_END);
raw_size_1080p = ftell(file_raw_1080p);
fseek(file_raw_1080p, 0, SEEK_SET);
size_t tx_buffer_size = 0;
uint8_t *raw_buf_1080p = (uint8_t*)jpeg_alloc_encoder_mem(raw_size_1080p, &tx_mem_cfg, &tx_buffer_size);
assert(raw_buf_1080p != NULL);
fread(raw_buf_1080p, 1, raw_size_1080p, file_raw_1080p);
fclose(file_raw_1080p);
size_t rx_buffer_size = 0;
uint8_t *jpg_buf_1080p = (uint8_t*)jpeg_alloc_encoder_mem(raw_size_1080p / 10, &rx_mem_cfg, &rx_buffer_size); // Assume that compression ratio of 10 to 1
assert(jpg_buf_1080p != NULL);
jpeg_encode_cfg_t enc_config = {
.src_type = JPEG_ENCODE_IN_FORMAT_RGB888,
.sub_sample = JPEG_DOWN_SAMPLING_YUV422,
.image_quality = 80,
.width = 1920,
.height = 1080,
};
ESP_ERROR_CHECK(jpeg_encoder_process(jpeg_handle, &enc_config, raw_buf_1080p, raw_size_1080p, jpg_buf_1080p, rx_buffer_size, &jpg_size_1080p));
FILE *file_jpg_1080p = fopen(s_outfile_1080p, "wb");
ESP_LOGI(TAG, "outfile:%s", s_outfile_1080p);
if (file_jpg_1080p == NULL) {
ESP_LOGE(TAG, "fopen file_jpg_1080p error");
return;
}
fwrite(jpg_buf_1080p, 1, jpg_size_1080p, file_jpg_1080p);
fclose(file_jpg_1080p);
sdcard_deinit();
ESP_LOGI(TAG, "Card unmounted");
}