diff options
Diffstat (limited to 'core/src/fxcodec/lbmp/fx_bmp.cpp')
| -rw-r--r-- | core/src/fxcodec/lbmp/fx_bmp.cpp | 917 |
1 files changed, 917 insertions, 0 deletions
diff --git a/core/src/fxcodec/lbmp/fx_bmp.cpp b/core/src/fxcodec/lbmp/fx_bmp.cpp new file mode 100644 index 0000000000..4c6eb61757 --- /dev/null +++ b/core/src/fxcodec/lbmp/fx_bmp.cpp @@ -0,0 +1,917 @@ +// Copyright 2014 PDFium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
+
+#include "fx_bmp.h"
+FX_DWORD _GetDWord_LSBFirst(FX_LPBYTE p)
+{
+ return p[0] | (p[1] << 8) | (p[2] << 16) | (p[3] << 24);
+}
+FX_WORD _GetWord_LSBFirst(FX_LPBYTE p)
+{
+ return p[0] | (p[1] << 8);
+}
+void _SetDWord_LSBFirst(FX_LPBYTE p, FX_DWORD v)
+{
+ p[0] = (FX_BYTE)v;
+ p[1] = (FX_BYTE)(v >> 8);
+ p[2] = (FX_BYTE)(v >> 16);
+ p[3] = (FX_BYTE)(v >> 24);
+}
+void _SetWord_LSBFirst(FX_LPBYTE p, FX_WORD v)
+{
+ p[0] = (FX_BYTE)v;
+ p[1] = (FX_BYTE)(v >> 8);
+}
+void _bmp_error(bmp_decompress_struct_p bmp_ptr, FX_LPCSTR err_msg)
+{
+ if(bmp_ptr != NULL && bmp_ptr->_bmp_error_fn != NULL) {
+ bmp_ptr->_bmp_error_fn(bmp_ptr, err_msg);
+ }
+}
+bmp_decompress_struct_p _bmp_create_decompress()
+{
+ bmp_decompress_struct_p bmp_ptr = FX_Alloc(bmp_decompress_struct, 1);
+ if(bmp_ptr == NULL) {
+ return NULL;
+ }
+ FXSYS_memset32(bmp_ptr, 0, sizeof(bmp_decompress_struct));
+ bmp_ptr->decode_status = BMP_D_STATUS_HEADER;
+ bmp_ptr->bmp_header_ptr = FX_Alloc(BmpFileHeader, 1);
+ return bmp_ptr;
+}
+void _bmp_destroy_decompress(bmp_decompress_struct_pp bmp_ptr_ptr)
+{
+ if(bmp_ptr_ptr == NULL || *bmp_ptr_ptr == NULL) {
+ return;
+ }
+ bmp_decompress_struct_p bmp_ptr = *bmp_ptr_ptr;
+ *bmp_ptr_ptr = NULL;
+ if(bmp_ptr->out_row_buffer != NULL) {
+ FX_Free(bmp_ptr->out_row_buffer);
+ }
+ if(bmp_ptr->pal_ptr != NULL) {
+ FX_Free(bmp_ptr->pal_ptr);
+ }
+ if(bmp_ptr->bmp_header_ptr != NULL) {
+ FX_Free(bmp_ptr->bmp_header_ptr);
+ }
+ FX_Free(bmp_ptr);
+}
+FX_INT32 _bmp_read_header(bmp_decompress_struct_p bmp_ptr)
+{
+ if(bmp_ptr == NULL) {
+ return 0;
+ }
+ FX_DWORD skip_size_org = bmp_ptr->skip_size;
+ if(bmp_ptr->decode_status == BMP_D_STATUS_HEADER) {
+ ASSERT(sizeof(BmpFileHeader) == 14);
+ BmpFileHeader* bmp_header_ptr = NULL;
+ if(_bmp_read_data(bmp_ptr, (FX_LPBYTE*)&bmp_header_ptr, 14) == NULL) {
+ return 2;
+ }
+ bmp_ptr->bmp_header_ptr->bfType = _GetWord_LSBFirst((FX_LPBYTE)&bmp_header_ptr->bfType);
+ bmp_ptr->bmp_header_ptr->bfOffBits = _GetDWord_LSBFirst((FX_LPBYTE)&bmp_header_ptr->bfOffBits);
+ bmp_ptr->data_size = _GetDWord_LSBFirst((FX_LPBYTE)&bmp_header_ptr->bfSize);
+ if(bmp_ptr->bmp_header_ptr->bfType != BMP_SIGNATURE) {
+ _bmp_error(bmp_ptr, "Not A Bmp Image");
+ return 0;
+ }
+ if(bmp_ptr->avail_in < sizeof(FX_DWORD)) {
+ bmp_ptr->skip_size = skip_size_org;
+ return 2;
+ }
+ bmp_ptr->img_ifh_size = _GetDWord_LSBFirst(bmp_ptr->next_in + bmp_ptr->skip_size);
+ bmp_ptr->pal_type = 0;
+ ASSERT(sizeof(BmpCoreHeader) == 12);
+ ASSERT(sizeof(BmpInfoHeader) == 40);
+ switch(bmp_ptr->img_ifh_size) {
+ case FX_MIN(12, sizeof(BmpCoreHeader)): {
+ bmp_ptr->pal_type = 1;
+ BmpCoreHeaderPtr bmp_core_header_ptr = NULL;
+ if(_bmp_read_data(bmp_ptr, (FX_LPBYTE*)&bmp_core_header_ptr, bmp_ptr->img_ifh_size) == NULL) {
+ bmp_ptr->skip_size = skip_size_org;
+ return 2;
+ }
+ bmp_ptr->width = (FX_DWORD)_GetWord_LSBFirst((FX_LPBYTE)&bmp_core_header_ptr->bcWidth);
+ bmp_ptr->height = (FX_DWORD)_GetWord_LSBFirst((FX_LPBYTE)&bmp_core_header_ptr->bcHeight);
+ bmp_ptr->bitCounts = _GetWord_LSBFirst((FX_LPBYTE)&bmp_core_header_ptr->bcBitCount);
+ bmp_ptr->compress_flag = BMP_RGB;
+ bmp_ptr->imgTB_flag = FALSE;
+ }
+ break;
+ case FX_MIN(40, sizeof(BmpInfoHeader)): {
+ BmpInfoHeaderPtr bmp_info_header_ptr = NULL;
+ if(_bmp_read_data(bmp_ptr, (FX_LPBYTE*)&bmp_info_header_ptr, bmp_ptr->img_ifh_size) == NULL) {
+ bmp_ptr->skip_size = skip_size_org;
+ return 2;
+ }
+ bmp_ptr->width = _GetDWord_LSBFirst((FX_LPBYTE)&bmp_info_header_ptr->biWidth);
+ bmp_ptr->height = _GetDWord_LSBFirst((FX_LPBYTE)&bmp_info_header_ptr->biHeight);
+ bmp_ptr->bitCounts = _GetWord_LSBFirst((FX_LPBYTE)&bmp_info_header_ptr->biBitCount);
+ bmp_ptr->compress_flag = _GetDWord_LSBFirst((FX_LPBYTE)&bmp_info_header_ptr->biCompression);
+ bmp_ptr->color_used = _GetDWord_LSBFirst((FX_LPBYTE)&bmp_info_header_ptr->biClrUsed);
+ bmp_ptr->dpi_x = (FX_INT32)_GetDWord_LSBFirst((FX_LPBYTE)&bmp_info_header_ptr->biXPelsPerMeter);
+ bmp_ptr->dpi_y = (FX_INT32)_GetDWord_LSBFirst((FX_LPBYTE)&bmp_info_header_ptr->biYPelsPerMeter);
+ if(bmp_ptr->height < 0) {
+ bmp_ptr->height = -bmp_ptr->height;
+ bmp_ptr->imgTB_flag = TRUE;
+ }
+ }
+ break;
+ default: {
+ if(bmp_ptr->img_ifh_size > FX_MIN(40, sizeof(BmpInfoHeader))) {
+ BmpInfoHeaderPtr bmp_info_header_ptr = NULL;
+ if(_bmp_read_data(bmp_ptr, (FX_LPBYTE*)&bmp_info_header_ptr, bmp_ptr->img_ifh_size) == NULL) {
+ bmp_ptr->skip_size = skip_size_org;
+ return 2;
+ }
+ FX_WORD biPlanes;
+ bmp_ptr->width = _GetDWord_LSBFirst((FX_LPBYTE)&bmp_info_header_ptr->biWidth);
+ bmp_ptr->height = _GetDWord_LSBFirst((FX_LPBYTE)&bmp_info_header_ptr->biHeight);
+ bmp_ptr->bitCounts = _GetWord_LSBFirst((FX_LPBYTE)&bmp_info_header_ptr->biBitCount);
+ bmp_ptr->compress_flag = _GetDWord_LSBFirst((FX_LPBYTE)&bmp_info_header_ptr->biCompression);
+ bmp_ptr->color_used = _GetDWord_LSBFirst((FX_LPBYTE)&bmp_info_header_ptr->biClrUsed);
+ biPlanes = _GetWord_LSBFirst((FX_LPBYTE)&bmp_info_header_ptr->biPlanes);
+ bmp_ptr->dpi_x = _GetDWord_LSBFirst((FX_LPBYTE)&bmp_info_header_ptr->biXPelsPerMeter);
+ bmp_ptr->dpi_y = _GetDWord_LSBFirst((FX_LPBYTE)&bmp_info_header_ptr->biYPelsPerMeter);
+ if(bmp_ptr->height < 0) {
+ bmp_ptr->height = -bmp_ptr->height;
+ bmp_ptr->imgTB_flag = TRUE;
+ }
+ if(bmp_ptr->compress_flag == BMP_RGB &&
+ biPlanes == 1 &&
+ bmp_ptr->color_used == 0) {
+ break;
+ }
+ }
+ _bmp_error(bmp_ptr, "Unsupported Bmp File");
+ return 0;
+ }
+ }
+ ASSERT(bmp_ptr->width > 0);
+ ASSERT(bmp_ptr->compress_flag <= BMP_BITFIELDS);
+ switch(bmp_ptr->bitCounts) {
+ case 1:
+ case 4:
+ case 8:
+ case 16:
+ case 24: {
+ if(bmp_ptr->color_used > ((FX_DWORD)1) << bmp_ptr->bitCounts) {
+ _bmp_error(bmp_ptr, "The Bmp File Is Corrupt");
+ return 0;
+ }
+ }
+ case 32: {
+ if(bmp_ptr->width <= 0 || bmp_ptr->compress_flag > BMP_BITFIELDS) {
+ _bmp_error(bmp_ptr, "The Bmp File Is Corrupt");
+ return 0;
+ }
+ }
+ break;
+ default:
+ _bmp_error(bmp_ptr, "The Bmp File Is Corrupt");
+ return 0;
+ }
+ bmp_ptr->src_row_bytes = BMP_WIDTHBYTES(bmp_ptr->width, bmp_ptr->bitCounts);
+ switch(bmp_ptr->bitCounts) {
+ case 1:
+ case 4:
+ case 8:
+ bmp_ptr->out_row_bytes = BMP_WIDTHBYTES(bmp_ptr->width, 8);
+ bmp_ptr->components = 1;
+ break;
+ case 16:
+ case 24:
+ bmp_ptr->out_row_bytes = BMP_WIDTHBYTES(bmp_ptr->width, 24);
+ bmp_ptr->components = 3;
+ break;
+ case 32:
+ bmp_ptr->out_row_bytes = bmp_ptr->src_row_bytes;
+ bmp_ptr->components = 4;
+ break;
+ }
+ if(bmp_ptr->out_row_buffer != NULL) {
+ FX_Free(bmp_ptr->out_row_buffer);
+ bmp_ptr->out_row_buffer = NULL;
+ }
+ bmp_ptr->out_row_buffer = FX_Alloc(FX_BYTE, bmp_ptr->out_row_bytes);
+ BMP_PTR_NOT_NULL(bmp_ptr->out_row_buffer, bmp_ptr);
+ FXSYS_memset32(bmp_ptr->out_row_buffer, 0, bmp_ptr->out_row_bytes);
+ _bmp_save_decoding_status(bmp_ptr, BMP_D_STATUS_PAL);
+ }
+ if (bmp_ptr->decode_status == BMP_D_STATUS_PAL) {
+ skip_size_org = bmp_ptr->skip_size;
+#ifdef BMP_SUPPORT_BITFIELD
+ if(bmp_ptr->compress_flag == BMP_BITFIELDS) {
+ if(bmp_ptr->bitCounts != 16 && bmp_ptr->bitCounts != 32) {
+ _bmp_error(bmp_ptr, "The Bmp File Is Corrupt");
+ return 0;
+ }
+ FX_DWORD* mask;
+ if(_bmp_read_data(bmp_ptr, (FX_LPBYTE*)&mask, 3 * sizeof(FX_DWORD)) == NULL) {
+ bmp_ptr->skip_size = skip_size_org;
+ return 2;
+ }
+ bmp_ptr->mask_red = _GetDWord_LSBFirst((FX_LPBYTE)&mask[0]);
+ bmp_ptr->mask_green = _GetDWord_LSBFirst((FX_LPBYTE)&mask[1]);
+ bmp_ptr->mask_blue = _GetDWord_LSBFirst((FX_LPBYTE)&mask[2]);
+ if(bmp_ptr->mask_red & bmp_ptr->mask_green ||
+ bmp_ptr->mask_red & bmp_ptr->mask_blue ||
+ bmp_ptr->mask_green & bmp_ptr->mask_blue) {
+ _bmp_error(bmp_ptr, "The Bitfield Bmp File Is Corrupt");
+ return 0;
+ }
+ if(bmp_ptr->bmp_header_ptr->bfOffBits < 26 + bmp_ptr->img_ifh_size) {
+ bmp_ptr->bmp_header_ptr->bfOffBits = 26 + bmp_ptr->img_ifh_size;
+ }
+ _bmp_save_decoding_status(bmp_ptr, BMP_D_STATUS_DATA_PRE);
+ return 1;
+ } else if(bmp_ptr->bitCounts == 16) {
+ bmp_ptr->mask_red = 0x7C00;
+ bmp_ptr->mask_green = 0x03E0;
+ bmp_ptr->mask_blue = 0x001F;
+ }
+#else
+ if(bmp_ptr->compress_flag == BMP_BITFIELDS || bmp_ptr->bitCounts == 16) {
+ _bmp_error(bmp_ptr, "Unsupported Bitfield Bmp File");
+ return 0;
+ }
+#endif
+ bmp_ptr->pal_num = 0;
+ if(bmp_ptr->bitCounts < 16) {
+ bmp_ptr->pal_num = 1 << bmp_ptr->bitCounts;
+ if(bmp_ptr->color_used != 0) {
+ bmp_ptr->pal_num = bmp_ptr->color_used;
+ }
+ FX_LPBYTE src_pal_ptr = NULL;
+ FX_DWORD src_pal_size = bmp_ptr->pal_num * (bmp_ptr->pal_type ? 3 : 4);
+ if(_bmp_read_data(bmp_ptr, (FX_LPBYTE*)&src_pal_ptr, src_pal_size) == NULL) {
+ bmp_ptr->skip_size = skip_size_org;
+ return 2;
+ }
+ if(bmp_ptr->pal_ptr != NULL) {
+ FX_Free(bmp_ptr->pal_ptr);
+ bmp_ptr->pal_ptr = NULL;
+ }
+ bmp_ptr->pal_ptr = FX_Alloc(FX_DWORD, bmp_ptr->pal_num);
+ BMP_PTR_NOT_NULL(bmp_ptr->pal_ptr, bmp_ptr);
+ FX_INT32 src_pal_index = 0;
+ if(bmp_ptr->pal_type == BMP_PAL_OLD) {
+ while(src_pal_index < bmp_ptr->pal_num) {
+ bmp_ptr->pal_ptr[src_pal_index++] = BMP_PAL_ENCODE(0x00, src_pal_ptr[2], src_pal_ptr[1], src_pal_ptr[0]);
+ src_pal_ptr += 3;
+ }
+ } else {
+ while(src_pal_index < bmp_ptr->pal_num) {
+ bmp_ptr->pal_ptr[src_pal_index++] = BMP_PAL_ENCODE(src_pal_ptr[3], src_pal_ptr[2], src_pal_ptr[1], src_pal_ptr[0]);
+ src_pal_ptr += 4;
+ }
+ }
+ }
+ if(bmp_ptr->bmp_header_ptr->bfOffBits < 14 + bmp_ptr->img_ifh_size + bmp_ptr->pal_num * (bmp_ptr->pal_type ? 3 : 4)) {
+ bmp_ptr->bmp_header_ptr->bfOffBits = 14 + bmp_ptr->img_ifh_size + bmp_ptr->pal_num * (bmp_ptr->pal_type ? 3 : 4);
+ }
+ _bmp_save_decoding_status(bmp_ptr, BMP_D_STATUS_DATA_PRE);
+ }
+ return 1;
+}
+FX_INT32 _bmp_decode_image(bmp_decompress_struct_p bmp_ptr)
+{
+ if(bmp_ptr->decode_status == BMP_D_STATUS_DATA_PRE) {
+ bmp_ptr->avail_in = 0;
+ if(!bmp_ptr->_bmp_get_data_position_fn(bmp_ptr, bmp_ptr->bmp_header_ptr->bfOffBits)) {
+ bmp_ptr->decode_status = BMP_D_STATUS_TAIL;
+ _bmp_error(bmp_ptr, "The Bmp File Is Corrupt, Unexpected Stream Offset");
+ return 0;
+ }
+ bmp_ptr->row_num = 0;
+ _bmp_save_decoding_status(bmp_ptr, BMP_D_STATUS_DATA);
+ }
+ if(bmp_ptr->decode_status == BMP_D_STATUS_DATA) {
+ switch(bmp_ptr->compress_flag) {
+ case BMP_RGB:
+ case BMP_BITFIELDS:
+ return _bmp_decode_rgb(bmp_ptr);
+ case BMP_RLE8:
+ return _bmp_decode_rle8(bmp_ptr);
+ case BMP_RLE4:
+ return _bmp_decode_rle4(bmp_ptr);
+ }
+ }
+ _bmp_error(bmp_ptr, "Any Uncontrol Error");
+ return 0;
+}
+FX_INT32 _bmp_decode_rgb(bmp_decompress_struct_p bmp_ptr)
+{
+ FX_LPBYTE row_buf = bmp_ptr->out_row_buffer;
+ FX_LPBYTE des_buf = NULL;
+ while (bmp_ptr->row_num < bmp_ptr->height) {
+ if(_bmp_read_data(bmp_ptr, &des_buf, bmp_ptr->src_row_bytes) == NULL) {
+ return 2;
+ }
+ _bmp_save_decoding_status(bmp_ptr, BMP_D_STATUS_DATA);
+ switch(bmp_ptr->bitCounts) {
+ case 1: {
+ for (FX_INT32 col = 0; col < bmp_ptr->width; col++) {
+ *row_buf++ = des_buf[col >> 3] & (0x80 >> (col % 8)) ? 0x01 : 0x00;
+ }
+ }
+ break;
+ case 4: {
+ for (FX_INT32 col = 0; col < bmp_ptr->width; col++) {
+ *row_buf++ = (col & 0x01) ?
+ (des_buf[col >> 1] & 0x0F) :
+ ((des_buf[col >> 1] & 0xF0) >> 4);
+ }
+ }
+ break;
+#ifdef BMP_SUPPORT_BITFIELD
+ case 16: {
+ FX_WORD* buf = (FX_WORD*)des_buf;
+ FX_BYTE blue_bits = 0;
+ FX_BYTE green_bits = 0;
+ FX_BYTE red_bits = 0;
+ for(FX_INT32 i = 0; i < 16; i++) {
+ if((bmp_ptr->mask_blue >> i) & 0x01) {
+ blue_bits++;
+ }
+ if((bmp_ptr->mask_green >> i) & 0x01) {
+ green_bits++;
+ }
+ if((bmp_ptr->mask_red >> i) & 0x01) {
+ red_bits++;
+ }
+ }
+ green_bits += blue_bits;
+ red_bits += green_bits;
+ blue_bits = 8 - blue_bits;
+ green_bits -= 8;
+ red_bits -= 8;
+ for (FX_INT32 col = 0; col < bmp_ptr->width; col++) {
+ *buf = _GetWord_LSBFirst((FX_LPBYTE)buf);
+ *row_buf++ = (FX_BYTE)((*buf & bmp_ptr->mask_blue) << blue_bits);
+ *row_buf++ = (FX_BYTE)((*buf & bmp_ptr->mask_green) >> green_bits);
+ *row_buf++ = (FX_BYTE)((*buf++ & bmp_ptr->mask_red) >> red_bits);
+ }
+ }
+ break;
+#endif
+ case 8:
+ case 24:
+ case 32:
+ FXSYS_memcpy32(bmp_ptr->out_row_buffer, des_buf, bmp_ptr->src_row_bytes);
+ break;
+ }
+ row_buf = bmp_ptr->out_row_buffer;
+ bmp_ptr->_bmp_get_row_fn(bmp_ptr,
+ bmp_ptr->imgTB_flag ? bmp_ptr->row_num++ : (bmp_ptr->height - 1 - bmp_ptr->row_num++),
+ bmp_ptr->out_row_buffer);
+ }
+ _bmp_save_decoding_status(bmp_ptr, BMP_D_STATUS_TAIL);
+ return 1;
+}
+FX_INT32 _bmp_decode_rle8(bmp_decompress_struct_p bmp_ptr)
+{
+ FX_LPBYTE first_byte_ptr = NULL;
+ FX_LPBYTE second_byte_ptr = NULL;
+ bmp_ptr->col_num = 0;
+ while(TRUE) {
+ FX_DWORD skip_size_org = bmp_ptr->skip_size;
+ if(_bmp_read_data(bmp_ptr, &first_byte_ptr, 1) == NULL) {
+ return 2;
+ }
+ switch(*first_byte_ptr) {
+ case RLE_MARKER: {
+ if(_bmp_read_data(bmp_ptr, &first_byte_ptr, 1) == NULL) {
+ bmp_ptr->skip_size = skip_size_org;
+ return 2;
+ }
+ switch(*first_byte_ptr) {
+ case RLE_EOL: {
+ if(bmp_ptr->row_num >= bmp_ptr->height) {
+ _bmp_save_decoding_status(bmp_ptr, BMP_D_STATUS_TAIL);
+ _bmp_error(bmp_ptr, "The Bmp File Is Corrupt");
+ return 0;
+ }
+ bmp_ptr->_bmp_get_row_fn(bmp_ptr,
+ bmp_ptr->imgTB_flag ? bmp_ptr->row_num++ : (bmp_ptr->height - 1 - bmp_ptr->row_num++),
+ bmp_ptr->out_row_buffer);
+ bmp_ptr->col_num = 0;
+ FXSYS_memset32(bmp_ptr->out_row_buffer, 0, bmp_ptr->out_row_bytes);
+ _bmp_save_decoding_status(bmp_ptr, BMP_D_STATUS_DATA);
+ continue;
+ }
+ case RLE_EOI: {
+ if(bmp_ptr->row_num < bmp_ptr->height) {
+ bmp_ptr->_bmp_get_row_fn(bmp_ptr,
+ bmp_ptr->imgTB_flag ? bmp_ptr->row_num++ : (bmp_ptr->height - 1 - bmp_ptr->row_num++),
+ bmp_ptr->out_row_buffer);
+ }
+ _bmp_save_decoding_status(bmp_ptr, BMP_D_STATUS_TAIL);
+ return 1;
+ }
+ case RLE_DELTA: {
+ FX_LPBYTE delta_ptr;
+ if(_bmp_read_data(bmp_ptr, &delta_ptr, 2) == NULL) {
+ bmp_ptr->skip_size = skip_size_org;
+ return 2;
+ }
+ bmp_ptr->col_num += (FX_INT32)delta_ptr[0];
+ FX_INT32 bmp_row_num_next = bmp_ptr->row_num + (FX_INT32)delta_ptr[1];
+ if(bmp_ptr->col_num >= bmp_ptr->out_row_bytes || bmp_row_num_next >= bmp_ptr->height) {
+ _bmp_error(bmp_ptr, "The Bmp File Is Corrupt Or Not Supported");
+ return 0;
+ }
+ while(bmp_ptr->row_num < bmp_row_num_next) {
+ FXSYS_memset32(bmp_ptr->out_row_buffer, 0, bmp_ptr->out_row_bytes);
+ bmp_ptr->_bmp_get_row_fn(bmp_ptr,
+ bmp_ptr->imgTB_flag ? bmp_ptr->row_num++ : (bmp_ptr->height - 1 - bmp_ptr->row_num++),
+ bmp_ptr->out_row_buffer);
+ }
+ }
+ break;
+ default: {
+ if((FX_INT32)(*first_byte_ptr) > bmp_ptr->src_row_bytes - bmp_ptr->col_num) {
+ _bmp_error(bmp_ptr, "The Bmp File Is Corrupt");
+ return 0;
+ }
+ if(_bmp_read_data(bmp_ptr, &second_byte_ptr,
+ *first_byte_ptr & 1 ? *first_byte_ptr + 1 : *first_byte_ptr) == NULL) {
+ bmp_ptr->skip_size = skip_size_org;
+ return 2;
+ }
+ FXSYS_memcpy32(bmp_ptr->out_row_buffer + bmp_ptr->col_num, second_byte_ptr, *first_byte_ptr);
+ bmp_ptr->col_num += (FX_INT32)(*first_byte_ptr);
+ }
+ }
+ }
+ break;
+ default: {
+ if(_bmp_read_data(bmp_ptr, &second_byte_ptr, 1) == NULL) {
+ bmp_ptr->skip_size = skip_size_org;
+ return 2;
+ }
+ if((FX_INT32)(*first_byte_ptr) > bmp_ptr->src_row_bytes - bmp_ptr->col_num) {
+ _bmp_error(bmp_ptr, "The Bmp File Is Corrupt");
+ return 0;
+ }
+ FXSYS_memset8(bmp_ptr->out_row_buffer + bmp_ptr->col_num, *second_byte_ptr, *first_byte_ptr);
+ bmp_ptr->col_num += (FX_INT32)(*first_byte_ptr);
+ }
+ }
+ }
+ _bmp_error(bmp_ptr, "Any Uncontrol Error");
+ return 0;
+}
+FX_INT32 _bmp_decode_rle4(bmp_decompress_struct_p bmp_ptr)
+{
+ FX_LPBYTE first_byte_ptr = NULL;
+ FX_LPBYTE second_byte_ptr = NULL;
+ bmp_ptr->col_num = 0;
+ while (TRUE) {
+ FX_DWORD skip_size_org = bmp_ptr->skip_size;
+ if(_bmp_read_data(bmp_ptr, &first_byte_ptr, 1) == NULL) {
+ return 2;
+ }
+ switch(*first_byte_ptr) {
+ case RLE_MARKER: {
+ if(_bmp_read_data(bmp_ptr, &first_byte_ptr, 1) == NULL) {
+ bmp_ptr->skip_size = skip_size_org;
+ return 2;
+ }
+ switch(*first_byte_ptr) {
+ case RLE_EOL: {
+ if(bmp_ptr->row_num >= bmp_ptr->height) {
+ _bmp_save_decoding_status(bmp_ptr, BMP_D_STATUS_TAIL);
+ _bmp_error(bmp_ptr, "The Bmp File Is Corrupt");
+ return 0;
+ }
+ bmp_ptr->_bmp_get_row_fn(bmp_ptr,
+ bmp_ptr->imgTB_flag ? bmp_ptr->row_num++ : (bmp_ptr->height - 1 - bmp_ptr->row_num++),
+ bmp_ptr->out_row_buffer);
+ bmp_ptr->col_num = 0;
+ FXSYS_memset32(bmp_ptr->out_row_buffer, 0, bmp_ptr->out_row_bytes);
+ _bmp_save_decoding_status(bmp_ptr, BMP_D_STATUS_DATA);
+ continue;
+ }
+ case RLE_EOI: {
+ if(bmp_ptr->row_num < bmp_ptr->height) {
+ bmp_ptr->_bmp_get_row_fn(bmp_ptr,
+ bmp_ptr->imgTB_flag ? bmp_ptr->row_num++ : (bmp_ptr->height - 1 - bmp_ptr->row_num++),
+ bmp_ptr->out_row_buffer);
+ }
+ _bmp_save_decoding_status(bmp_ptr, BMP_D_STATUS_TAIL);
+ return 1;
+ }
+ case RLE_DELTA: {
+ FX_LPBYTE delta_ptr;
+ if(_bmp_read_data(bmp_ptr, &delta_ptr, 2) == NULL) {
+ bmp_ptr->skip_size = skip_size_org;
+ return 2;
+ }
+ bmp_ptr->col_num += (FX_INT32)delta_ptr[0];
+ FX_INT32 bmp_row_num_next = bmp_ptr->row_num + (FX_INT32)delta_ptr[1];
+ if(bmp_ptr->col_num >= bmp_ptr->out_row_bytes || bmp_row_num_next >= bmp_ptr->height) {
+ _bmp_error(bmp_ptr, "The Bmp File Is Corrupt Or Not Supported");
+ return 0;
+ }
+ while(bmp_ptr->row_num < bmp_row_num_next) {
+ FXSYS_memset32(bmp_ptr->out_row_buffer, 0, bmp_ptr->out_row_bytes);
+ bmp_ptr->_bmp_get_row_fn(bmp_ptr,
+ bmp_ptr->imgTB_flag ? bmp_ptr->row_num++ : (bmp_ptr->height - 1 - bmp_ptr->row_num++),
+ bmp_ptr->out_row_buffer);
+ }
+ }
+ break;
+ default: {
+ FX_BYTE size = (FX_BYTE)(((FX_WORD)(*first_byte_ptr) + 1) >> 1);
+ if((FX_INT32)*first_byte_ptr >= bmp_ptr->out_row_bytes - bmp_ptr->col_num) {
+ if(size + (bmp_ptr->col_num >> 1) > bmp_ptr->src_row_bytes) {
+ _bmp_error(bmp_ptr, "The Bmp File Is Corrupt");
+ return 0;
+ }
+ *first_byte_ptr = bmp_ptr->out_row_bytes - bmp_ptr->col_num - 1;
+ }
+ if(_bmp_read_data(bmp_ptr, &second_byte_ptr, size & 1 ? size + 1 : size) == NULL) {
+ bmp_ptr->skip_size = skip_size_org;
+ return 2;
+ }
+ for (FX_BYTE i = 0; i < *first_byte_ptr; i++) {
+ if(i & 0x01) {
+ *(bmp_ptr->out_row_buffer + bmp_ptr->col_num++) = (*second_byte_ptr++ & 0x0F);
+ } else {
+ *(bmp_ptr->out_row_buffer + bmp_ptr->col_num++) = ((*second_byte_ptr & 0xF0) >> 4);
+ }
+ }
+ }
+ }
+ }
+ break;
+ default: {
+ if(_bmp_read_data(bmp_ptr, &second_byte_ptr, 1) == NULL) {
+ bmp_ptr->skip_size = skip_size_org;
+ return 2;
+ }
+ if((FX_INT32)*first_byte_ptr > bmp_ptr->out_row_bytes - bmp_ptr->col_num) {
+ FX_BYTE size = (FX_BYTE)(((FX_WORD)(*first_byte_ptr) + 1) >> 1);
+ if(size + (bmp_ptr->col_num >> 1) > bmp_ptr->src_row_bytes) {
+ _bmp_error(bmp_ptr, "The Bmp File Is Corrupt");
+ return 0;
+ }
+ *first_byte_ptr = bmp_ptr->out_row_bytes - bmp_ptr->col_num - 1;
+ }
+ for (FX_BYTE i = 0; i < *first_byte_ptr; i++) {
+ if(i & 0x01) {
+ *(bmp_ptr->out_row_buffer + bmp_ptr->col_num++) = (*second_byte_ptr & 0x0F);
+ } else {
+ *(bmp_ptr->out_row_buffer + bmp_ptr->col_num++) = ((*second_byte_ptr & 0xF0) >> 4);
+ }
+ }
+ }
+ }
+ }
+ _bmp_error(bmp_ptr, "Any Uncontrol Error");
+ return 0;
+}
+FX_LPBYTE _bmp_read_data(bmp_decompress_struct_p bmp_ptr, FX_LPBYTE* des_buf_pp, FX_DWORD data_size)
+{
+ if(bmp_ptr == NULL ||
+ bmp_ptr->avail_in < bmp_ptr->skip_size + data_size) {
+ return NULL;
+ }
+ *des_buf_pp = bmp_ptr->next_in + bmp_ptr->skip_size;
+ bmp_ptr->skip_size += data_size;
+ return *des_buf_pp;
+}
+void _bmp_save_decoding_status(bmp_decompress_struct_p bmp_ptr, FX_INT32 status)
+{
+ bmp_ptr->decode_status = status;
+ bmp_ptr->next_in += bmp_ptr->skip_size;
+ bmp_ptr->avail_in -= bmp_ptr->skip_size;
+ bmp_ptr->skip_size = 0;
+}
+void _bmp_input_buffer(bmp_decompress_struct_p bmp_ptr, FX_LPBYTE src_buf, FX_DWORD src_size)
+{
+ bmp_ptr->next_in = src_buf;
+ bmp_ptr->avail_in = src_size;
+ bmp_ptr->skip_size = 0;
+}
+FX_DWORD _bmp_get_avail_input(bmp_decompress_struct_p bmp_ptr, FX_LPBYTE* avial_buf_ptr)
+{
+ if(avial_buf_ptr != NULL) {
+ *avial_buf_ptr = NULL;
+ if(bmp_ptr->avail_in > 0) {
+ *avial_buf_ptr = bmp_ptr->next_in;
+ }
+ }
+ return bmp_ptr->avail_in;
+}
+bmp_compress_struct_p _bmp_create_compress()
+{
+ bmp_compress_struct_p bmp_ptr;
+ bmp_ptr = FX_Alloc(bmp_compress_struct, 1);
+ if (bmp_ptr) {
+ FXSYS_memset32(bmp_ptr, 0, sizeof(bmp_compress_struct));
+ }
+ return bmp_ptr;
+}
+void _bmp_destroy_compress(bmp_compress_struct_p bmp_ptr)
+{
+ if (bmp_ptr) {
+ if (bmp_ptr->src_free && bmp_ptr->src_buf) {
+ FX_Free(bmp_ptr->src_buf);
+ }
+ FX_Free(bmp_ptr);
+ }
+}
+static void WriteFileHeader(BmpFileHeaderPtr head_ptr, FX_LPBYTE dst_buf)
+{
+ FX_DWORD offset;
+ offset = 0;
+ _SetWord_LSBFirst(&dst_buf[offset], head_ptr->bfType);
+ offset += 2;
+ _SetDWord_LSBFirst(&dst_buf[offset], head_ptr->bfSize);
+ offset += 4;
+ _SetWord_LSBFirst(&dst_buf[offset], head_ptr->bfReserved1);
+ offset += 2;
+ _SetWord_LSBFirst(&dst_buf[offset], head_ptr->bfReserved2);
+ offset += 2;
+ _SetDWord_LSBFirst(&dst_buf[offset], head_ptr->bfOffBits);
+ offset += 4;
+}
+static void WriteInfoHeader(BmpInfoHeaderPtr info_head_ptr, FX_LPBYTE dst_buf)
+{
+ FX_DWORD offset;
+ offset = sizeof(BmpFileHeader);
+ _SetDWord_LSBFirst(&dst_buf[offset], info_head_ptr->biSize);
+ offset += 4;
+ _SetDWord_LSBFirst(&dst_buf[offset], (FX_DWORD)info_head_ptr->biWidth);
+ offset += 4;
+ _SetDWord_LSBFirst(&dst_buf[offset], (FX_DWORD)info_head_ptr->biHeight);
+ offset += 4;
+ _SetWord_LSBFirst(&dst_buf[offset], info_head_ptr->biPlanes);
+ offset += 2;
+ _SetWord_LSBFirst(&dst_buf[offset], info_head_ptr->biBitCount);
+ offset += 2;
+ _SetDWord_LSBFirst(&dst_buf[offset], info_head_ptr->biCompression);
+ offset += 4;
+ _SetDWord_LSBFirst(&dst_buf[offset], info_head_ptr->biSizeImage);
+ offset += 4;
+ _SetDWord_LSBFirst(&dst_buf[offset], (FX_DWORD)info_head_ptr->biXPelsPerMeter);
+ offset += 4;
+ _SetDWord_LSBFirst(&dst_buf[offset], (FX_DWORD)info_head_ptr->biYPelsPerMeter);
+ offset += 4;
+ _SetDWord_LSBFirst(&dst_buf[offset], info_head_ptr->biClrUsed);
+ offset += 4;
+ _SetDWord_LSBFirst(&dst_buf[offset], info_head_ptr->biClrImportant);
+ offset += 4;
+}
+#ifdef BMP_SUPPORT_BITFIELD
+static void _bmp_encode_bitfields(bmp_compress_struct_p bmp_ptr, FX_LPBYTE& dst_buf, FX_DWORD& dst_size)
+{
+ if (bmp_ptr->info_header.biBitCount != 16 && bmp_ptr->info_header.biBitCount != 32) {
+ return;
+ }
+ FX_DWORD size, dst_pos, i;
+ size = bmp_ptr->src_pitch * bmp_ptr->src_row * bmp_ptr->info_header.biBitCount / 16;
+ dst_pos = bmp_ptr->file_header.bfOffBits;
+ dst_size += size;
+ dst_buf = FX_Realloc(FX_BYTE, dst_buf, dst_size);
+ if (dst_buf == NULL) {
+ return;
+ }
+ FXSYS_memset32(&dst_buf[dst_pos], 0, size);
+ FX_DWORD mask_red;
+ FX_DWORD mask_green;
+ FX_DWORD mask_blue;
+ mask_red = 0x7C00;
+ mask_green = 0x03E0;
+ mask_blue = 0x001F;
+ if (bmp_ptr->info_header.biCompression == BMP_BITFIELDS) {
+ if (bmp_ptr->bit_type == BMP_BIT_565) {
+ mask_red = 0xF800;
+ mask_green = 0x07E0;
+ mask_blue = 0x001F;
+ }
+ if (bmp_ptr->info_header.biBitCount == 32) {
+ mask_red = 0xFF0000;
+ mask_green = 0x00FF00;
+ mask_blue = 0x0000FF;
+ }
+ _SetDWord_LSBFirst(&dst_buf[dst_pos], mask_red);
+ dst_pos += 4;
+ _SetDWord_LSBFirst(&dst_buf[dst_pos], mask_green);
+ dst_pos += 4;
+ _SetDWord_LSBFirst(&dst_buf[dst_pos], mask_blue);
+ dst_pos += 4;
+ bmp_ptr->file_header.bfOffBits = dst_pos;
+ }
+ FX_BYTE blue_bits = 0;
+ FX_BYTE green_bits = 0;
+ FX_BYTE red_bits = 0;
+ for(i = 0; i < bmp_ptr->info_header.biBitCount; i++) {
+ if((mask_blue >> i) & 0x01) {
+ blue_bits++;
+ }
+ if((mask_green >> i) & 0x01) {
+ green_bits++;
+ }
+ if((mask_red >> i) & 0x01) {
+ red_bits++;
+ }
+ }
+ green_bits += blue_bits;
+ red_bits += green_bits;
+ blue_bits = 8 - blue_bits;
+ green_bits -= 8;
+ red_bits -= 8;
+ i = 0;
+ for (FX_INT32 row_num = bmp_ptr->src_row - 1; row_num > -1; row_num--, i = 0) {
+ while (i < bmp_ptr->src_width * bmp_ptr->src_bpp / 8) {
+ FX_BYTE b = bmp_ptr->src_buf[row_num * bmp_ptr->src_pitch + i++];
+ FX_BYTE g = bmp_ptr->src_buf[row_num * bmp_ptr->src_pitch + i++];
+ FX_BYTE r = bmp_ptr->src_buf[row_num * bmp_ptr->src_pitch + i++];
+ if (bmp_ptr->src_bpp == 32) {
+ i++;
+ }
+ FX_DWORD pix_val = 0;
+ pix_val |= (b >> blue_bits) & mask_blue;
+ pix_val |= (g << green_bits) & mask_green;
+ pix_val |= (r << red_bits) & mask_red;
+ if (bmp_ptr->info_header.biBitCount == 16) {
+ _SetWord_LSBFirst(&dst_buf[dst_pos], (FX_WORD)pix_val);
+ dst_pos += 2;
+ } else {
+ _SetDWord_LSBFirst(&dst_buf[dst_pos], pix_val);
+ dst_pos += 4;
+ }
+ }
+ }
+ dst_size = dst_pos;
+}
+#endif
+static void _bmp_encode_rgb(bmp_compress_struct_p bmp_ptr, FX_LPBYTE& dst_buf, FX_DWORD& dst_size)
+{
+ if (bmp_ptr->info_header.biBitCount == 16) {
+#ifdef BMP_SUPPORT_BITFIELD
+ _bmp_encode_bitfields(bmp_ptr, dst_buf, dst_size);
+#endif
+ return;
+ }
+ FX_DWORD size, dst_pos;
+ FX_DWORD dst_pitch = (bmp_ptr->src_width * bmp_ptr->info_header.biBitCount + 31) / 32 * 4;
+ size = dst_pitch * bmp_ptr->src_row;
+ dst_pos = bmp_ptr->file_header.bfOffBits;
+ dst_size += size;
+ dst_buf = FX_Realloc(FX_BYTE, dst_buf, dst_size);
+ if (dst_buf == NULL) {
+ return;
+ }
+ FXSYS_memset32(&dst_buf[dst_pos], 0, size);
+ for (FX_INT32 row_num = bmp_ptr->src_row - 1; row_num > -1; row_num--) {
+ FXSYS_memcpy32(&dst_buf[dst_pos], &bmp_ptr->src_buf[row_num * bmp_ptr->src_pitch], bmp_ptr->src_pitch);
+ dst_pos += dst_pitch;
+ }
+ dst_size = dst_pos;
+}
+static FX_BYTE _bmp_rle8_search(FX_LPCBYTE buf, FX_INT32 len)
+{
+ FX_BYTE num;
+ num = 1;
+ while (num < len) {
+ if (buf[num - 1] != buf[num] || num == 0xFF) {
+ break;
+ }
+ num++;
+ }
+ return num;
+}
+static void _bmp_encode_rle8(bmp_compress_struct_p bmp_ptr, FX_LPBYTE& dst_buf, FX_DWORD& dst_size)
+{
+ FX_DWORD size, dst_pos, index;
+ FX_BYTE rle[2] = {0};
+ size = bmp_ptr->src_pitch * bmp_ptr->src_row * 2;
+ dst_pos = bmp_ptr->file_header.bfOffBits;
+ dst_size += size;
+ dst_buf = FX_Realloc(FX_BYTE, dst_buf, dst_size);
+ if (dst_buf == NULL) {
+ return;
+ }
+ FXSYS_memset32(&dst_buf[dst_pos], 0, size);
+ for (FX_INT32 row_num = bmp_ptr->src_row - 1, i = 0; row_num > -1; ) {
+ index = row_num * bmp_ptr->src_pitch;
+ rle[0] = _bmp_rle8_search(&bmp_ptr->src_buf[index + i], size - index - i);
+ rle[1] = bmp_ptr->src_buf[index + i];
+ if (i + rle[0] >= (FX_INT32)bmp_ptr->src_pitch) {
+ rle[0] = FX_BYTE(bmp_ptr->src_pitch - i);
+ if (rle[0]) {
+ dst_buf[dst_pos++] = rle[0];
+ dst_buf[dst_pos++] = rle[1];
+ }
+ dst_buf[dst_pos++] = RLE_MARKER;
+ dst_buf[dst_pos++] = RLE_EOL;
+ i = 0;
+ row_num--;
+ } else {
+ i += rle[0];
+ dst_buf[dst_pos++] = rle[0];
+ dst_buf[dst_pos++] = rle[1];
+ }
+ }
+ dst_buf[dst_pos++] = RLE_MARKER;
+ dst_buf[dst_pos++] = RLE_EOI;
+ dst_size = dst_pos;
+}
+static FX_BYTE _bmp_rle4_search(FX_LPCBYTE buf, FX_INT32 len)
+{
+ FX_BYTE num;
+ num = 2;
+ while (num < len) {
+ if (buf[num - 2] != buf[num] || num == 0xFF) {
+ break;
+ }
+ num++;
+ }
+ return num;
+}
+static void _bmp_encode_rle4(bmp_compress_struct_p bmp_ptr, FX_LPBYTE& dst_buf, FX_DWORD& dst_size)
+{
+ FX_DWORD size, dst_pos, index;
+ FX_BYTE rle[2] = {0};
+ size = bmp_ptr->src_pitch * bmp_ptr->src_row;
+ dst_pos = bmp_ptr->file_header.bfOffBits;
+ dst_size += size;
+ dst_buf = FX_Realloc(FX_BYTE, dst_buf, dst_size);
+ if (dst_buf == NULL) {
+ return;
+ }
+ FXSYS_memset32(&dst_buf[dst_pos], 0, size);
+ for (FX_INT32 row_num = bmp_ptr->src_row - 1, i = 0; row_num > -1; rle[1] = 0) {
+ index = row_num * bmp_ptr->src_pitch;
+ rle[0] = _bmp_rle4_search(&bmp_ptr->src_buf[index + i], size - index - i);
+ rle[1] |= (bmp_ptr->src_buf[index + i] & 0x0f) << 4;
+ rle[1] |= bmp_ptr->src_buf[index + i + 1] & 0x0f;
+ if (i + rle[0] >= (FX_INT32)bmp_ptr->src_pitch) {
+ rle[0] = FX_BYTE(bmp_ptr->src_pitch - i);
+ if (rle[0]) {
+ dst_buf[dst_pos++] = rle[0];
+ dst_buf[dst_pos++] = rle[1];
+ }
+ dst_buf[dst_pos++] = RLE_MARKER;
+ dst_buf[dst_pos++] = RLE_EOL;
+ i = 0;
+ row_num--;
+ } else {
+ i += rle[0];
+ dst_buf[dst_pos++] = rle[0];
+ dst_buf[dst_pos++] = rle[1];
+ }
+ }
+ dst_buf[dst_pos++] = RLE_MARKER;
+ dst_buf[dst_pos++] = RLE_EOI;
+ dst_size = dst_pos;
+}
+FX_BOOL _bmp_encode_image( bmp_compress_struct_p bmp_ptr, FX_LPBYTE& dst_buf, FX_DWORD& dst_size )
+{
+ FX_DWORD head_size = sizeof(BmpFileHeader) + sizeof(BmpInfoHeader);
+ FX_DWORD pal_size = sizeof(FX_DWORD) * bmp_ptr->pal_num;
+ if (bmp_ptr->info_header.biClrUsed > 0 && bmp_ptr->info_header.biClrUsed < bmp_ptr->pal_num) {
+ pal_size = sizeof(FX_DWORD) * bmp_ptr->info_header.biClrUsed;
+ }
+ dst_size = head_size + sizeof(FX_DWORD) * bmp_ptr->pal_num;
+ dst_buf = FX_AllocNL(FX_BYTE, dst_size);
+ if (dst_buf == NULL) {
+ return FALSE;
+ }
+ FXSYS_memset32(dst_buf, 0, dst_size);
+ bmp_ptr->file_header.bfOffBits = head_size;
+ if (bmp_ptr->pal_ptr && pal_size) {
+ FXSYS_memcpy32(&dst_buf[head_size], bmp_ptr->pal_ptr, pal_size);
+ bmp_ptr->file_header.bfOffBits += pal_size;
+ }
+ WriteInfoHeader(&bmp_ptr->info_header, dst_buf);
+ switch(bmp_ptr->info_header.biCompression) {
+ case BMP_RGB:
+ _bmp_encode_rgb(bmp_ptr, dst_buf, dst_size);
+ break;
+ case BMP_BITFIELDS:
+#ifdef BMP_SUPPORT_BITFIELD
+ _bmp_encode_bitfields(bmp_ptr, dst_buf, dst_size);
+#endif
+ break;
+ case BMP_RLE8:
+ _bmp_encode_rle8(bmp_ptr, dst_buf, dst_size);
+ break;
+ case BMP_RLE4:
+ _bmp_encode_rle4(bmp_ptr, dst_buf, dst_size);
+ break;
+ default:
+ ;
+ }
+ bmp_ptr->file_header.bfSize = dst_size;
+ WriteFileHeader(&bmp_ptr->file_header, dst_buf);
+ return TRUE;
+}
|