Merge branch 'refactor/ppa_dma2d_fourcc' into 'master'

refactor(ppa): use fourcc for dma2d and ppa color formats

Closes IDF-14234

See merge request espressif/esp-idf!43435

Author: suda-morris

components/esp_driver_jpeg/include/driver/jpeg_types.h

@@ -19,8 +19,8 @@ extern "C" {
  * @brief Enumeration for jpeg output format.
  */
 typedef enum {
-    JPEG_DECODE_OUT_FORMAT_RGB888 = ESP_COLOR_FOURCC_RGB24,        /*!< output RGB888 format */
-    JPEG_DECODE_OUT_FORMAT_RGB565 = ESP_COLOR_FOURCC_RGB16_BE,        /*!< output RGB565 format */
+    JPEG_DECODE_OUT_FORMAT_RGB888 = ESP_COLOR_FOURCC_BGR24,        /*!< output RGB888 format */
+    JPEG_DECODE_OUT_FORMAT_RGB565 = ESP_COLOR_FOURCC_RGB16,        /*!< output RGB565 format */
     JPEG_DECODE_OUT_FORMAT_GRAY = ESP_COLOR_FOURCC_GREY,          /*!< output the gray picture */
     JPEG_DECODE_OUT_FORMAT_YUV444 = ESP_COLOR_FOURCC_YUV,        /*!< output yuv444 format */
     JPEG_DECODE_OUT_FORMAT_YUV422 = ESP_COLOR_FOURCC_YVYU,        /*!< output yuv422 format */
@@ -55,8 +55,8 @@ typedef enum {
  * @brief Enumeration for jpeg input format.
  */
 typedef enum {
-    JPEG_ENCODE_IN_FORMAT_RGB888 = ESP_COLOR_FOURCC_RGB24,       /*!< input RGB888 format */
-    JPEG_ENCODE_IN_FORMAT_RGB565 = ESP_COLOR_FOURCC_RGB16_BE,       /*!< input RGB565 format */
+    JPEG_ENCODE_IN_FORMAT_RGB888 = ESP_COLOR_FOURCC_BGR24,       /*!< input RGB888 format */
+    JPEG_ENCODE_IN_FORMAT_RGB565 = ESP_COLOR_FOURCC_RGB16,       /*!< input RGB565 format */
     JPEG_ENCODE_IN_FORMAT_GRAY = ESP_COLOR_FOURCC_GREY,         /*!< input GRAY format */
     JPEG_ENCODE_IN_FORMAT_YUV422 = ESP_COLOR_FOURCC_YVYU,       /*!< input YUV422 format */
 #if !(CONFIG_ESP_REV_MIN_FULL < 300 && SOC_IS(ESP32P4)) // Invisible for unsupported chips

components/esp_driver_jpeg/jpeg_decode.c

@@ -439,7 +439,7 @@ static esp_err_t jpeg_dec_config_dma_descriptor(jpeg_decoder_handle_t decoder_en
     cfg_desc(decoder_engine, decoder_engine->txlink, JPEG_DMA2D_2D_DISABLE, DMA2D_DESCRIPTOR_BLOCK_RW_MODE_SINGLE, decoder_engine->header_info->buffer_left & JPEG_DMA2D_MAX_SIZE, decoder_engine->header_info->buffer_left & JPEG_DMA2D_MAX_SIZE, JPEG_DMA2D_EOF_NOT_LAST, 1, DMA2D_DESCRIPTOR_BUFFER_OWNER_DMA, (decoder_engine->header_info->buffer_left >> JPEG_DMA2D_1D_HIGH_14BIT), (decoder_engine->header_info->buffer_left >> JPEG_DMA2D_1D_HIGH_14BIT), decoder_engine->header_info->buffer_offset, NULL);
 
     // Configure rx link descriptor
-    cfg_desc(decoder_engine, decoder_engine->rxlink, JPEG_DMA2D_2D_ENABLE, DMA2D_DESCRIPTOR_BLOCK_RW_MODE_MULTIPLE, dma_vb, dma_hb, JPEG_DMA2D_EOF_NOT_LAST, dma2d_desc_pixel_format_to_pbyte_value_fourcc(decoder_engine->output_format), DMA2D_DESCRIPTOR_BUFFER_OWNER_DMA, decoder_engine->header_info->process_v, decoder_engine->header_info->process_h, decoder_engine->decoded_buf, NULL);
+    cfg_desc(decoder_engine, decoder_engine->rxlink, JPEG_DMA2D_2D_ENABLE, DMA2D_DESCRIPTOR_BLOCK_RW_MODE_MULTIPLE, dma_vb, dma_hb, JPEG_DMA2D_EOF_NOT_LAST, dma2d_desc_pixel_format_to_pbyte_value(decoder_engine->output_format), DMA2D_DESCRIPTOR_BUFFER_OWNER_DMA, decoder_engine->header_info->process_v, decoder_engine->header_info->process_h, decoder_engine->decoded_buf, NULL);
 
     return ESP_OK;
 }

components/esp_driver_jpeg/jpeg_encode.c

@@ -245,7 +245,7 @@ esp_err_t jpeg_encoder_process(jpeg_encoder_handle_t encoder_engine, const jpeg_
 
     // 2D direction
     memset(encoder_engine->txlink, 0, sizeof(dma2d_descriptor_t));
-    s_cfg_desc(encoder_engine, encoder_engine->txlink, JPEG_DMA2D_2D_ENABLE, DMA2D_DESCRIPTOR_BLOCK_RW_MODE_MULTIPLE, dma_vb, dma_hb, JPEG_DMA2D_EOF_NOT_LAST, dma2d_desc_pixel_format_to_pbyte_value_fourcc(encoder_engine->picture_format), DMA2D_DESCRIPTOR_BUFFER_OWNER_DMA, encoder_engine->header_info->origin_v, encoder_engine->header_info->origin_h, raw_buffer, NULL);
+    s_cfg_desc(encoder_engine, encoder_engine->txlink, JPEG_DMA2D_2D_ENABLE, DMA2D_DESCRIPTOR_BLOCK_RW_MODE_MULTIPLE, dma_vb, dma_hb, JPEG_DMA2D_EOF_NOT_LAST, dma2d_desc_pixel_format_to_pbyte_value(encoder_engine->picture_format), DMA2D_DESCRIPTOR_BUFFER_OWNER_DMA, encoder_engine->header_info->origin_v, encoder_engine->header_info->origin_h, raw_buffer, NULL);
 
     ret = esp_cache_msync((void*)raw_buffer, inbuf_size, ESP_CACHE_MSYNC_FLAG_DIR_C2M | ESP_CACHE_MSYNC_FLAG_UNALIGNED);
     assert(ret == ESP_OK);

components/esp_driver_ppa/include/driver/ppa.h

@@ -127,7 +127,6 @@ typedef struct {
     };
     ppa_color_range_t yuv_range;            /*!< When the color mode is any YUV color space, this field is to describe its color range */
     ppa_color_conv_std_rgb_yuv_t yuv_std;   /*!< When the color mode is any YUV color space, this field is to describe its YUV<->RGB conversion standard */
-    color_yuv422_pack_order_t yuv422_pack_order; /*!< When the color mode is YUV422, this field is to describe its data pack order */
 } ppa_in_pic_blk_config_t;
 
 /**

components/esp_driver_ppa/src/ppa_blend.c

@@ -46,16 +46,6 @@ bool ppa_blend_transaction_on_picked(uint32_t num_chans, const dma2d_trans_chann
     }
     assert(dma2d_tx_bg_chan && dma2d_tx_fg_chan && dma2d_rx_chan);
 
-    color_space_pixel_format_t in_bg_pixel_format = {
-        .color_type_id = blend_trans_desc->in_bg.blend_cm,
-    };
-    color_space_pixel_format_t in_fg_pixel_format = {
-        .color_type_id = blend_trans_desc->in_fg.blend_cm,
-    };
-    color_space_pixel_format_t out_pixel_format = {
-        .color_type_id = blend_trans_desc->out.blend_cm,
-    };
-
     // Fill 2D-DMA descriptors
     blend_engine->dma_tx_bg_desc->vb_size = blend_trans_desc->in_bg.block_h;
     blend_engine->dma_tx_bg_desc->hb_length = blend_trans_desc->in_bg.block_w;
@@ -65,7 +55,7 @@ bool ppa_blend_transaction_on_picked(uint32_t num_chans, const dma2d_trans_chann
     blend_engine->dma_tx_bg_desc->owner = DMA2D_DESCRIPTOR_BUFFER_OWNER_DMA;
     blend_engine->dma_tx_bg_desc->va_size = blend_trans_desc->in_bg.pic_h;
     blend_engine->dma_tx_bg_desc->ha_length = blend_trans_desc->in_bg.pic_w;
-    blend_engine->dma_tx_bg_desc->pbyte = dma2d_desc_pixel_format_to_pbyte_value(in_bg_pixel_format);
+    blend_engine->dma_tx_bg_desc->pbyte = dma2d_desc_pixel_format_to_pbyte_value((esp_color_fourcc_t)blend_trans_desc->in_bg.blend_cm);
     blend_engine->dma_tx_bg_desc->y = blend_trans_desc->in_bg.block_offset_y;
     blend_engine->dma_tx_bg_desc->x = blend_trans_desc->in_bg.block_offset_x;
     blend_engine->dma_tx_bg_desc->mode = DMA2D_DESCRIPTOR_BLOCK_RW_MODE_SINGLE;
@@ -80,7 +70,7 @@ bool ppa_blend_transaction_on_picked(uint32_t num_chans, const dma2d_trans_chann
     blend_engine->dma_tx_fg_desc->owner = DMA2D_DESCRIPTOR_BUFFER_OWNER_DMA;
     blend_engine->dma_tx_fg_desc->va_size = blend_trans_desc->in_fg.pic_h;
     blend_engine->dma_tx_fg_desc->ha_length = blend_trans_desc->in_fg.pic_w;
-    blend_engine->dma_tx_fg_desc->pbyte = dma2d_desc_pixel_format_to_pbyte_value(in_fg_pixel_format);
+    blend_engine->dma_tx_fg_desc->pbyte = dma2d_desc_pixel_format_to_pbyte_value((esp_color_fourcc_t)blend_trans_desc->in_fg.blend_cm);
     blend_engine->dma_tx_fg_desc->y = blend_trans_desc->in_fg.block_offset_y;
     blend_engine->dma_tx_fg_desc->x = blend_trans_desc->in_fg.block_offset_x;
     blend_engine->dma_tx_fg_desc->mode = DMA2D_DESCRIPTOR_BLOCK_RW_MODE_SINGLE;
@@ -95,7 +85,7 @@ bool ppa_blend_transaction_on_picked(uint32_t num_chans, const dma2d_trans_chann
     blend_engine->dma_rx_desc->owner = DMA2D_DESCRIPTOR_BUFFER_OWNER_DMA;
     blend_engine->dma_rx_desc->va_size = blend_trans_desc->out.pic_h;
     blend_engine->dma_rx_desc->ha_length = blend_trans_desc->out.pic_w;
-    blend_engine->dma_rx_desc->pbyte = dma2d_desc_pixel_format_to_pbyte_value(out_pixel_format);
+    blend_engine->dma_rx_desc->pbyte = dma2d_desc_pixel_format_to_pbyte_value((esp_color_fourcc_t)blend_trans_desc->out.blend_cm);
     blend_engine->dma_rx_desc->y = blend_trans_desc->out.block_offset_y;
     blend_engine->dma_rx_desc->x = blend_trans_desc->out.block_offset_x;
     blend_engine->dma_rx_desc->mode = DMA2D_DESCRIPTOR_BLOCK_RW_MODE_SINGLE;
@@ -140,27 +130,24 @@ bool ppa_blend_transaction_on_picked(uint32_t num_chans, const dma2d_trans_chann
 
     // Configure PPA Blending engine
     ppa_ll_blend_set_rx_bg_color_mode(platform->hal.dev, blend_trans_desc->in_bg.blend_cm);
-    if (COLOR_SPACE_TYPE((uint32_t)blend_trans_desc->in_bg.blend_cm) == COLOR_SPACE_YUV) {
+    if (PPA_IS_CM_YUV(blend_trans_desc->in_bg.blend_cm)) {
         ppa_ll_blend_set_rx_bg_yuv_range(platform->hal.dev, blend_trans_desc->in_bg.yuv_range);
         ppa_ll_blend_set_rx_bg_yuv2rgb_std(platform->hal.dev, blend_trans_desc->in_bg.yuv_std);
     }
-    if ((uint32_t)blend_trans_desc->in_bg.blend_cm == PPA_BLEND_COLOR_MODE_YUV422) {
-        ppa_ll_blend_set_rx_bg_yuv422_pack_order(platform->hal.dev, blend_trans_desc->in_bg.yuv422_pack_order);
-    }
     ppa_ll_blend_enable_rx_bg_byte_swap(platform->hal.dev, blend_trans_desc->bg_byte_swap);
     ppa_ll_blend_enable_rx_bg_rgb_swap(platform->hal.dev, blend_trans_desc->bg_rgb_swap);
     ppa_ll_blend_configure_rx_bg_alpha(platform->hal.dev, blend_trans_desc->bg_alpha_update_mode, blend_trans_desc->bg_alpha_value);
 
     ppa_ll_blend_set_rx_fg_color_mode(platform->hal.dev, blend_trans_desc->in_fg.blend_cm);
-    if (COLOR_SPACE_TYPE((uint32_t)blend_trans_desc->in_fg.blend_cm) == COLOR_SPACE_ALPHA) {
+    if (PPA_IS_CM_ALPHA(blend_trans_desc->in_fg.blend_cm)) {
         ppa_ll_blend_set_rx_fg_fix_rgb(platform->hal.dev, &blend_trans_desc->fg_fix_rgb_val);
     }
     ppa_ll_blend_enable_rx_fg_byte_swap(platform->hal.dev, blend_trans_desc->fg_byte_swap);
     ppa_ll_blend_enable_rx_fg_rgb_swap(platform->hal.dev, blend_trans_desc->fg_rgb_swap);
     ppa_ll_blend_configure_rx_fg_alpha(platform->hal.dev, blend_trans_desc->fg_alpha_update_mode, blend_trans_desc->fg_alpha_value);
 
     ppa_ll_blend_set_tx_color_mode(platform->hal.dev, blend_trans_desc->out.blend_cm);
-    if (COLOR_SPACE_TYPE((uint32_t)blend_trans_desc->out.blend_cm) == COLOR_SPACE_YUV) {
+    if (PPA_IS_CM_YUV(blend_trans_desc->out.blend_cm)) {
         ppa_ll_blend_set_tx_yuv_range(platform->hal.dev, blend_trans_desc->out.yuv_range);
         ppa_ll_blend_set_tx_rgb2yuv_std(platform->hal.dev, blend_trans_desc->out.yuv_std);
     }
@@ -201,7 +188,7 @@ esp_err_t ppa_do_blend(ppa_client_handle_t ppa_client, const ppa_blend_oper_conf
                             config->in_bg.block_h % 2 == 0 && config->in_bg.block_w % 2 == 0 &&
                             config->in_bg.block_offset_x % 2 == 0 && config->in_bg.block_offset_y % 2 == 0,
                             ESP_ERR_INVALID_ARG, TAG, "YUV420 input does not support odd h/w/offset_x/offset_y");
-    } else if (config->in_bg.blend_cm == PPA_BLEND_COLOR_MODE_YUV422) {
+    } else if (PPA_IS_CM_YUV422(config->in_bg.blend_cm)) {
         ESP_RETURN_ON_FALSE(config->in_bg.pic_w % 2 == 0 && config->in_bg.block_w % 2 == 0 && config->in_bg.block_offset_x % 2 == 0,
                             ESP_ERR_INVALID_ARG, TAG, "YUV422 input does not support odd w/offset_x");
     }
@@ -218,7 +205,7 @@ esp_err_t ppa_do_blend(ppa_client_handle_t ppa_client, const ppa_blend_oper_conf
         ESP_RETURN_ON_FALSE(config->out.pic_h % 2 == 0 && config->out.pic_w % 2 == 0 &&
                             config->out.block_offset_x % 2 == 0 && config->out.block_offset_y % 2 == 0,
                             ESP_ERR_INVALID_ARG, TAG, "YUV420 output does not support odd h/w/offset_x/offset_y");
-    } else if (config->out.blend_cm == PPA_BLEND_COLOR_MODE_YUV422) {
+    } else if (PPA_IS_CM_YUV422(config->out.blend_cm)) {
         ESP_RETURN_ON_FALSE(config->out.pic_w % 2 == 0 && config->out.block_offset_x % 2 == 0,
                             ESP_ERR_INVALID_ARG, TAG, "YUV422 output does not support odd w/offset_x");
     }
@@ -228,10 +215,7 @@ esp_err_t ppa_do_blend(ppa_client_handle_t ppa_client, const ppa_blend_oper_conf
     ESP_RETURN_ON_FALSE(config->in_fg.block_w <= (config->in_fg.pic_w - config->in_fg.block_offset_x) &&
                         config->in_fg.block_h <= (config->in_fg.pic_h - config->in_fg.block_offset_y),
                         ESP_ERR_INVALID_ARG, TAG, "in_fg.block_w/h + in_fg.block_offset_x/y does not fit in the in pic");
-    color_space_pixel_format_t out_pixel_format = {
-        .color_type_id = config->out.blend_cm,
-    };
-    uint32_t out_pixel_depth = color_hal_pixel_format_get_bit_depth(out_pixel_format); // bits
+    uint32_t out_pixel_depth = color_hal_pixel_format_fourcc_get_bit_depth((esp_color_fourcc_t)config->out.blend_cm); // bits
     uint32_t out_pic_len = config->out.pic_w * config->out.pic_h * out_pixel_depth / 8;
     ESP_RETURN_ON_FALSE(out_pic_len <= config->out.buffer_size, ESP_ERR_INVALID_ARG, TAG, "out.pic_w/h mismatch with out.buffer_size");
     ESP_RETURN_ON_FALSE(config->in_bg.block_w == config->in_fg.block_w && config->in_bg.block_h == config->in_fg.block_h,
@@ -271,21 +255,15 @@ esp_err_t ppa_do_blend(ppa_client_handle_t ppa_client, const ppa_blend_oper_conf
 
     // Write back and invalidate necessary data (note that the window content is not continuous in the buffer)
     // Write back in_bg_buffer, in_fg_buffer extended windows (alignment not necessary on C2M direction)
-    color_space_pixel_format_t in_bg_pixel_format = {
-        .color_type_id = config->in_bg.blend_cm,
-    };
-    uint32_t in_bg_pixel_depth = color_hal_pixel_format_get_bit_depth(in_bg_pixel_format); // bits
+    uint32_t in_bg_pixel_depth = color_hal_pixel_format_fourcc_get_bit_depth((esp_color_fourcc_t)config->in_bg.blend_cm); // bits
     // Usually C2M can let the msync do alignment internally, however, it only do L1-cacheline-size alignment for L1->L2, and then L2-cacheline-size alignment for L2->mem
     // While M2C direction manual alignment is L2-cacheline-size alignment for mem->L2->L1
     // Mismatching writeback and invalidate data size could cause synchronization error if in_bg/fg_buffer and out_buffer are the same one
     uint32_t in_bg_ext_window = (uint32_t)config->in_bg.buffer + config->in_bg.block_offset_y * config->in_bg.pic_w * in_bg_pixel_depth / 8;
     uint32_t in_bg_ext_window_aligned = PPA_ALIGN_DOWN(in_bg_ext_window, buf_alignment_size);
     uint32_t in_bg_ext_window_len = config->in_bg.pic_w * config->in_bg.block_h * in_bg_pixel_depth / 8;
     esp_cache_msync((void *)in_bg_ext_window_aligned, PPA_ALIGN_UP(in_bg_ext_window_len + (in_bg_ext_window - in_bg_ext_window_aligned), buf_alignment_size), ESP_CACHE_MSYNC_FLAG_DIR_C2M);
-    color_space_pixel_format_t in_fg_pixel_format = {
-        .color_type_id = config->in_fg.blend_cm,
-    };
-    uint32_t in_fg_pixel_depth = color_hal_pixel_format_get_bit_depth(in_fg_pixel_format); // bits
+    uint32_t in_fg_pixel_depth = color_hal_pixel_format_fourcc_get_bit_depth((esp_color_fourcc_t)config->in_fg.blend_cm); // bits
     uint32_t in_fg_ext_window = (uint32_t)config->in_fg.buffer + config->in_fg.block_offset_y * config->in_fg.pic_w * in_fg_pixel_depth / 8;
     // Same for fg_buffer msync, do manual alignment
     uint32_t in_fg_ext_window_aligned = PPA_ALIGN_DOWN(in_fg_ext_window, buf_alignment_size);

components/esp_driver_ppa/src/ppa_fill.c

@@ -32,10 +32,6 @@ bool ppa_fill_transaction_on_picked(uint32_t num_chans, const dma2d_trans_channe
     assert(dma2d_chans[0].dir == DMA2D_CHANNEL_DIRECTION_RX);
     dma2d_channel_handle_t dma2d_rx_chan = dma2d_chans[0].chan;
 
-    color_space_pixel_format_t out_pixel_format = {
-        .color_type_id = fill_trans_desc->out.fill_cm,
-    };
-
     // Fill 2D-DMA descriptors
     blend_engine->dma_rx_desc->vb_size = fill_trans_desc->fill_block_h;
     blend_engine->dma_rx_desc->hb_length = fill_trans_desc->fill_block_w;
@@ -45,7 +41,7 @@ bool ppa_fill_transaction_on_picked(uint32_t num_chans, const dma2d_trans_channe
     blend_engine->dma_rx_desc->owner = DMA2D_DESCRIPTOR_BUFFER_OWNER_DMA;
     blend_engine->dma_rx_desc->va_size = fill_trans_desc->out.pic_h;
     blend_engine->dma_rx_desc->ha_length = fill_trans_desc->out.pic_w;
-    blend_engine->dma_rx_desc->pbyte = dma2d_desc_pixel_format_to_pbyte_value(out_pixel_format);
+    blend_engine->dma_rx_desc->pbyte = dma2d_desc_pixel_format_to_pbyte_value((esp_color_fourcc_t)fill_trans_desc->out.fill_cm);
     blend_engine->dma_rx_desc->y = fill_trans_desc->out.block_offset_y;
     blend_engine->dma_rx_desc->x = fill_trans_desc->out.block_offset_x;
     blend_engine->dma_rx_desc->mode = DMA2D_DESCRIPTOR_BLOCK_RW_MODE_SINGLE;
@@ -104,14 +100,11 @@ esp_err_t ppa_do_fill(ppa_client_handle_t ppa_client, const ppa_fill_oper_config
     //                         config->out.block_offset_x % 2 == 0 && config->out.block_offset_y % 2 == 0,
     //                         ESP_ERR_INVALID_ARG, TAG, "YUV420 output does not support odd h/w/offset_x/offset_y");
     // } else
-    if (config->out.fill_cm == PPA_FILL_COLOR_MODE_YUV422) {
+    if (config->out.fill_cm == PPA_FILL_COLOR_MODE_YUV422_UYVY) {
         ESP_RETURN_ON_FALSE(config->out.pic_w % 2 == 0 && config->out.block_offset_x % 2 == 0,
                             ESP_ERR_INVALID_ARG, TAG, "YUV422 output does not support odd w/offset_x");
     }
-    color_space_pixel_format_t out_pixel_format = {
-        .color_type_id = config->out.fill_cm,
-    };
-    uint32_t out_pixel_depth = color_hal_pixel_format_get_bit_depth(out_pixel_format);
+    uint32_t out_pixel_depth = color_hal_pixel_format_fourcc_get_bit_depth((esp_color_fourcc_t)config->out.fill_cm);
     uint32_t out_pic_len = config->out.pic_w * config->out.pic_h * out_pixel_depth / 8;
     ESP_RETURN_ON_FALSE(out_pic_len <= config->out.buffer_size, ESP_ERR_INVALID_ARG, TAG, "out.pic_w/h mismatch with out.buffer_size");
     ESP_RETURN_ON_FALSE(config->fill_block_w <= (config->out.pic_w - config->out.block_offset_x) &&

components/esp_driver_ppa/src/ppa_priv.h

@@ -28,13 +28,23 @@ extern "C" {
 #define PPA_PM_LOCK_NAME_LEN_MAX 16
 
 #define PPA_CHECK_CM_SUPPORT_BYTE_SWAP(str, color_type_id) \
-            ESP_RETURN_ON_FALSE(color_type_id == COLOR_TYPE_ID(COLOR_SPACE_ARGB, COLOR_PIXEL_ARGB8888) || color_type_id == COLOR_TYPE_ID(COLOR_SPACE_RGB, COLOR_PIXEL_RGB565), \
+            ESP_RETURN_ON_FALSE((color_type_id == ESP_COLOR_FOURCC_BGRA32) || (color_type_id == ESP_COLOR_FOURCC_RGB16), \
                                 ESP_ERR_INVALID_ARG, TAG, str "_cm does not support byte_swap");
 
 #define PPA_CHECK_CM_SUPPORT_RGB_SWAP(str, color_type_id) \
-            ESP_RETURN_ON_FALSE(COLOR_SPACE_TYPE(color_type_id) == COLOR_SPACE_ARGB || COLOR_SPACE_TYPE(color_type_id) == COLOR_SPACE_RGB, \
+            ESP_RETURN_ON_FALSE((color_type_id == ESP_COLOR_FOURCC_BGRA32) || (color_type_id == ESP_COLOR_FOURCC_BGR24) || (color_type_id == ESP_COLOR_FOURCC_RGB16), \
                                 ESP_ERR_INVALID_ARG, TAG, str "_cm does not support rgb_swap");
 
+#define PPA_IS_CM_YUV422(color_type_id) \
+            (color_type_id == ESP_COLOR_FOURCC_UYVY || color_type_id == ESP_COLOR_FOURCC_VYUY || \
+             color_type_id == ESP_COLOR_FOURCC_YUYV || color_type_id == ESP_COLOR_FOURCC_YVYU)
+
+#define PPA_IS_CM_YUV(color_type_id) \
+            (color_type_id == ESP_COLOR_FOURCC_OUYY_EVYY || color_type_id == ESP_COLOR_FOURCC_YUV || PPA_IS_CM_YUV422(color_type_id))
+
+#define PPA_IS_CM_ALPHA(color_type_id) \
+            (color_type_id == ESP_COLOR_FOURCC_ALPHA8 || color_type_id == ESP_COLOR_FOURCC_ALPHA4)
+
 #define PPA_ALIGN_UP(num, align)    (((num) + ((align) - 1)) & ~((align) - 1))
 #define PPA_ALIGN_DOWN(num, align)  ((num) & ~((align) - 1))