summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--core/src/fxcodec/codec/fx_codec_bmp.cpp40
-rw-r--r--core/src/fxcodec/codec/fx_codec_gif.cpp80
-rw-r--r--core/src/fxcodec/lbmp/fx_bmp.cpp364
-rw-r--r--core/src/fxcodec/lbmp/fx_bmp.h63
-rw-r--r--core/src/fxcodec/lgif/fx_gif.cpp480
-rw-r--r--core/src/fxcodec/lgif/fx_gif.h110
-rw-r--r--core/src/fxge/dib/fx_dib_convert.cpp397
-rw-r--r--fpdfsdk/src/fsdk_baseannot.cpp4
8 files changed, 682 insertions, 856 deletions
diff --git a/core/src/fxcodec/codec/fx_codec_bmp.cpp b/core/src/fxcodec/codec/fx_codec_bmp.cpp
index 042392c0d1..41a881d3ae 100644
--- a/core/src/fxcodec/codec/fx_codec_bmp.cpp
+++ b/core/src/fxcodec/codec/fx_codec_bmp.cpp
@@ -17,27 +17,27 @@ struct FXBMP_Context {
void (*m_FreeFunc)(void*);
};
extern "C" {
-static void* _bmp_alloc_func(unsigned int size) {
+static void* bmp_alloc_func(unsigned int size) {
return FX_Alloc(char, size);
}
-static void _bmp_free_func(void* p) {
+static void bmp_free_func(void* p) {
FX_Free(p);
}
};
-static void _bmp_error_data(bmp_decompress_struct_p bmp_ptr,
- const FX_CHAR* err_msg) {
+static void bmp_error_data(bmp_decompress_struct_p bmp_ptr,
+ const FX_CHAR* err_msg) {
FXSYS_strncpy((char*)bmp_ptr->err_ptr, err_msg, BMP_MAX_ERROR_SIZE - 1);
longjmp(bmp_ptr->jmpbuf, 1);
}
-static void _bmp_read_scanline(bmp_decompress_struct_p bmp_ptr,
- int32_t row_num,
- uint8_t* row_buf) {
+static void bmp_read_scanline(bmp_decompress_struct_p bmp_ptr,
+ int32_t row_num,
+ uint8_t* row_buf) {
FXBMP_Context* p = (FXBMP_Context*)bmp_ptr->context_ptr;
CCodec_BmpModule* pModule = (CCodec_BmpModule*)p->parent_ptr;
pModule->ReadScanlineCallback(p->child_ptr, row_num, row_buf);
}
-static FX_BOOL _bmp_get_data_position(bmp_decompress_struct_p bmp_ptr,
- FX_DWORD rcd_pos) {
+static FX_BOOL bmp_get_data_position(bmp_decompress_struct_p bmp_ptr,
+ FX_DWORD rcd_pos) {
FXBMP_Context* p = (FXBMP_Context*)bmp_ptr->context_ptr;
CCodec_BmpModule* pModule = (CCodec_BmpModule*)p->parent_ptr;
return pModule->InputImagePositionBufCallback(p->child_ptr, rcd_pos);
@@ -51,27 +51,27 @@ void* CCodec_BmpModule::Start(void* pModule) {
if (p == NULL) {
return NULL;
}
- p->m_AllocFunc = _bmp_alloc_func;
- p->m_FreeFunc = _bmp_free_func;
+ p->m_AllocFunc = bmp_alloc_func;
+ p->m_FreeFunc = bmp_free_func;
p->bmp_ptr = NULL;
p->parent_ptr = (void*)this;
p->child_ptr = pModule;
- p->bmp_ptr = _bmp_create_decompress();
+ p->bmp_ptr = bmp_create_decompress();
if (p->bmp_ptr == NULL) {
FX_Free(p);
return NULL;
}
p->bmp_ptr->context_ptr = (void*)p;
p->bmp_ptr->err_ptr = m_szLastError;
- p->bmp_ptr->_bmp_error_fn = _bmp_error_data;
- p->bmp_ptr->_bmp_get_row_fn = _bmp_read_scanline;
- p->bmp_ptr->_bmp_get_data_position_fn = _bmp_get_data_position;
+ p->bmp_ptr->bmp_error_fn = bmp_error_data;
+ p->bmp_ptr->bmp_get_row_fn = bmp_read_scanline;
+ p->bmp_ptr->bmp_get_data_position_fn = bmp_get_data_position;
return p;
}
void CCodec_BmpModule::Finish(void* pContext) {
FXBMP_Context* p = (FXBMP_Context*)pContext;
if (p) {
- _bmp_destroy_decompress(&p->bmp_ptr);
+ bmp_destroy_decompress(&p->bmp_ptr);
p->m_FreeFunc(p);
}
}
@@ -87,7 +87,7 @@ int32_t CCodec_BmpModule::ReadHeader(void* pContext,
if (setjmp(p->bmp_ptr->jmpbuf)) {
return 0;
}
- int32_t ret = _bmp_read_header(p->bmp_ptr);
+ int32_t ret = bmp_read_header(p->bmp_ptr);
if (ret != 1) {
return ret;
}
@@ -110,16 +110,16 @@ int32_t CCodec_BmpModule::LoadImage(void* pContext) {
if (setjmp(p->bmp_ptr->jmpbuf)) {
return 0;
}
- return _bmp_decode_image(p->bmp_ptr);
+ return bmp_decode_image(p->bmp_ptr);
}
FX_DWORD CCodec_BmpModule::GetAvailInput(void* pContext,
uint8_t** avial_buf_ptr) {
FXBMP_Context* p = (FXBMP_Context*)pContext;
- return _bmp_get_avail_input(p->bmp_ptr, avial_buf_ptr);
+ return bmp_get_avail_input(p->bmp_ptr, avial_buf_ptr);
}
void CCodec_BmpModule::Input(void* pContext,
const uint8_t* src_buf,
FX_DWORD src_size) {
FXBMP_Context* p = (FXBMP_Context*)pContext;
- _bmp_input_buffer(p->bmp_ptr, (uint8_t*)src_buf, src_size);
+ bmp_input_buffer(p->bmp_ptr, (uint8_t*)src_buf, src_size);
}
diff --git a/core/src/fxcodec/codec/fx_codec_gif.cpp b/core/src/fxcodec/codec/fx_codec_gif.cpp
index af0c32ea9d..661732fb3f 100644
--- a/core/src/fxcodec/codec/fx_codec_gif.cpp
+++ b/core/src/fxcodec/codec/fx_codec_gif.cpp
@@ -17,51 +17,51 @@ struct FXGIF_Context {
void (*m_FreeFunc)(void*);
};
extern "C" {
-static void* _gif_alloc_func(unsigned int size) {
+static void* gif_alloc_func(unsigned int size) {
return FX_Alloc(char, size);
}
-static void _gif_free_func(void* p) {
+static void gif_free_func(void* p) {
FX_Free(p);
}
};
-static void _gif_error_data(gif_decompress_struct_p gif_ptr,
- const FX_CHAR* err_msg) {
+static void gif_error_data(gif_decompress_struct_p gif_ptr,
+ const FX_CHAR* err_msg) {
FXSYS_strncpy((char*)gif_ptr->err_ptr, err_msg, GIF_MAX_ERROR_SIZE - 1);
longjmp(gif_ptr->jmpbuf, 1);
}
-static uint8_t* _gif_ask_buf_for_pal(gif_decompress_struct_p gif_ptr,
- int32_t pal_size) {
+static uint8_t* gif_ask_buf_for_pal(gif_decompress_struct_p gif_ptr,
+ int32_t pal_size) {
FXGIF_Context* p = (FXGIF_Context*)gif_ptr->context_ptr;
CCodec_GifModule* pModule = (CCodec_GifModule*)p->parent_ptr;
return pModule->AskLocalPaletteBufCallback(
- p->child_ptr, _gif_get_frame_num(gif_ptr), pal_size);
+ p->child_ptr, gif_get_frame_num(gif_ptr), pal_size);
}
-static void _gif_record_current_position(gif_decompress_struct_p gif_ptr,
- FX_DWORD* cur_pos_ptr) {
+static void gif_record_current_position(gif_decompress_struct_p gif_ptr,
+ FX_DWORD* cur_pos_ptr) {
FXGIF_Context* p = (FXGIF_Context*)gif_ptr->context_ptr;
CCodec_GifModule* pModule = (CCodec_GifModule*)p->parent_ptr;
pModule->RecordCurrentPositionCallback(p->child_ptr, *cur_pos_ptr);
}
-static void _gif_read_scanline(gif_decompress_struct_p gif_ptr,
- int32_t row_num,
- uint8_t* row_buf) {
+static void gif_read_scanline(gif_decompress_struct_p gif_ptr,
+ int32_t row_num,
+ uint8_t* row_buf) {
FXGIF_Context* p = (FXGIF_Context*)gif_ptr->context_ptr;
CCodec_GifModule* pModule = (CCodec_GifModule*)p->parent_ptr;
pModule->ReadScanlineCallback(p->child_ptr, row_num, row_buf);
}
-static FX_BOOL _gif_get_record_position(gif_decompress_struct_p gif_ptr,
- FX_DWORD cur_pos,
- int32_t left,
- int32_t top,
- int32_t width,
- int32_t height,
- int32_t pal_num,
- void* pal_ptr,
- int32_t delay_time,
- FX_BOOL user_input,
- int32_t trans_index,
- int32_t disposal_method,
- FX_BOOL interlace) {
+static FX_BOOL gif_get_record_position(gif_decompress_struct_p gif_ptr,
+ FX_DWORD cur_pos,
+ int32_t left,
+ int32_t top,
+ int32_t width,
+ int32_t height,
+ int32_t pal_num,
+ void* pal_ptr,
+ int32_t delay_time,
+ FX_BOOL user_input,
+ int32_t trans_index,
+ int32_t disposal_method,
+ FX_BOOL interlace) {
FXGIF_Context* p = (FXGIF_Context*)gif_ptr->context_ptr;
CCodec_GifModule* pModule = (CCodec_GifModule*)p->parent_ptr;
return pModule->InputRecordPositionBufCallback(
@@ -75,29 +75,29 @@ void* CCodec_GifModule::Start(void* pModule) {
return NULL;
}
FXSYS_memset(p, 0, sizeof(FXGIF_Context));
- p->m_AllocFunc = _gif_alloc_func;
- p->m_FreeFunc = _gif_free_func;
+ p->m_AllocFunc = gif_alloc_func;
+ p->m_FreeFunc = gif_free_func;
p->gif_ptr = NULL;
p->parent_ptr = (void*)this;
p->child_ptr = pModule;
- p->gif_ptr = _gif_create_decompress();
+ p->gif_ptr = gif_create_decompress();
if (p->gif_ptr == NULL) {
FX_Free(p);
return NULL;
}
p->gif_ptr->context_ptr = (void*)p;
p->gif_ptr->err_ptr = m_szLastError;
- p->gif_ptr->_gif_error_fn = _gif_error_data;
- p->gif_ptr->_gif_ask_buf_for_pal_fn = _gif_ask_buf_for_pal;
- p->gif_ptr->_gif_record_current_position_fn = _gif_record_current_position;
- p->gif_ptr->_gif_get_row_fn = _gif_read_scanline;
- p->gif_ptr->_gif_get_record_position_fn = _gif_get_record_position;
+ p->gif_ptr->gif_error_fn = gif_error_data;
+ p->gif_ptr->gif_ask_buf_for_pal_fn = gif_ask_buf_for_pal;
+ p->gif_ptr->gif_record_current_position_fn = gif_record_current_position;
+ p->gif_ptr->gif_get_row_fn = gif_read_scanline;
+ p->gif_ptr->gif_get_record_position_fn = gif_get_record_position;
return p;
}
void CCodec_GifModule::Finish(void* pContext) {
FXGIF_Context* p = (FXGIF_Context*)pContext;
if (p) {
- _gif_destroy_decompress(&p->gif_ptr);
+ gif_destroy_decompress(&p->gif_ptr);
p->m_FreeFunc(p);
}
}
@@ -112,7 +112,7 @@ int32_t CCodec_GifModule::ReadHeader(void* pContext,
if (setjmp(p->gif_ptr->jmpbuf)) {
return 0;
}
- int32_t ret = _gif_read_header(p->gif_ptr);
+ int32_t ret = gif_read_header(p->gif_ptr);
if (ret != 1) {
return ret;
}
@@ -130,11 +130,11 @@ int32_t CCodec_GifModule::LoadFrameInfo(void* pContext, int* frame_num) {
if (setjmp(p->gif_ptr->jmpbuf)) {
return 0;
}
- int32_t ret = _gif_get_frame(p->gif_ptr);
+ int32_t ret = gif_get_frame(p->gif_ptr);
if (ret != 1) {
return ret;
}
- *frame_num = _gif_get_frame_num(p->gif_ptr);
+ *frame_num = gif_get_frame_num(p->gif_ptr);
return 1;
}
int32_t CCodec_GifModule::LoadFrame(void* pContext,
@@ -144,7 +144,7 @@ int32_t CCodec_GifModule::LoadFrame(void* pContext,
if (setjmp(p->gif_ptr->jmpbuf)) {
return 0;
}
- int32_t ret = _gif_load_frame(p->gif_ptr, frame_num);
+ int32_t ret = gif_load_frame(p->gif_ptr, frame_num);
if (ret == 1) {
if (pAttribute) {
pAttribute->m_nGifLeft =
@@ -177,11 +177,11 @@ int32_t CCodec_GifModule::LoadFrame(void* pContext,
FX_DWORD CCodec_GifModule::GetAvailInput(void* pContext,
uint8_t** avial_buf_ptr) {
FXGIF_Context* p = (FXGIF_Context*)pContext;
- return _gif_get_avail_input(p->gif_ptr, avial_buf_ptr);
+ return gif_get_avail_input(p->gif_ptr, avial_buf_ptr);
}
void CCodec_GifModule::Input(void* pContext,
const uint8_t* src_buf,
FX_DWORD src_size) {
FXGIF_Context* p = (FXGIF_Context*)pContext;
- _gif_input_buffer(p->gif_ptr, (uint8_t*)src_buf, src_size);
+ gif_input_buffer(p->gif_ptr, (uint8_t*)src_buf, src_size);
}
diff --git a/core/src/fxcodec/lbmp/fx_bmp.cpp b/core/src/fxcodec/lbmp/fx_bmp.cpp
index 2a0e227e46..07e83a1618 100644
--- a/core/src/fxcodec/lbmp/fx_bmp.cpp
+++ b/core/src/fxcodec/lbmp/fx_bmp.cpp
@@ -13,30 +13,32 @@ namespace {
const size_t kBmpCoreHeaderSize = 12;
const size_t kBmpInfoHeaderSize = 40;
-} // namespace
-
-FX_DWORD _GetDWord_LSBFirst(uint8_t* p) {
+// TODO(thestig): Replace with FXDWORD_GET_LSBFIRST?
+FX_DWORD GetDWord_LSBFirst(uint8_t* p) {
return p[0] | (p[1] << 8) | (p[2] << 16) | (p[3] << 24);
}
-FX_WORD _GetWord_LSBFirst(uint8_t* p) {
- return p[0] | (p[1] << 8);
-}
-void _SetDWord_LSBFirst(uint8_t* p, FX_DWORD v) {
+
+void SetDWord_LSBFirst(uint8_t* p, FX_DWORD v) {
p[0] = (uint8_t)v;
p[1] = (uint8_t)(v >> 8);
p[2] = (uint8_t)(v >> 16);
p[3] = (uint8_t)(v >> 24);
}
-void _SetWord_LSBFirst(uint8_t* p, FX_WORD v) {
+} // namespace
+
+FX_WORD GetWord_LSBFirst(uint8_t* p) {
+ return p[0] | (p[1] << 8);
+}
+void SetWord_LSBFirst(uint8_t* p, FX_WORD v) {
p[0] = (uint8_t)v;
p[1] = (uint8_t)(v >> 8);
}
-void _bmp_error(bmp_decompress_struct_p bmp_ptr, const FX_CHAR* err_msg) {
- if (bmp_ptr && bmp_ptr->_bmp_error_fn) {
- bmp_ptr->_bmp_error_fn(bmp_ptr, err_msg);
+void bmp_error(bmp_decompress_struct_p bmp_ptr, const FX_CHAR* err_msg) {
+ if (bmp_ptr && bmp_ptr->bmp_error_fn) {
+ bmp_ptr->bmp_error_fn(bmp_ptr, err_msg);
}
}
-bmp_decompress_struct_p _bmp_create_decompress() {
+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;
@@ -46,7 +48,7 @@ bmp_decompress_struct_p _bmp_create_decompress() {
bmp_ptr->bmp_header_ptr = FX_Alloc(BmpFileHeader, 1);
return bmp_ptr;
}
-void _bmp_destroy_decompress(bmp_decompress_struct_pp bmp_ptr_ptr) {
+void bmp_destroy_decompress(bmp_decompress_struct_pp bmp_ptr_ptr) {
if (bmp_ptr_ptr == NULL || *bmp_ptr_ptr == NULL) {
return;
}
@@ -59,7 +61,7 @@ void _bmp_destroy_decompress(bmp_decompress_struct_pp bmp_ptr_ptr) {
FX_Free(bmp_ptr->bmp_header_ptr);
FX_Free(bmp_ptr);
}
-int32_t _bmp_read_header(bmp_decompress_struct_p bmp_ptr) {
+int32_t bmp_read_header(bmp_decompress_struct_p bmp_ptr) {
if (bmp_ptr == NULL) {
return 0;
}
@@ -67,16 +69,16 @@ int32_t _bmp_read_header(bmp_decompress_struct_p bmp_ptr) {
if (bmp_ptr->decode_status == BMP_D_STATUS_HEADER) {
ASSERT(sizeof(BmpFileHeader) == 14);
BmpFileHeader* bmp_header_ptr = NULL;
- if (_bmp_read_data(bmp_ptr, (uint8_t**)&bmp_header_ptr, 14) == NULL) {
+ if (bmp_read_data(bmp_ptr, (uint8_t**)&bmp_header_ptr, 14) == NULL) {
return 2;
}
bmp_ptr->bmp_header_ptr->bfType =
- _GetWord_LSBFirst((uint8_t*)&bmp_header_ptr->bfType);
+ GetWord_LSBFirst((uint8_t*)&bmp_header_ptr->bfType);
bmp_ptr->bmp_header_ptr->bfOffBits =
- _GetDWord_LSBFirst((uint8_t*)&bmp_header_ptr->bfOffBits);
- bmp_ptr->data_size = _GetDWord_LSBFirst((uint8_t*)&bmp_header_ptr->bfSize);
+ GetDWord_LSBFirst((uint8_t*)&bmp_header_ptr->bfOffBits);
+ bmp_ptr->data_size = GetDWord_LSBFirst((uint8_t*)&bmp_header_ptr->bfSize);
if (bmp_ptr->bmp_header_ptr->bfType != BMP_SIGNATURE) {
- _bmp_error(bmp_ptr, "Not A Bmp Image");
+ bmp_error(bmp_ptr, "Not A Bmp Image");
return 0;
}
if (bmp_ptr->avail_in < sizeof(FX_DWORD)) {
@@ -84,7 +86,7 @@ int32_t _bmp_read_header(bmp_decompress_struct_p bmp_ptr) {
return 2;
}
bmp_ptr->img_ifh_size =
- _GetDWord_LSBFirst(bmp_ptr->next_in + bmp_ptr->skip_size);
+ GetDWord_LSBFirst(bmp_ptr->next_in + bmp_ptr->skip_size);
bmp_ptr->pal_type = 0;
static_assert(sizeof(BmpCoreHeader) == kBmpCoreHeaderSize,
"BmpCoreHeader has wrong size");
@@ -94,40 +96,40 @@ int32_t _bmp_read_header(bmp_decompress_struct_p bmp_ptr) {
case kBmpCoreHeaderSize: {
bmp_ptr->pal_type = 1;
BmpCoreHeaderPtr bmp_core_header_ptr = NULL;
- if (_bmp_read_data(bmp_ptr, (uint8_t**)&bmp_core_header_ptr,
- bmp_ptr->img_ifh_size) == NULL) {
+ if (bmp_read_data(bmp_ptr, (uint8_t**)&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(
- (uint8_t*)&bmp_core_header_ptr->bcWidth);
- bmp_ptr->height = (FX_DWORD)_GetWord_LSBFirst(
- (uint8_t*)&bmp_core_header_ptr->bcHeight);
+ bmp_ptr->width =
+ GetWord_LSBFirst((uint8_t*)&bmp_core_header_ptr->bcWidth);
+ bmp_ptr->height =
+ GetWord_LSBFirst((uint8_t*)&bmp_core_header_ptr->bcHeight);
bmp_ptr->bitCounts =
- _GetWord_LSBFirst((uint8_t*)&bmp_core_header_ptr->bcBitCount);
+ GetWord_LSBFirst((uint8_t*)&bmp_core_header_ptr->bcBitCount);
bmp_ptr->compress_flag = BMP_RGB;
bmp_ptr->imgTB_flag = FALSE;
} break;
case kBmpInfoHeaderSize: {
BmpInfoHeaderPtr bmp_info_header_ptr = NULL;
- if (_bmp_read_data(bmp_ptr, (uint8_t**)&bmp_info_header_ptr,
- bmp_ptr->img_ifh_size) == NULL) {
+ if (bmp_read_data(bmp_ptr, (uint8_t**)&bmp_info_header_ptr,
+ bmp_ptr->img_ifh_size) == NULL) {
bmp_ptr->skip_size = skip_size_org;
return 2;
}
bmp_ptr->width =
- _GetDWord_LSBFirst((uint8_t*)&bmp_info_header_ptr->biWidth);
+ GetDWord_LSBFirst((uint8_t*)&bmp_info_header_ptr->biWidth);
bmp_ptr->height =
- _GetDWord_LSBFirst((uint8_t*)&bmp_info_header_ptr->biHeight);
+ GetDWord_LSBFirst((uint8_t*)&bmp_info_header_ptr->biHeight);
bmp_ptr->bitCounts =
- _GetWord_LSBFirst((uint8_t*)&bmp_info_header_ptr->biBitCount);
+ GetWord_LSBFirst((uint8_t*)&bmp_info_header_ptr->biBitCount);
bmp_ptr->compress_flag =
- _GetDWord_LSBFirst((uint8_t*)&bmp_info_header_ptr->biCompression);
+ GetDWord_LSBFirst((uint8_t*)&bmp_info_header_ptr->biCompression);
bmp_ptr->color_used =
- _GetDWord_LSBFirst((uint8_t*)&bmp_info_header_ptr->biClrUsed);
- bmp_ptr->dpi_x = (int32_t)_GetDWord_LSBFirst(
+ GetDWord_LSBFirst((uint8_t*)&bmp_info_header_ptr->biClrUsed);
+ bmp_ptr->dpi_x = (int32_t)GetDWord_LSBFirst(
(uint8_t*)&bmp_info_header_ptr->biXPelsPerMeter);
- bmp_ptr->dpi_y = (int32_t)_GetDWord_LSBFirst(
+ bmp_ptr->dpi_y = (int32_t)GetDWord_LSBFirst(
(uint8_t*)&bmp_info_header_ptr->biYPelsPerMeter);
if (bmp_ptr->height < 0) {
bmp_ptr->height = -bmp_ptr->height;
@@ -138,27 +140,26 @@ int32_t _bmp_read_header(bmp_decompress_struct_p bmp_ptr) {
if (bmp_ptr->img_ifh_size >
std::min(kBmpInfoHeaderSize, sizeof(BmpInfoHeader))) {
BmpInfoHeaderPtr bmp_info_header_ptr = NULL;
- if (_bmp_read_data(bmp_ptr, (uint8_t**)&bmp_info_header_ptr,
- bmp_ptr->img_ifh_size) == NULL) {
+ if (bmp_read_data(bmp_ptr, (uint8_t**)&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((uint8_t*)&bmp_info_header_ptr->biWidth);
+ GetDWord_LSBFirst((uint8_t*)&bmp_info_header_ptr->biWidth);
bmp_ptr->height =
- _GetDWord_LSBFirst((uint8_t*)&bmp_info_header_ptr->biHeight);
+ GetDWord_LSBFirst((uint8_t*)&bmp_info_header_ptr->biHeight);
bmp_ptr->bitCounts =
- _GetWord_LSBFirst((uint8_t*)&bmp_info_header_ptr->biBitCount);
+ GetWord_LSBFirst((uint8_t*)&bmp_info_header_ptr->biBitCount);
bmp_ptr->compress_flag =
- _GetDWord_LSBFirst((uint8_t*)&bmp_info_header_ptr->biCompression);
+ GetDWord_LSBFirst((uint8_t*)&bmp_info_header_ptr->biCompression);
bmp_ptr->color_used =
- _GetDWord_LSBFirst((uint8_t*)&bmp_info_header_ptr->biClrUsed);
- biPlanes =
- _GetWord_LSBFirst((uint8_t*)&bmp_info_header_ptr->biPlanes);
- bmp_ptr->dpi_x = _GetDWord_LSBFirst(
+ GetDWord_LSBFirst((uint8_t*)&bmp_info_header_ptr->biClrUsed);
+ biPlanes = GetWord_LSBFirst((uint8_t*)&bmp_info_header_ptr->biPlanes);
+ bmp_ptr->dpi_x = GetDWord_LSBFirst(
(uint8_t*)&bmp_info_header_ptr->biXPelsPerMeter);
- bmp_ptr->dpi_y = _GetDWord_LSBFirst(
+ bmp_ptr->dpi_y = GetDWord_LSBFirst(
(uint8_t*)&bmp_info_header_ptr->biYPelsPerMeter);
if (bmp_ptr->height < 0) {
bmp_ptr->height = -bmp_ptr->height;
@@ -169,7 +170,7 @@ int32_t _bmp_read_header(bmp_decompress_struct_p bmp_ptr) {
break;
}
}
- _bmp_error(bmp_ptr, "Unsupported Bmp File");
+ bmp_error(bmp_ptr, "Unsupported Bmp File");
return 0;
}
}
@@ -182,18 +183,18 @@ int32_t _bmp_read_header(bmp_decompress_struct_p bmp_ptr) {
case 16:
case 24: {
if (bmp_ptr->color_used > ((FX_DWORD)1) << bmp_ptr->bitCounts) {
- _bmp_error(bmp_ptr, "The Bmp File Is Corrupt");
+ 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");
+ bmp_error(bmp_ptr, "The Bmp File Is Corrupt");
return 0;
}
} break;
default:
- _bmp_error(bmp_ptr, "The Bmp File Is Corrupt");
+ bmp_error(bmp_ptr, "The Bmp File Is Corrupt");
return 0;
}
bmp_ptr->src_row_bytes = BMP_WIDTHBYTES(bmp_ptr->width, bmp_ptr->bitCounts);
@@ -217,47 +218,40 @@ int32_t _bmp_read_header(bmp_decompress_struct_p bmp_ptr) {
FX_Free(bmp_ptr->out_row_buffer);
bmp_ptr->out_row_buffer = FX_Alloc(uint8_t, bmp_ptr->out_row_bytes);
FXSYS_memset(bmp_ptr->out_row_buffer, 0, bmp_ptr->out_row_bytes);
- _bmp_save_decoding_status(bmp_ptr, BMP_D_STATUS_PAL);
+ 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");
+ bmp_error(bmp_ptr, "The Bmp File Is Corrupt");
return 0;
}
FX_DWORD* mask;
- if (_bmp_read_data(bmp_ptr, (uint8_t**)&mask, 3 * sizeof(FX_DWORD)) ==
+ if (bmp_read_data(bmp_ptr, (uint8_t**)&mask, 3 * sizeof(FX_DWORD)) ==
NULL) {
bmp_ptr->skip_size = skip_size_org;
return 2;
}
- bmp_ptr->mask_red = _GetDWord_LSBFirst((uint8_t*)&mask[0]);
- bmp_ptr->mask_green = _GetDWord_LSBFirst((uint8_t*)&mask[1]);
- bmp_ptr->mask_blue = _GetDWord_LSBFirst((uint8_t*)&mask[2]);
+ bmp_ptr->mask_red = GetDWord_LSBFirst((uint8_t*)&mask[0]);
+ bmp_ptr->mask_green = GetDWord_LSBFirst((uint8_t*)&mask[1]);
+ bmp_ptr->mask_blue = GetDWord_LSBFirst((uint8_t*)&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");
+ 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);
+ 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;
@@ -266,7 +260,7 @@ int32_t _bmp_read_header(bmp_decompress_struct_p bmp_ptr) {
}
uint8_t* 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, (uint8_t**)&src_pal_ptr, src_pal_size) ==
+ if (bmp_read_data(bmp_ptr, (uint8_t**)&src_pal_ptr, src_pal_size) ==
NULL) {
bmp_ptr->skip_size = skip_size_org;
return 2;
@@ -295,44 +289,44 @@ int32_t _bmp_read_header(bmp_decompress_struct_p bmp_ptr) {
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);
+ bmp_save_decoding_status(bmp_ptr, BMP_D_STATUS_DATA_PRE);
}
return 1;
}
-int32_t _bmp_decode_image(bmp_decompress_struct_p bmp_ptr) {
+int32_t 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(
+ 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");
+ 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);
+ 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);
+ return bmp_decode_rgb(bmp_ptr);
case BMP_RLE8:
- return _bmp_decode_rle8(bmp_ptr);
+ return bmp_decode_rle8(bmp_ptr);
case BMP_RLE4:
- return _bmp_decode_rle4(bmp_ptr);
+ return bmp_decode_rle4(bmp_ptr);
}
}
- _bmp_error(bmp_ptr, "Any Uncontrol Error");
+ bmp_error(bmp_ptr, "Any Uncontrol Error");
return 0;
}
-int32_t _bmp_decode_rgb(bmp_decompress_struct_p bmp_ptr) {
+int32_t bmp_decode_rgb(bmp_decompress_struct_p bmp_ptr) {
uint8_t* row_buf = bmp_ptr->out_row_buffer;
uint8_t* 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) {
+ 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);
+ bmp_save_decoding_status(bmp_ptr, BMP_D_STATUS_DATA);
switch (bmp_ptr->bitCounts) {
case 1: {
for (int32_t col = 0; col < bmp_ptr->width; col++) {
@@ -345,7 +339,6 @@ int32_t _bmp_decode_rgb(bmp_decompress_struct_p bmp_ptr) {
: ((des_buf[col >> 1] & 0xF0) >> 4);
}
} break;
-#ifdef BMP_SUPPORT_BITFIELD
case 16: {
FX_WORD* buf = (FX_WORD*)des_buf;
uint8_t blue_bits = 0;
@@ -368,13 +361,12 @@ int32_t _bmp_decode_rgb(bmp_decompress_struct_p bmp_ptr) {
green_bits -= 8;
red_bits -= 8;
for (int32_t col = 0; col < bmp_ptr->width; col++) {
- *buf = _GetWord_LSBFirst((uint8_t*)buf);
+ *buf = GetWord_LSBFirst((uint8_t*)buf);
*row_buf++ = (uint8_t)((*buf & bmp_ptr->mask_blue) << blue_bits);
*row_buf++ = (uint8_t)((*buf & bmp_ptr->mask_green) >> green_bits);
*row_buf++ = (uint8_t)((*buf++ & bmp_ptr->mask_red) >> red_bits);
}
} break;
-#endif
case 8:
case 24:
case 32:
@@ -382,61 +374,61 @@ int32_t _bmp_decode_rgb(bmp_decompress_struct_p bmp_ptr) {
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_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);
+ bmp_save_decoding_status(bmp_ptr, BMP_D_STATUS_TAIL);
return 1;
}
-int32_t _bmp_decode_rle8(bmp_decompress_struct_p bmp_ptr) {
+int32_t bmp_decode_rle8(bmp_decompress_struct_p bmp_ptr) {
uint8_t* first_byte_ptr = NULL;
uint8_t* 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) {
+ 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) {
+ 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");
+ 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_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_memset(bmp_ptr->out_row_buffer, 0, bmp_ptr->out_row_bytes);
- _bmp_save_decoding_status(bmp_ptr, BMP_D_STATUS_DATA);
+ 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_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);
+ bmp_save_decoding_status(bmp_ptr, BMP_D_STATUS_TAIL);
return 1;
}
case RLE_DELTA: {
uint8_t* delta_ptr;
- if (_bmp_read_data(bmp_ptr, &delta_ptr, 2) == NULL) {
+ if (bmp_read_data(bmp_ptr, &delta_ptr, 2) == NULL) {
bmp_ptr->skip_size = skip_size_org;
return 2;
}
@@ -444,12 +436,12 @@ int32_t _bmp_decode_rle8(bmp_decompress_struct_p bmp_ptr) {
int32_t bmp_row_num_next = bmp_ptr->row_num + (int32_t)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");
+ bmp_error(bmp_ptr, "The Bmp File Is Corrupt Or Not Supported");
return 0;
}
while (bmp_ptr->row_num < bmp_row_num_next) {
FXSYS_memset(bmp_ptr->out_row_buffer, 0, bmp_ptr->out_row_bytes);
- bmp_ptr->_bmp_get_row_fn(
+ bmp_ptr->bmp_get_row_fn(
bmp_ptr, bmp_ptr->imgTB_flag
? bmp_ptr->row_num++
: (bmp_ptr->height - 1 - bmp_ptr->row_num++),
@@ -459,12 +451,12 @@ int32_t _bmp_decode_rle8(bmp_decompress_struct_p bmp_ptr) {
default: {
if ((int32_t)(*first_byte_ptr) >
bmp_ptr->src_row_bytes - bmp_ptr->col_num) {
- _bmp_error(bmp_ptr, "The Bmp File Is Corrupt");
+ 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) {
+ 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;
}
@@ -475,13 +467,13 @@ int32_t _bmp_decode_rle8(bmp_decompress_struct_p bmp_ptr) {
}
} break;
default: {
- if (_bmp_read_data(bmp_ptr, &second_byte_ptr, 1) == NULL) {
+ if (bmp_read_data(bmp_ptr, &second_byte_ptr, 1) == NULL) {
bmp_ptr->skip_size = skip_size_org;
return 2;
}
if ((int32_t)(*first_byte_ptr) >
bmp_ptr->src_row_bytes - bmp_ptr->col_num) {
- _bmp_error(bmp_ptr, "The Bmp File Is Corrupt");
+ bmp_error(bmp_ptr, "The Bmp File Is Corrupt");
return 0;
}
FXSYS_memset(bmp_ptr->out_row_buffer + bmp_ptr->col_num,
@@ -490,55 +482,55 @@ int32_t _bmp_decode_rle8(bmp_decompress_struct_p bmp_ptr) {
}
}
}
- _bmp_error(bmp_ptr, "Any Uncontrol Error");
+ bmp_error(bmp_ptr, "Any Uncontrol Error");
return 0;
}
-int32_t _bmp_decode_rle4(bmp_decompress_struct_p bmp_ptr) {
+int32_t bmp_decode_rle4(bmp_decompress_struct_p bmp_ptr) {
uint8_t* first_byte_ptr = NULL;
uint8_t* 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) {
+ 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) {
+ 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");
+ 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_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_memset(bmp_ptr->out_row_buffer, 0, bmp_ptr->out_row_bytes);
- _bmp_save_decoding_status(bmp_ptr, BMP_D_STATUS_DATA);
+ 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_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);
+ bmp_save_decoding_status(bmp_ptr, BMP_D_STATUS_TAIL);
return 1;
}
case RLE_DELTA: {
uint8_t* delta_ptr;
- if (_bmp_read_data(bmp_ptr, &delta_ptr, 2) == NULL) {
+ if (bmp_read_data(bmp_ptr, &delta_ptr, 2) == NULL) {
bmp_ptr->skip_size = skip_size_org;
return 2;
}
@@ -546,12 +538,12 @@ int32_t _bmp_decode_rle4(bmp_decompress_struct_p bmp_ptr) {
int32_t bmp_row_num_next = bmp_ptr->row_num + (int32_t)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");
+ bmp_error(bmp_ptr, "The Bmp File Is Corrupt Or Not Supported");
return 0;
}
while (bmp_ptr->row_num < bmp_row_num_next) {
FXSYS_memset(bmp_ptr->out_row_buffer, 0, bmp_ptr->out_row_bytes);
- bmp_ptr->_bmp_get_row_fn(
+ bmp_ptr->bmp_get_row_fn(
bmp_ptr, bmp_ptr->imgTB_flag
? bmp_ptr->row_num++
: (bmp_ptr->height - 1 - bmp_ptr->row_num++),
@@ -563,13 +555,13 @@ int32_t _bmp_decode_rle4(bmp_decompress_struct_p bmp_ptr) {
if ((int32_t)*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");
+ 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) {
+ if (bmp_read_data(bmp_ptr, &second_byte_ptr,
+ size & 1 ? size + 1 : size) == NULL) {
bmp_ptr->skip_size = skip_size_org;
return 2;
}
@@ -586,7 +578,7 @@ int32_t _bmp_decode_rle4(bmp_decompress_struct_p bmp_ptr) {
}
} break;
default: {
- if (_bmp_read_data(bmp_ptr, &second_byte_ptr, 1) == NULL) {
+ if (bmp_read_data(bmp_ptr, &second_byte_ptr, 1) == NULL) {
bmp_ptr->skip_size = skip_size_org;
return 2;
}
@@ -594,7 +586,7 @@ int32_t _bmp_decode_rle4(bmp_decompress_struct_p bmp_ptr) {
bmp_ptr->out_row_bytes - bmp_ptr->col_num) {
uint8_t size = (uint8_t)(((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");
+ bmp_error(bmp_ptr, "The Bmp File Is Corrupt");
return 0;
}
*first_byte_ptr = bmp_ptr->out_row_bytes - bmp_ptr->col_num - 1;
@@ -611,12 +603,12 @@ int32_t _bmp_decode_rle4(bmp_decompress_struct_p bmp_ptr) {
}
}
}
- _bmp_error(bmp_ptr, "Any Uncontrol Error");
+ bmp_error(bmp_ptr, "Any Uncontrol Error");
return 0;
}
-uint8_t* _bmp_read_data(bmp_decompress_struct_p bmp_ptr,
- uint8_t** des_buf_pp,
- FX_DWORD data_size) {
+uint8_t* bmp_read_data(bmp_decompress_struct_p bmp_ptr,
+ uint8_t** des_buf_pp,
+ FX_DWORD data_size) {
if (bmp_ptr == NULL || bmp_ptr->avail_in < bmp_ptr->skip_size + data_size) {
return NULL;
}
@@ -624,22 +616,21 @@ uint8_t* _bmp_read_data(bmp_decompress_struct_p bmp_ptr,
bmp_ptr->skip_size += data_size;
return *des_buf_pp;
}
-void _bmp_save_decoding_status(bmp_decompress_struct_p bmp_ptr,
- int32_t status) {
+void bmp_save_decoding_status(bmp_decompress_struct_p bmp_ptr, int32_t 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,
- uint8_t* src_buf,
- FX_DWORD src_size) {
+void bmp_input_buffer(bmp_decompress_struct_p bmp_ptr,
+ uint8_t* 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,
- uint8_t** avial_buf_ptr) {
+FX_DWORD bmp_get_avail_input(bmp_decompress_struct_p bmp_ptr,
+ uint8_t** avial_buf_ptr) {
if (avial_buf_ptr) {
*avial_buf_ptr = NULL;
if (bmp_ptr->avail_in > 0) {
@@ -648,7 +639,7 @@ FX_DWORD _bmp_get_avail_input(bmp_decompress_struct_p bmp_ptr,
}
return bmp_ptr->avail_in;
}
-bmp_compress_struct_p _bmp_create_compress() {
+bmp_compress_struct_p bmp_create_compress() {
bmp_compress_struct_p bmp_ptr;
bmp_ptr = FX_Alloc(bmp_compress_struct, 1);
if (bmp_ptr) {
@@ -656,7 +647,7 @@ bmp_compress_struct_p _bmp_create_compress() {
}
return bmp_ptr;
}
-void _bmp_destroy_compress(bmp_compress_struct_p 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);
@@ -667,49 +658,46 @@ void _bmp_destroy_compress(bmp_compress_struct_p bmp_ptr) {
static void WriteFileHeader(BmpFileHeaderPtr head_ptr, uint8_t* dst_buf) {
FX_DWORD offset;
offset = 0;
- _SetWord_LSBFirst(&dst_buf[offset], head_ptr->bfType);
+ SetWord_LSBFirst(&dst_buf[offset], head_ptr->bfType);
offset += 2;
- _SetDWord_LSBFirst(&dst_buf[offset], head_ptr->bfSize);
+ SetDWord_LSBFirst(&dst_buf[offset], head_ptr->bfSize);
offset += 4;
- _SetWord_LSBFirst(&dst_buf[offset], head_ptr->bfReserved1);
+ SetWord_LSBFirst(&dst_buf[offset], head_ptr->bfReserved1);
offset += 2;
- _SetWord_LSBFirst(&dst_buf[offset], head_ptr->bfReserved2);
+ SetWord_LSBFirst(&dst_buf[offset], head_ptr->bfReserved2);
offset += 2;
- _SetDWord_LSBFirst(&dst_buf[offset], head_ptr->bfOffBits);
+ SetDWord_LSBFirst(&dst_buf[offset], head_ptr->bfOffBits);
offset += 4;
}
static void WriteInfoHeader(BmpInfoHeaderPtr info_head_ptr, uint8_t* dst_buf) {
FX_DWORD offset;
offset = sizeof(BmpFileHeader);
- _SetDWord_LSBFirst(&dst_buf[offset], info_head_ptr->biSize);
+ SetDWord_LSBFirst(&dst_buf[offset], info_head_ptr->biSize);
offset += 4;
- _SetDWord_LSBFirst(&dst_buf[offset], (FX_DWORD)info_head_ptr->biWidth);
+ SetDWord_LSBFirst(&dst_buf[offset], info_head_ptr->biWidth);
offset += 4;
- _SetDWord_LSBFirst(&dst_buf[offset], (FX_DWORD)info_head_ptr->biHeight);
+ SetDWord_LSBFirst(&dst_buf[offset], info_head_ptr->biHeight);
offset += 4;
- _SetWord_LSBFirst(&dst_buf[offset], info_head_ptr->biPlanes);
+ SetWord_LSBFirst(&dst_buf[offset], info_head_ptr->biPlanes);
offset += 2;
- _SetWord_LSBFirst(&dst_buf[offset], info_head_ptr->biBitCount);
+ SetWord_LSBFirst(&dst_buf[offset], info_head_ptr->biBitCount);
offset += 2;
- _SetDWord_LSBFirst(&dst_buf[offset], info_head_ptr->biCompression);
+ SetDWord_LSBFirst(&dst_buf[offset], info_head_ptr->biCompression);
offset += 4;
- _SetDWord_LSBFirst(&dst_buf[offset], info_head_ptr->biSizeImage);
+ SetDWord_LSBFirst(&dst_buf[offset], info_head_ptr->biSizeImage);
offset += 4;
- _SetDWord_LSBFirst(&dst_buf[offset],
- (FX_DWORD)info_head_ptr->biXPelsPerMeter);
+ SetDWord_LSBFirst(&dst_buf[offset], info_head_ptr->biXPelsPerMeter);
offset += 4;
- _SetDWord_LSBFirst(&dst_buf[offset],
- (FX_DWORD)info_head_ptr->biYPelsPerMeter);
+ SetDWord_LSBFirst(&dst_buf[offset], info_head_ptr->biYPelsPerMeter);
offset += 4;
- _SetDWord_LSBFirst(&dst_buf[offset], info_head_ptr->biClrUsed);
+ SetDWord_LSBFirst(&dst_buf[offset], info_head_ptr->biClrUsed);
offset += 4;
- _SetDWord_LSBFirst(&dst_buf[offset], info_head_ptr->biClrImportant);
+ 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,
- uint8_t*& dst_buf,
- FX_DWORD& dst_size) {
+static void bmp_encode_bitfields(bmp_compress_struct_p bmp_ptr,
+ uint8_t*& dst_buf,
+ FX_DWORD& dst_size) {
if (bmp_ptr->info_header.biBitCount != 16 &&
bmp_ptr->info_header.biBitCount != 32) {
return;
@@ -741,11 +729,11 @@ static void _bmp_encode_bitfields(bmp_compress_struct_p bmp_ptr,
mask_green = 0x00FF00;
mask_blue = 0x0000FF;
}
- _SetDWord_LSBFirst(&dst_buf[dst_pos], mask_red);
+ SetDWord_LSBFirst(&dst_buf[dst_pos], mask_red);
dst_pos += 4;
- _SetDWord_LSBFirst(&dst_buf[dst_pos], mask_green);
+ SetDWord_LSBFirst(&dst_buf[dst_pos], mask_green);
dst_pos += 4;
- _SetDWord_LSBFirst(&dst_buf[dst_pos], mask_blue);
+ SetDWord_LSBFirst(&dst_buf[dst_pos], mask_blue);
dst_pos += 4;
bmp_ptr->file_header.bfOffBits = dst_pos;
}
@@ -782,24 +770,22 @@ static void _bmp_encode_bitfields(bmp_compress_struct_p bmp_ptr,
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);
+ SetWord_LSBFirst(&dst_buf[dst_pos], pix_val);
dst_pos += 2;
} else {
- _SetDWord_LSBFirst(&dst_buf[dst_pos], pix_val);
+ 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,
- uint8_t*& dst_buf,
- FX_DWORD& dst_size) {
+
+static void bmp_encode_rgb(bmp_compress_struct_p bmp_ptr,
+ uint8_t*& 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
+ bmp_encode_bitfields(bmp_ptr, dst_buf, dst_size);
return;
}
FX_DWORD size, dst_pos;
@@ -821,7 +807,7 @@ static void _bmp_encode_rgb(bmp_compress_struct_p bmp_ptr,
}
dst_size = dst_pos;
}
-static uint8_t _bmp_rle8_search(const uint8_t* buf, int32_t len) {
+static uint8_t bmp_rle8_search(const uint8_t* buf, int32_t len) {
uint8_t num;
num = 1;
while (num < len) {
@@ -832,9 +818,9 @@ static uint8_t _bmp_rle8_search(const uint8_t* buf, int32_t len) {
}
return num;
}
-static void _bmp_encode_rle8(bmp_compress_struct_p bmp_ptr,
- uint8_t*& dst_buf,
- FX_DWORD& dst_size) {
+static void bmp_encode_rle8(bmp_compress_struct_p bmp_ptr,
+ uint8_t*& dst_buf,
+ FX_DWORD& dst_size) {
FX_DWORD size, dst_pos, index;
uint8_t rle[2] = {0};
size = bmp_ptr->src_pitch * bmp_ptr->src_row * 2;
@@ -847,7 +833,7 @@ static void _bmp_encode_rle8(bmp_compress_struct_p bmp_ptr,
FXSYS_memset(&dst_buf[dst_pos], 0, size);
for (int32_t 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[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] >= (int32_t)bmp_ptr->src_pitch) {
rle[0] = uint8_t(bmp_ptr->src_pitch - i);
@@ -869,7 +855,7 @@ static void _bmp_encode_rle8(bmp_compress_struct_p bmp_ptr,
dst_buf[dst_pos++] = RLE_EOI;
dst_size = dst_pos;
}
-static uint8_t _bmp_rle4_search(const uint8_t* buf, int32_t len) {
+static uint8_t bmp_rle4_search(const uint8_t* buf, int32_t len) {
uint8_t num;
num = 2;
while (num < len) {
@@ -880,9 +866,9 @@ static uint8_t _bmp_rle4_search(const uint8_t* buf, int32_t len) {
}
return num;
}
-static void _bmp_encode_rle4(bmp_compress_struct_p bmp_ptr,
- uint8_t*& dst_buf,
- FX_DWORD& dst_size) {
+static void bmp_encode_rle4(bmp_compress_struct_p bmp_ptr,
+ uint8_t*& dst_buf,
+ FX_DWORD& dst_size) {
FX_DWORD size, dst_pos, index;
uint8_t rle[2] = {0};
size = bmp_ptr->src_pitch * bmp_ptr->src_row;
@@ -896,7 +882,7 @@ static void _bmp_encode_rle4(bmp_compress_struct_p bmp_ptr,
for (int32_t 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[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] >= (int32_t)bmp_ptr->src_pitch) {
@@ -919,9 +905,9 @@ static void _bmp_encode_rle4(bmp_compress_struct_p bmp_ptr,
dst_buf[dst_pos++] = RLE_EOI;
dst_size = dst_pos;
}
-FX_BOOL _bmp_encode_image(bmp_compress_struct_p bmp_ptr,
- uint8_t*& dst_buf,
- FX_DWORD& dst_size) {
+FX_BOOL bmp_encode_image(bmp_compress_struct_p bmp_ptr,
+ uint8_t*& 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 &&
@@ -942,18 +928,16 @@ FX_BOOL _bmp_encode_image(bmp_compress_struct_p bmp_ptr,
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);
+ 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
+ bmp_encode_bitfields(bmp_ptr, dst_buf, dst_size);
break;
case BMP_RLE8:
- _bmp_encode_rle8(bmp_ptr, dst_buf, dst_size);
+ bmp_encode_rle8(bmp_ptr, dst_buf, dst_size);
break;
case BMP_RLE4:
- _bmp_encode_rle4(bmp_ptr, dst_buf, dst_size);
+ bmp_encode_rle4(bmp_ptr, dst_buf, dst_size);
break;
default:
break;
diff --git a/core/src/fxcodec/lbmp/fx_bmp.h b/core/src/fxcodec/lbmp/fx_bmp.h
index 063b1bd757..24c94cabbe 100644
--- a/core/src/fxcodec/lbmp/fx_bmp.h
+++ b/core/src/fxcodec/lbmp/fx_bmp.h
@@ -11,7 +11,6 @@
#include "core/include/fxcrt/fx_basic.h"
-#define BMP_SUPPORT_BITFIELD
#define BMP_WIDTHBYTES(width, bitCount) ((width * bitCount) + 31) / 32 * 4
#define BMP_PAL_ENCODE(a, r, g, b) \
(((FX_DWORD)(a) << 24) | ((r) << 16) | ((g) << 8) | (b))
@@ -70,8 +69,7 @@ typedef bmp_decompress_struct_p* bmp_decompress_struct_pp;
struct tag_bmp_decompress_struct {
jmp_buf jmpbuf;
FX_CHAR* err_ptr;
- void (*_bmp_error_fn)(bmp_decompress_struct_p gif_ptr,
- const FX_CHAR* err_msg);
+ void (*bmp_error_fn)(bmp_decompress_struct_p gif_ptr, const FX_CHAR* err_msg);
void* context_ptr;
@@ -97,39 +95,37 @@ struct tag_bmp_decompress_struct {
int32_t col_num;
int32_t dpi_x;
int32_t dpi_y;
-#ifdef BMP_SUPPORT_BITFIELD
FX_DWORD mask_red;
FX_DWORD mask_green;
FX_DWORD mask_blue;
-#endif
- FX_BOOL (*_bmp_get_data_position_fn)(bmp_decompress_struct_p bmp_ptr,
+ FX_BOOL (*bmp_get_data_position_fn)(bmp_decompress_struct_p bmp_ptr,
FX_DWORD cur_pos);
- void (*_bmp_get_row_fn)(bmp_decompress_struct_p bmp_ptr,
- int32_t row_num,
- uint8_t* row_buf);
+ void (*bmp_get_row_fn)(bmp_decompress_struct_p bmp_ptr,
+ int32_t row_num,
+ uint8_t* row_buf);
uint8_t* next_in;
FX_DWORD avail_in;
FX_DWORD skip_size;
int32_t decode_status;
};
-void _bmp_error(bmp_decompress_struct_p bmp_ptr, const FX_CHAR* err_msg);
-bmp_decompress_struct_p _bmp_create_decompress();
-void _bmp_destroy_decompress(bmp_decompress_struct_pp bmp_ptr_ptr);
-int32_t _bmp_read_header(bmp_decompress_struct_p bmp_ptr);
-int32_t _bmp_decode_image(bmp_decompress_struct_p bmp_ptr);
-int32_t _bmp_decode_rgb(bmp_decompress_struct_p bmp_ptr);
-int32_t _bmp_decode_rle8(bmp_decompress_struct_p bmp_ptr);
-int32_t _bmp_decode_rle4(bmp_decompress_struct_p bmp_ptr);
-uint8_t* _bmp_read_data(bmp_decompress_struct_p bmp_ptr,
- uint8_t** des_buf_pp,
- FX_DWORD data_size);
-void _bmp_save_decoding_status(bmp_decompress_struct_p bmp_ptr, int32_t status);
-void _bmp_input_buffer(bmp_decompress_struct_p bmp_ptr,
- uint8_t* src_buf,
- FX_DWORD src_size);
-FX_DWORD _bmp_get_avail_input(bmp_decompress_struct_p bmp_ptr,
- uint8_t** avial_buf_ptr);
+void bmp_error(bmp_decompress_struct_p bmp_ptr, const FX_CHAR* err_msg);
+bmp_decompress_struct_p bmp_create_decompress();
+void bmp_destroy_decompress(bmp_decompress_struct_pp bmp_ptr_ptr);
+int32_t bmp_read_header(bmp_decompress_struct_p bmp_ptr);
+int32_t bmp_decode_image(bmp_decompress_struct_p bmp_ptr);
+int32_t bmp_decode_rgb(bmp_decompress_struct_p bmp_ptr);
+int32_t bmp_decode_rle8(bmp_decompress_struct_p bmp_ptr);
+int32_t bmp_decode_rle4(bmp_decompress_struct_p bmp_ptr);
+uint8_t* bmp_read_data(bmp_decompress_struct_p bmp_ptr,
+ uint8_t** des_buf_pp,
+ FX_DWORD data_size);
+void bmp_save_decoding_status(bmp_decompress_struct_p bmp_ptr, int32_t status);
+void bmp_input_buffer(bmp_decompress_struct_p bmp_ptr,
+ uint8_t* src_buf,
+ FX_DWORD src_size);
+FX_DWORD bmp_get_avail_input(bmp_decompress_struct_p bmp_ptr,
+ uint8_t** avial_buf_ptr);
typedef struct tag_bmp_compress_struct bmp_compress_struct;
typedef bmp_compress_struct* bmp_compress_struct_p;
typedef bmp_compress_struct_p* bmp_compress_struct_pp;
@@ -144,15 +140,16 @@ struct tag_bmp_compress_struct {
FX_BOOL src_free;
FX_DWORD* pal_ptr;
FX_WORD pal_num;
-#ifdef BMP_SUPPORT_BITFIELD
uint8_t bit_type;
-#endif
};
-bmp_compress_struct_p _bmp_create_compress();
-void _bmp_destroy_compress(bmp_compress_struct_p bmp_ptr);
-FX_BOOL _bmp_encode_image(bmp_compress_struct_p bmp_ptr,
- uint8_t*& dst_buf,
- FX_DWORD& dst_size);
+bmp_compress_struct_p bmp_create_compress();
+void bmp_destroy_compress(bmp_compress_struct_p bmp_ptr);
+FX_BOOL bmp_encode_image(bmp_compress_struct_p bmp_ptr,
+ uint8_t*& dst_buf,
+ FX_DWORD& dst_size);
+
+FX_WORD GetWord_LSBFirst(uint8_t* p);
+void SetWord_LSBFirst(uint8_t* p, FX_WORD v);
#endif // CORE_SRC_FXCODEC_LBMP_FX_BMP_H_
diff --git a/core/src/fxcodec/lgif/fx_gif.cpp b/core/src/fxcodec/lgif/fx_gif.cpp
index ffac891032..a4de72978a 100644
--- a/core/src/fxcodec/lgif/fx_gif.cpp
+++ b/core/src/fxcodec/lgif/fx_gif.cpp
@@ -5,6 +5,9 @@
// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
#include "core/src/fxcodec/lgif/fx_gif.h"
+
+#include "core/src/fxcodec/lbmp/fx_bmp.h"
+
void CGifLZWDecoder::Input(uint8_t* src_buf, FX_DWORD src_size) {
next_in = src_buf;
avail_in = src_size;
@@ -141,9 +144,9 @@ int32_t CGifLZWDecoder::Decode(uint8_t* des_buf, FX_DWORD& des_size) {
}
return 0;
}
-static FX_BOOL _gif_grow_buf(uint8_t*& dst_buf,
- FX_DWORD& dst_len,
- FX_DWORD size) {
+static FX_BOOL gif_grow_buf(uint8_t*& dst_buf,
+ FX_DWORD& dst_len,
+ FX_DWORD size) {
if (dst_len < size) {
FX_DWORD len_org = dst_len;
while (dst_buf && dst_len < size) {
@@ -162,19 +165,19 @@ static FX_BOOL _gif_grow_buf(uint8_t*& dst_buf,
}
return TRUE;
}
-static inline void _gif_cut_index(uint8_t& val,
- FX_DWORD index,
- uint8_t index_bit,
- uint8_t index_bit_use,
- uint8_t bit_use) {
+static inline void gif_cut_index(uint8_t& val,
+ FX_DWORD index,
+ uint8_t index_bit,
+ uint8_t index_bit_use,
+ uint8_t bit_use) {
FX_DWORD cut = ((1 << (index_bit - index_bit_use)) - 1) << index_bit_use;
val |= ((index & cut) >> index_bit_use) << bit_use;
}
-static inline uint8_t _gif_cut_buf(const uint8_t* buf,
- FX_DWORD& offset,
- uint8_t bit_cut,
- uint8_t& bit_offset,
- FX_DWORD& bit_num) {
+static inline uint8_t gif_cut_buf(const uint8_t* buf,
+ FX_DWORD& offset,
+ uint8_t bit_cut,
+ uint8_t& bit_offset,
+ FX_DWORD& bit_num) {
if (bit_cut != 8) {
FX_WORD index = 0;
index |= ((1 << bit_cut) - 1) << (7 - bit_offset);
@@ -224,15 +227,15 @@ void CGifLZWEncoder::Start(uint8_t code_len,
src_offset = 0;
src_bit_offset = 0;
src_bit_num = 0;
- code_table[index_num].prefix = _gif_cut_buf(src_buf, src_offset, src_bit_cut,
- src_bit_offset, src_bit_num);
- code_table[index_num].suffix = _gif_cut_buf(src_buf, src_offset, src_bit_cut,
- src_bit_offset, src_bit_num);
+ code_table[index_num].prefix = gif_cut_buf(src_buf, src_offset, src_bit_cut,
+ src_bit_offset, src_bit_num);
+ code_table[index_num].suffix = gif_cut_buf(src_buf, src_offset, src_bit_cut,
+ src_bit_offset, src_bit_num);
}
void CGifLZWEncoder::WriteBlock(uint8_t*& dst_buf,
FX_DWORD& dst_len,
FX_DWORD& offset) {
- if (!_gif_grow_buf(dst_buf, dst_len, offset + GIF_DATA_BLOCK + 1)) {
+ if (!gif_grow_buf(dst_buf, dst_len, offset + GIF_DATA_BLOCK + 1)) {
longjmp(jmp, 1);
}
dst_buf[offset++] = index_buf_len;
@@ -250,8 +253,8 @@ void CGifLZWEncoder::EncodeString(FX_DWORD index,
if (index_buf_len == GIF_DATA_BLOCK) {
WriteBlock(dst_buf, dst_len, offset);
}
- _gif_cut_index(index_buf[index_buf_len], index, index_bit_cur, index_bit_use,
- bit_offset);
+ gif_cut_index(index_buf[index_buf_len], index, index_bit_cur, index_bit_use,
+ bit_offset);
if (index_bit_cur <= (8 - bit_offset)) {
bit_offset += index_bit_cur;
} else if (index_bit_cur <= (16 - bit_offset)) {
@@ -261,8 +264,8 @@ void CGifLZWEncoder::EncodeString(FX_DWORD index,
if (index_buf_len == GIF_DATA_BLOCK) {
WriteBlock(dst_buf, dst_len, offset);
}
- _gif_cut_index(index_buf[index_buf_len], index, index_bit_cur,
- index_bit_use, bit_offset);
+ gif_cut_index(index_buf[index_buf_len], index, index_bit_cur, index_bit_use,
+ bit_offset);
bit_offset = index_bit_cur - index_bit_use;
} else {
index_bit_use += (8 - bit_offset);
@@ -271,16 +274,16 @@ void CGifLZWEncoder::EncodeString(FX_DWORD index,
if (index_buf_len == GIF_DATA_BLOCK) {
WriteBlock(dst_buf, dst_len, offset);
}
- _gif_cut_index(index_buf[index_buf_len], index, index_bit_cur,
- index_bit_use, bit_offset);
+ gif_cut_index(index_buf[index_buf_len], index, index_bit_cur, index_bit_use,
+ bit_offset);
index_bit_use += 8;
bit_offset = 0;
index_buf_len++;
if (index_buf_len == GIF_DATA_BLOCK) {
WriteBlock(dst_buf, dst_len, offset);
}
- _gif_cut_index(index_buf[index_buf_len], index, index_bit_cur,
- index_bit_use, bit_offset);
+ gif_cut_index(index_buf[index_buf_len], index, index_bit_cur, index_bit_use,
+ bit_offset);
bit_offset = index_bit_cur - index_bit_use;
}
if (bit_offset == 8) {
@@ -315,11 +318,11 @@ FX_BOOL CGifLZWEncoder::Encode(const uint8_t* src_buf,
EncodeString(code_clear, dst_buf, dst_len, offset);
ClearTable();
code_table[index_num].prefix = suffix;
- code_table[index_num].suffix = _gif_cut_buf(
+ code_table[index_num].suffix = gif_cut_buf(
src_buf, src_offset, src_bit_cut, src_bit_offset, src_bit_num);
} else {
code_table[index_num].prefix = code_table[index_num - 1].suffix;
- code_table[index_num].suffix = _gif_cut_buf(
+ code_table[index_num].suffix = gif_cut_buf(
src_buf, src_offset, src_bit_cut, src_bit_offset, src_bit_num);
}
}
@@ -337,7 +340,7 @@ FX_BOOL CGifLZWEncoder::LookUpInTable(const uint8_t* buf,
code_table[i].suffix == code_table[index_num].suffix) {
code_table[index_num].prefix = i;
code_table[index_num].suffix =
- _gif_cut_buf(buf, offset, src_bit_cut, bit_offset, src_bit_num);
+ gif_cut_buf(buf, offset, src_bit_cut, bit_offset, src_bit_num);
table_cur = i;
return TRUE;
}
@@ -353,7 +356,7 @@ void CGifLZWEncoder::Finish(uint8_t*& dst_buf,
bit_offset = 0;
ClearTable();
}
-gif_decompress_struct_p _gif_create_decompress() {
+gif_decompress_struct_p gif_create_decompress() {
gif_decompress_struct_p gif_ptr =
(gif_decompress_struct*)FX_Alloc(uint8_t, sizeof(gif_decompress_struct));
if (gif_ptr == NULL) {
@@ -362,15 +365,11 @@ gif_decompress_struct_p _gif_create_decompress() {
FXSYS_memset(gif_ptr, 0, sizeof(gif_decompress_struct));
gif_ptr->decode_status = GIF_D_STATUS_SIG;
gif_ptr->img_ptr_arr_ptr = new CFX_ArrayTemplate<GifImage*>;
-#ifdef GIF_SUPPORT_COMMENT_EXTENSION
gif_ptr->cmt_data_ptr = new CFX_ByteString;
-#endif
-#ifdef GIF_SUPPORT_PLAIN_TEXT_EXTENSION
gif_ptr->pt_ptr_arr_ptr = new CFX_ArrayTemplate<GifPlainText*>;
-#endif
return gif_ptr;
}
-void _gif_destroy_decompress(gif_decompress_struct_pp gif_ptr_ptr) {
+void gif_destroy_decompress(gif_decompress_struct_pp gif_ptr_ptr) {
if (gif_ptr_ptr == NULL || *gif_ptr_ptr == NULL) {
return;
}
@@ -393,16 +392,8 @@ void _gif_destroy_decompress(gif_decompress_struct_pp gif_ptr_ptr) {
gif_ptr->img_ptr_arr_ptr->RemoveAll();
delete gif_ptr->img_ptr_arr_ptr;
}
-#ifdef GIF_SUPPORT_APPLICATION_EXTENSION
- FX_Free(gif_ptr->app_data);
-#endif
-#ifdef GIF_SUPPORT_COMMENT_EXTENSION
delete gif_ptr->cmt_data_ptr;
-#endif
-#ifdef GIF_SUPPORT_GRAPHIC_CONTROL_EXTENSION
FX_Free(gif_ptr->gce_ptr);
-#endif
-#ifdef GIF_SUPPORT_PLAIN_TEXT_EXTENSION
if (gif_ptr->pt_ptr_arr_ptr) {
int32_t size_pt_arr = gif_ptr->pt_ptr_arr_ptr->GetSize();
for (int32_t i = 0; i < size_pt_arr; i++) {
@@ -414,10 +405,9 @@ void _gif_destroy_decompress(gif_decompress_struct_pp gif_ptr_ptr) {
gif_ptr->pt_ptr_arr_ptr->RemoveAll();
delete gif_ptr->pt_ptr_arr_ptr;
}
-#endif
FX_Free(gif_ptr);
}
-gif_compress_struct_p _gif_create_compress() {
+gif_compress_struct_p gif_create_compress() {
gif_compress_struct_p gif_ptr =
(gif_compress_struct*)FX_Alloc(uint8_t, sizeof(gif_compress_struct));
if (gif_ptr == NULL) {
@@ -451,11 +441,6 @@ gif_compress_struct_p _gif_create_compress() {
return NULL;
}
FXSYS_memset(gif_ptr->image_info_ptr, 0, sizeof(GifImageInfo));
-#ifdef GIF_SUPPORT_APPLICATION_EXTENSION
- FXSYS_memcpy(gif_ptr->app_identify, "netscape", 8);
- FXSYS_memcpy(gif_ptr->app_authentication, "2.0", 3);
-#endif
-#ifdef GIF_SUPPORT_GRAPHIC_CONTROL_EXTENSION
gif_ptr->gce_ptr = (GifGCE*)FX_Alloc(uint8_t, sizeof(GifGCE));
if (gif_ptr->gce_ptr == NULL) {
FX_Free(gif_ptr->image_info_ptr);
@@ -465,8 +450,6 @@ gif_compress_struct_p _gif_create_compress() {
FX_Free(gif_ptr);
return NULL;
}
-#endif
-#ifdef GIF_SUPPORT_PLAIN_TEXT_EXTENSION
gif_ptr->pte_ptr = (GifPTE*)FX_Alloc(uint8_t, sizeof(GifPTE));
if (gif_ptr->pte_ptr == NULL) {
FX_Free(gif_ptr->gce_ptr);
@@ -479,10 +462,9 @@ gif_compress_struct_p _gif_create_compress() {
}
FXSYS_memset(gif_ptr->pte_ptr, 0, sizeof(GifPTE));
gif_ptr->pte_ptr->block_size = 12;
-#endif
return gif_ptr;
}
-void _gif_destroy_compress(gif_compress_struct_pp gif_ptr_ptr) {
+void gif_destroy_compress(gif_compress_struct_pp gif_ptr_ptr) {
if (gif_ptr_ptr == NULL || *gif_ptr_ptr == NULL) {
return;
}
@@ -494,44 +476,35 @@ void _gif_destroy_compress(gif_compress_struct_pp gif_ptr_ptr) {
FX_Free(gif_ptr->image_info_ptr);
FX_Free(gif_ptr->local_pal);
delete gif_ptr->img_encoder_ptr;
-#ifdef GIF_SUPPORT_APPLICATION_EXTENSION
- FX_Free(gif_ptr->app_data);
-#endif
-#ifdef GIF_SUPPORT_GRAPHIC_CONTROL_EXTENSION
FX_Free(gif_ptr->gce_ptr);
-#endif
-#ifdef GIF_SUPPORT_COMMENT_EXTENSION
FX_Free(gif_ptr->cmt_data_ptr);
-#endif
-#ifdef GIF_SUPPORT_PLAIN_TEXT_EXTENSION
FX_Free(gif_ptr->pte_ptr);
-#endif
FX_Free(gif_ptr);
}
-void _gif_error(gif_decompress_struct_p gif_ptr, const FX_CHAR* err_msg) {
- if (gif_ptr && gif_ptr->_gif_error_fn) {
- gif_ptr->_gif_error_fn(gif_ptr, err_msg);
+void gif_error(gif_decompress_struct_p gif_ptr, const FX_CHAR* err_msg) {
+ if (gif_ptr && gif_ptr->gif_error_fn) {
+ gif_ptr->gif_error_fn(gif_ptr, err_msg);
}
}
-void _gif_warn(gif_decompress_struct_p gif_ptr, const FX_CHAR* err_msg) {}
-int32_t _gif_read_header(gif_decompress_struct_p gif_ptr) {
+void gif_warn(gif_decompress_struct_p gif_ptr, const FX_CHAR* err_msg) {}
+int32_t gif_read_header(gif_decompress_struct_p gif_ptr) {
if (gif_ptr == NULL) {
return 0;
}
FX_DWORD skip_size_org = gif_ptr->skip_size;
ASSERT(sizeof(GifHeader) == 6);
GifHeader* gif_header_ptr = NULL;
- if (_gif_read_data(gif_ptr, (uint8_t**)&gif_header_ptr, 6) == NULL) {
+ if (gif_read_data(gif_ptr, (uint8_t**)&gif_header_ptr, 6) == NULL) {
return 2;
}
if (FXSYS_strncmp(gif_header_ptr->signature, GIF_SIGNATURE, 3) != 0 ||
gif_header_ptr->version[0] != '8' || gif_header_ptr->version[2] != 'a') {
- _gif_error(gif_ptr, "Not A Gif Image");
+ gif_error(gif_ptr, "Not A Gif Image");
return 0;
}
ASSERT(sizeof(GifLSD) == 7);
GifLSD* gif_lsd_ptr = NULL;
- if (_gif_read_data(gif_ptr, (uint8_t**)&gif_lsd_ptr, 7) == NULL) {
+ if (gif_read_data(gif_ptr, (uint8_t**)&gif_lsd_ptr, 7) == NULL) {
gif_ptr->skip_size = skip_size_org;
return 2;
}
@@ -541,7 +514,7 @@ int32_t _gif_read_header(gif_decompress_struct_p gif_ptr) {
ASSERT(sizeof(GifPalette) == 3);
int32_t global_pal_size = gif_ptr->global_pal_num * 3;
uint8_t* global_pal_ptr = NULL;
- if (_gif_read_data(gif_ptr, &global_pal_ptr, global_pal_size) == NULL) {
+ if (gif_read_data(gif_ptr, &global_pal_ptr, global_pal_size) == NULL) {
gif_ptr->skip_size = skip_size_org;
return 2;
}
@@ -552,13 +525,13 @@ int32_t _gif_read_header(gif_decompress_struct_p gif_ptr) {
gif_ptr->global_pal_ptr = (GifPalette*)FX_Alloc(uint8_t, global_pal_size);
FXSYS_memcpy(gif_ptr->global_pal_ptr, global_pal_ptr, global_pal_size);
}
- gif_ptr->width = (int)_GetWord_LSBFirst((uint8_t*)&gif_lsd_ptr->width);
- gif_ptr->height = (int)_GetWord_LSBFirst((uint8_t*)&gif_lsd_ptr->height);
+ gif_ptr->width = (int)GetWord_LSBFirst((uint8_t*)&gif_lsd_ptr->width);
+ gif_ptr->height = (int)GetWord_LSBFirst((uint8_t*)&gif_lsd_ptr->height);
gif_ptr->bc_index = gif_lsd_ptr->bc_index;
gif_ptr->pixel_aspect = gif_lsd_ptr->pixel_aspect;
return 1;
}
-int32_t _gif_get_frame(gif_decompress_struct_p gif_ptr) {
+int32_t gif_get_frame(gif_decompress_struct_p gif_ptr) {
if (gif_ptr == NULL) {
return 0;
}
@@ -569,69 +542,56 @@ int32_t _gif_get_frame(gif_decompress_struct_p gif_ptr) {
return 1;
case GIF_D_STATUS_SIG: {
uint8_t* sig_ptr = NULL;
- if (_gif_read_data(gif_ptr, &sig_ptr, 1) == NULL) {
+ if (gif_read_data(gif_ptr, &sig_ptr, 1) == NULL) {
return 2;
}
switch (*sig_ptr) {
case GIF_SIG_EXTENSION:
- _gif_save_decoding_status(gif_ptr, GIF_D_STATUS_EXT);
+ gif_save_decoding_status(gif_ptr, GIF_D_STATUS_EXT);
continue;
case GIF_SIG_IMAGE:
- _gif_save_decoding_status(gif_ptr, GIF_D_STATUS_IMG_INFO);
+ gif_save_decoding_status(gif_ptr, GIF_D_STATUS_IMG_INFO);
continue;
case GIF_SIG_TRAILER:
- _gif_save_decoding_status(gif_ptr, GIF_D_STATUS_TAIL);
+ gif_save_decoding_status(gif_ptr, GIF_D_STATUS_TAIL);
return 1;
default:
if (gif_ptr->avail_in) {
- _gif_warn(gif_ptr, "The Gif File has non_standard Tag!");
- _gif_save_decoding_status(gif_ptr, GIF_D_STATUS_SIG);
+ gif_warn(gif_ptr, "The Gif File has non_standard Tag!");
+ gif_save_decoding_status(gif_ptr, GIF_D_STATUS_SIG);
continue;
}
- _gif_warn(gif_ptr, "The Gif File Doesn't have Trailer Tag!");
+ gif_warn(gif_ptr, "The Gif File Doesn't have Trailer Tag!");
return 1;
}
}
case GIF_D_STATUS_EXT: {
uint8_t* ext_ptr = NULL;
- if (_gif_read_data(gif_ptr, &ext_ptr, 1) == NULL) {
+ if (gif_read_data(gif_ptr, &ext_ptr, 1) == NULL) {
return 2;
}
switch (*ext_ptr) {
-#ifdef GIF_SUPPORT_APPLICATION_EXTENSION
- case GIF_BLOCK_AE:
- _gif_save_decoding_status(gif_ptr, GIF_D_STATUS_EXT_AE);
- continue;
-#endif
-#ifdef GIF_SUPPORT_COMMENT_EXTENSION
case GIF_BLOCK_CE:
- _gif_save_decoding_status(gif_ptr, GIF_D_STATUS_EXT_CE);
+ gif_save_decoding_status(gif_ptr, GIF_D_STATUS_EXT_CE);
continue;
-#endif
-#ifdef GIF_SUPPORT_GRAPHIC_CONTROL_EXTENSION
case GIF_BLOCK_GCE:
- _gif_save_decoding_status(gif_ptr, GIF_D_STATUS_EXT_GCE);
+ gif_save_decoding_status(gif_ptr, GIF_D_STATUS_EXT_GCE);
continue;
-#endif
-#ifdef GIF_SUPPORT_PLAIN_TEXT_EXTENSION
case GIF_BLOCK_PTE:
- _gif_save_decoding_status(gif_ptr, GIF_D_STATUS_EXT_PTE);
+ gif_save_decoding_status(gif_ptr, GIF_D_STATUS_EXT_PTE);
continue;
-#endif
default: {
int32_t status = GIF_D_STATUS_EXT_UNE;
-#ifndef GIF_SUPPORT_PLAIN_TEXT_EXTENSION
if (*ext_ptr == GIF_BLOCK_PTE) {
status = GIF_D_STATUS_EXT_PTE;
}
-#endif
- _gif_save_decoding_status(gif_ptr, status);
+ gif_save_decoding_status(gif_ptr, status);
continue;
}
}
}
case GIF_D_STATUS_IMG_INFO: {
- ret = _gif_decode_image_info(gif_ptr);
+ ret = gif_decode_image_info(gif_ptr);
if (ret != 1) {
return ret;
}
@@ -641,25 +601,25 @@ int32_t _gif_get_frame(gif_decompress_struct_p gif_ptr) {
uint8_t* data_size_ptr = NULL;
uint8_t* data_ptr = NULL;
FX_DWORD skip_size_org = gif_ptr->skip_size;
- if (_gif_read_data(gif_ptr, &data_size_ptr, 1) == NULL) {
+ if (gif_read_data(gif_ptr, &data_size_ptr, 1) == NULL) {
return 2;
}
while (*data_size_ptr != GIF_BLOCK_TERMINAL) {
- if (_gif_read_data(gif_ptr, &data_ptr, *data_size_ptr) == NULL) {
+ if (gif_read_data(gif_ptr, &data_ptr, *data_size_ptr) == NULL) {
gif_ptr->skip_size = skip_size_org;
return 2;
}
- _gif_save_decoding_status(gif_ptr, GIF_D_STATUS_IMG_DATA);
+ gif_save_decoding_status(gif_ptr, GIF_D_STATUS_IMG_DATA);
skip_size_org = gif_ptr->skip_size;
- if (_gif_read_data(gif_ptr, &data_size_ptr, 1) == NULL) {
+ if (gif_read_data(gif_ptr, &data_size_ptr, 1) == NULL) {
return 2;
}
}
- _gif_save_decoding_status(gif_ptr, GIF_D_STATUS_SIG);
+ gif_save_decoding_status(gif_ptr, GIF_D_STATUS_SIG);
continue;
}
default: {
- ret = _gif_decode_extension(gif_ptr);
+ ret = gif_decode_extension(gif_ptr);
if (ret != 1) {
return ret;
}
@@ -669,63 +629,29 @@ int32_t _gif_get_frame(gif_decompress_struct_p gif_ptr) {
}
return 1;
}
-void _gif_takeover_gce_ptr(gif_decompress_struct_p gif_ptr,
- GifGCE** gce_ptr_ptr) {
+void gif_takeover_gce_ptr(gif_decompress_struct_p gif_ptr,
+ GifGCE** gce_ptr_ptr) {
*gce_ptr_ptr = NULL;
-#ifdef GIF_SUPPORT_GRAPHIC_CONTROL_EXTENSION
if (gif_ptr->gce_ptr && gce_ptr_ptr) {
*gce_ptr_ptr = gif_ptr->gce_ptr;
gif_ptr->gce_ptr = NULL;
}
-#endif
}
-int32_t _gif_decode_extension(gif_decompress_struct_p gif_ptr) {
+int32_t gif_decode_extension(gif_decompress_struct_p gif_ptr) {
uint8_t* data_size_ptr = NULL;
uint8_t* data_ptr = NULL;
FX_DWORD skip_size_org = gif_ptr->skip_size;
switch (gif_ptr->decode_status) {
-#ifdef GIF_SUPPORT_APPLICATION_EXTENSION
- case GIF_D_STATUS_EXT_AE: {
- ASSERT(sizeof(GifAE) == 12);
- GifAE* gif_ae_ptr = NULL;
- if (_gif_read_data(gif_ptr, (uint8_t**)&gif_ae_ptr, 12) == NULL) {
- return 2;
- }
- CFX_ByteString gif_ae_data_str;
- if (_gif_read_data(gif_ptr, &data_size_ptr, 1) == NULL) {
- gif_ptr->skip_size = skip_size_org;
- return 2;
- }
- while (*data_size_ptr != GIF_BLOCK_TERMINAL) {
- uint8_t data_size = *data_size_ptr;
- if (_gif_read_data(gif_ptr, &data_ptr, *data_size_ptr) == NULL ||
- _gif_read_data(gif_ptr, &data_size_ptr, 1) == NULL) {
- gif_ptr->skip_size = skip_size_org;
- return 2;
- }
- gif_ae_data_str += CFX_ByteString((const uint8_t*)data_ptr, data_size);
- }
- FXSYS_memcpy(gif_ptr->app_identify, gif_ae_ptr->app_identify, 8);
- FXSYS_memcpy(gif_ptr->app_authentication, gif_ae_ptr->app_authentication,
- 3);
- gif_ptr->app_data_size = gif_ae_data_str.GetLength();
- FX_Free(gif_ptr->app_data);
- gif_ptr->app_data = FX_Alloc(uint8_t, gif_ptr->app_data_size);
- FXSYS_memcpy(gif_ptr->app_data, const uint8_t*(gif_ae_data_str),
- gif_ptr->app_data_size);
- } break;
-#endif
-#ifdef GIF_SUPPORT_COMMENT_EXTENSION
case GIF_D_STATUS_EXT_CE: {
- if (_gif_read_data(gif_ptr, &data_size_ptr, 1) == NULL) {
+ if (gif_read_data(gif_ptr, &data_size_ptr, 1) == NULL) {
gif_ptr->skip_size = skip_size_org;
return 2;
}
gif_ptr->cmt_data_ptr->Empty();
while (*data_size_ptr != GIF_BLOCK_TERMINAL) {
uint8_t data_size = *data_size_ptr;
- if (_gif_read_data(gif_ptr, &data_ptr, *data_size_ptr) == NULL ||
- _gif_read_data(gif_ptr, &data_size_ptr, 1) == NULL) {
+ if (gif_read_data(gif_ptr, &data_ptr, *data_size_ptr) == NULL ||
+ gif_read_data(gif_ptr, &data_size_ptr, 1) == NULL) {
gif_ptr->skip_size = skip_size_org;
return 2;
}
@@ -733,33 +659,31 @@ int32_t _gif_decode_extension(gif_decompress_struct_p gif_ptr) {
CFX_ByteString((const FX_CHAR*)data_ptr, data_size);
}
} break;
-#endif
-#ifdef GIF_SUPPORT_PLAIN_TEXT_EXTENSION
case GIF_D_STATUS_EXT_PTE: {
ASSERT(sizeof(GifPTE) == 13);
GifPTE* gif_pte_ptr = NULL;
- if (_gif_read_data(gif_ptr, (uint8_t**)&gif_pte_ptr, 13) == NULL) {
+ if (gif_read_data(gif_ptr, (uint8_t**)&gif_pte_ptr, 13) == NULL) {
return 2;
}
GifPlainText* gif_pt_ptr = FX_Alloc(GifPlainText, 1);
FXSYS_memset(gif_pt_ptr, 0, sizeof(GifPlainText));
- _gif_takeover_gce_ptr(gif_ptr, &gif_pt_ptr->gce_ptr);
+ gif_takeover_gce_ptr(gif_ptr, &gif_pt_ptr->gce_ptr);
gif_pt_ptr->pte_ptr = (GifPTE*)FX_Alloc(uint8_t, sizeof(GifPTE));
gif_pt_ptr->string_ptr = new CFX_ByteString;
gif_pt_ptr->pte_ptr->block_size = gif_pte_ptr->block_size;
gif_pt_ptr->pte_ptr->grid_left =
- _GetWord_LSBFirst((uint8_t*)&gif_pte_ptr->grid_left);
+ GetWord_LSBFirst((uint8_t*)&gif_pte_ptr->grid_left);
gif_pt_ptr->pte_ptr->grid_top =
- _GetWord_LSBFirst((uint8_t*)&gif_pte_ptr->grid_top);
+ GetWord_LSBFirst((uint8_t*)&gif_pte_ptr->grid_top);
gif_pt_ptr->pte_ptr->grid_width =
- _GetWord_LSBFirst((uint8_t*)&gif_pte_ptr->grid_width);
+ GetWord_LSBFirst((uint8_t*)&gif_pte_ptr->grid_width);
gif_pt_ptr->pte_ptr->grid_height =
- _GetWord_LSBFirst((uint8_t*)&gif_pte_ptr->grid_height);
+ GetWord_LSBFirst((uint8_t*)&gif_pte_ptr->grid_height);
gif_pt_ptr->pte_ptr->char_width = gif_pte_ptr->char_width;
gif_pt_ptr->pte_ptr->char_height = gif_pte_ptr->char_height;
gif_pt_ptr->pte_ptr->fc_index = gif_pte_ptr->fc_index;
gif_pt_ptr->pte_ptr->bc_index = gif_pte_ptr->bc_index;
- if (_gif_read_data(gif_ptr, &data_size_ptr, 1) == NULL) {
+ if (gif_read_data(gif_ptr, &data_size_ptr, 1) == NULL) {
gif_ptr->skip_size = skip_size_org;
if (gif_pt_ptr) {
FX_Free(gif_pt_ptr->gce_ptr);
@@ -771,8 +695,8 @@ int32_t _gif_decode_extension(gif_decompress_struct_p gif_ptr) {
}
while (*data_size_ptr != GIF_BLOCK_TERMINAL) {
uint8_t data_size = *data_size_ptr;
- if (_gif_read_data(gif_ptr, &data_ptr, *data_size_ptr) == NULL ||
- _gif_read_data(gif_ptr, &data_size_ptr, 1) == NULL) {
+ if (gif_read_data(gif_ptr, &data_ptr, *data_size_ptr) == NULL ||
+ gif_read_data(gif_ptr, &data_size_ptr, 1) == NULL) {
gif_ptr->skip_size = skip_size_org;
if (gif_pt_ptr) {
FX_Free(gif_pt_ptr->gce_ptr);
@@ -787,12 +711,10 @@ int32_t _gif_decode_extension(gif_decompress_struct_p gif_ptr) {
}
gif_ptr->pt_ptr_arr_ptr->Add(gif_pt_ptr);
} break;
-#endif
-#ifdef GIF_SUPPORT_GRAPHIC_CONTROL_EXTENSION
case GIF_D_STATUS_EXT_GCE: {
ASSERT(sizeof(GifGCE) == 5);
GifGCE* gif_gce_ptr = NULL;
- if (_gif_read_data(gif_ptr, (uint8_t**)&gif_gce_ptr, 6) == NULL) {
+ if (gif_read_data(gif_ptr, (uint8_t**)&gif_gce_ptr, 6) == NULL) {
return 2;
}
if (gif_ptr->gce_ptr == NULL) {
@@ -801,43 +723,38 @@ int32_t _gif_decode_extension(gif_decompress_struct_p gif_ptr) {
gif_ptr->gce_ptr->block_size = gif_gce_ptr->block_size;
gif_ptr->gce_ptr->gce_flag = gif_gce_ptr->gce_flag;
gif_ptr->gce_ptr->delay_time =
- _GetWord_LSBFirst((uint8_t*)&gif_gce_ptr->delay_time);
+ GetWord_LSBFirst((uint8_t*)&gif_gce_ptr->delay_time);
gif_ptr->gce_ptr->trans_index = gif_gce_ptr->trans_index;
} break;
-#endif
default: {
-#ifndef GIF_SUPPORT_PLAIN_TEXT_EXTENSION
-#ifdef GIF_SUPPORT_GRAPHIC_CONTROL_EXTENSION
if (gif_ptr->decode_status == GIF_D_STATUS_EXT_PTE) {
FX_Free(gif_ptr->gce_ptr);
gif_ptr->gce_ptr = NULL;
}
-#endif
-#endif
- if (_gif_read_data(gif_ptr, &data_size_ptr, 1) == NULL) {
+ if (gif_read_data(gif_ptr, &data_size_ptr, 1) == NULL) {
return 2;
}
while (*data_size_ptr != GIF_BLOCK_TERMINAL) {
- if (_gif_read_data(gif_ptr, &data_ptr, *data_size_ptr) == NULL ||
- _gif_read_data(gif_ptr, &data_size_ptr, 1) == NULL) {
+ if (gif_read_data(gif_ptr, &data_ptr, *data_size_ptr) == NULL ||
+ gif_read_data(gif_ptr, &data_size_ptr, 1) == NULL) {
gif_ptr->skip_size = skip_size_org;
return 2;
}
}
}
}
- _gif_save_decoding_status(gif_ptr, GIF_D_STATUS_SIG);
+ gif_save_decoding_status(gif_ptr, GIF_D_STATUS_SIG);
return 1;
}
-int32_t _gif_decode_image_info(gif_decompress_struct_p gif_ptr) {
+int32_t gif_decode_image_info(gif_decompress_struct_p gif_ptr) {
if (gif_ptr->width == 0 || gif_ptr->height == 0) {
- _gif_error(gif_ptr, "No Image Header Info");
+ gif_error(gif_ptr, "No Image Header Info");
return 0;
}
FX_DWORD skip_size_org = gif_ptr->skip_size;
ASSERT(sizeof(GifImageInfo) == 9);
GifImageInfo* gif_img_info_ptr = NULL;
- if (_gif_read_data(gif_ptr, (uint8_t**)&gif_img_info_ptr, 9) == NULL) {
+ if (gif_read_data(gif_ptr, (uint8_t**)&gif_img_info_ptr, 9) == NULL) {
return 2;
}
GifImage* gif_image_ptr = (GifImage*)FX_Alloc(uint8_t, sizeof(GifImage));
@@ -845,13 +762,13 @@ int32_t _gif_decode_image_info(gif_decompress_struct_p gif_ptr) {
gif_image_ptr->image_info_ptr =
(GifImageInfo*)FX_Alloc(uint8_t, sizeof(GifImageInfo));
gif_image_ptr->image_info_ptr->left =
- _GetWord_LSBFirst((uint8_t*)&gif_img_info_ptr->left);
+ GetWord_LSBFirst((uint8_t*)&gif_img_info_ptr->left);
gif_image_ptr->image_info_ptr->top =
- _GetWord_LSBFirst((uint8_t*)&gif_img_info_ptr->top);
+ GetWord_LSBFirst((uint8_t*)&gif_img_info_ptr->top);
gif_image_ptr->image_info_ptr->width =
- _GetWord_LSBFirst((uint8_t*)&gif_img_info_ptr->width);
+ GetWord_LSBFirst((uint8_t*)&gif_img_info_ptr->width);
gif_image_ptr->image_info_ptr->height =
- _GetWord_LSBFirst((uint8_t*)&gif_img_info_ptr->height);
+ GetWord_LSBFirst((uint8_t*)&gif_img_info_ptr->height);
gif_image_ptr->image_info_ptr->local_flag = gif_img_info_ptr->local_flag;
if (gif_image_ptr->image_info_ptr->left +
gif_image_ptr->image_info_ptr->width >
@@ -862,7 +779,7 @@ int32_t _gif_decode_image_info(gif_decompress_struct_p gif_ptr) {
FX_Free(gif_image_ptr->image_info_ptr);
FX_Free(gif_image_ptr->image_row_buf);
FX_Free(gif_image_ptr);
- _gif_error(gif_ptr, "Image Data Out Of LSD, The File May Be Corrupt");
+ gif_error(gif_ptr, "Image Data Out Of LSD, The File May Be Corrupt");
return 0;
}
GifLF* gif_img_info_lf_ptr = (GifLF*)&gif_img_info_ptr->local_flag;
@@ -870,7 +787,7 @@ int32_t _gif_decode_image_info(gif_decompress_struct_p gif_ptr) {
ASSERT(sizeof(GifPalette) == 3);
int32_t loc_pal_size = (2 << gif_img_info_lf_ptr->pal_bits) * 3;
uint8_t* loc_pal_ptr = NULL;
- if (_gif_read_data(gif_ptr, &loc_pal_ptr, loc_pal_size) == NULL) {
+ if (gif_read_data(gif_ptr, &loc_pal_ptr, loc_pal_size) == NULL) {
gif_ptr->skip_size = skip_size_org;
FX_Free(gif_image_ptr->image_info_ptr);
FX_Free(gif_image_ptr->image_row_buf);
@@ -878,14 +795,14 @@ int32_t _gif_decode_image_info(gif_decompress_struct_p gif_ptr) {
return 2;
}
gif_image_ptr->local_pal_ptr =
- (GifPalette*)gif_ptr->_gif_ask_buf_for_pal_fn(gif_ptr, loc_pal_size);
+ (GifPalette*)gif_ptr->gif_ask_buf_for_pal_fn(gif_ptr, loc_pal_size);
if (gif_image_ptr->local_pal_ptr) {
FXSYS_memcpy((uint8_t*)gif_image_ptr->local_pal_ptr, loc_pal_ptr,
loc_pal_size);
}
}
uint8_t* code_size_ptr = NULL;
- if (_gif_read_data(gif_ptr, &code_size_ptr, 1) == NULL) {
+ if (gif_read_data(gif_ptr, &code_size_ptr, 1) == NULL) {
gif_ptr->skip_size = skip_size_org;
FX_Free(gif_image_ptr->image_info_ptr);
FX_Free(gif_image_ptr->local_pal_ptr);
@@ -894,15 +811,15 @@ int32_t _gif_decode_image_info(gif_decompress_struct_p gif_ptr) {
return 2;
}
gif_image_ptr->image_code_size = *code_size_ptr;
- gif_ptr->_gif_record_current_position_fn(gif_ptr,
- &gif_image_ptr->image_data_pos);
+ gif_ptr->gif_record_current_position_fn(gif_ptr,
+ &gif_image_ptr->image_data_pos);
gif_image_ptr->image_data_pos += gif_ptr->skip_size;
- _gif_takeover_gce_ptr(gif_ptr, &gif_image_ptr->image_gce_ptr);
+ gif_takeover_gce_ptr(gif_ptr, &gif_image_ptr->image_gce_ptr);
gif_ptr->img_ptr_arr_ptr->Add(gif_image_ptr);
- _gif_save_decoding_status(gif_ptr, GIF_D_STATUS_IMG_DATA);
+ gif_save_decoding_status(gif_ptr, GIF_D_STATUS_IMG_DATA);
return 1;
}
-int32_t _gif_load_frame(gif_decompress_struct_p gif_ptr, int32_t frame_num) {
+int32_t gif_load_frame(gif_decompress_struct_p gif_ptr, int32_t frame_num) {
if (gif_ptr == NULL || frame_num < 0 ||
frame_num >= gif_ptr->img_ptr_arr_ptr->GetSize()) {
return 0;
@@ -926,7 +843,7 @@ int32_t _gif_load_frame(gif_decompress_struct_p gif_ptr, int32_t frame_num) {
: 0;
gif_ptr->avail_in = 0;
if (gif_img_gce_ptr == NULL) {
- FX_BOOL bRes = gif_ptr->_gif_get_record_position_fn(
+ FX_BOOL bRes = gif_ptr->gif_get_record_position_fn(
gif_ptr, gif_image_ptr->image_data_pos,
gif_image_ptr->image_info_ptr->left,
gif_image_ptr->image_info_ptr->top,
@@ -938,11 +855,11 @@ int32_t _gif_load_frame(gif_decompress_struct_p gif_ptr, int32_t frame_num) {
if (!bRes) {
FX_Free(gif_image_ptr->image_row_buf);
gif_image_ptr->image_row_buf = NULL;
- _gif_error(gif_ptr, "Error Read Record Position Data");
+ gif_error(gif_ptr, "Error Read Record Position Data");
return 0;
}
} else {
- FX_BOOL bRes = gif_ptr->_gif_get_record_position_fn(
+ FX_BOOL bRes = gif_ptr->gif_get_record_position_fn(
gif_ptr, gif_image_ptr->image_data_pos,
gif_image_ptr->image_info_ptr->left,
gif_image_ptr->image_info_ptr->top,
@@ -962,7 +879,7 @@ int32_t _gif_load_frame(gif_decompress_struct_p gif_ptr, int32_t frame_num) {
if (!bRes) {
FX_Free(gif_image_ptr->image_row_buf);
gif_image_ptr->image_row_buf = NULL;
- _gif_error(gif_ptr, "Error Read Record Position Data");
+ gif_error(gif_ptr, "Error Read Record Position Data");
return 0;
}
}
@@ -974,20 +891,20 @@ int32_t _gif_load_frame(gif_decompress_struct_p gif_ptr, int32_t frame_num) {
gif_ptr->img_row_avail_size = 0;
gif_ptr->img_pass_num = 0;
gif_image_ptr->image_row_num = 0;
- _gif_save_decoding_status(gif_ptr, GIF_D_STATUS_IMG_DATA);
+ gif_save_decoding_status(gif_ptr, GIF_D_STATUS_IMG_DATA);
}
CGifLZWDecoder* img_decoder_ptr = gif_ptr->img_decoder_ptr;
if (gif_ptr->decode_status == GIF_D_STATUS_IMG_DATA) {
- if (_gif_read_data(gif_ptr, &data_size_ptr, 1) == NULL) {
+ if (gif_read_data(gif_ptr, &data_size_ptr, 1) == NULL) {
return 2;
}
if (*data_size_ptr != GIF_BLOCK_TERMINAL) {
- if (_gif_read_data(gif_ptr, &data_ptr, *data_size_ptr) == NULL) {
+ if (gif_read_data(gif_ptr, &data_ptr, *data_size_ptr) == NULL) {
gif_ptr->skip_size = skip_size_org;
return 2;
}
img_decoder_ptr->Input(data_ptr, *data_size_ptr);
- _gif_save_decoding_status(gif_ptr, GIF_D_STATUS_IMG_DATA);
+ gif_save_decoding_status(gif_ptr, GIF_D_STATUS_IMG_DATA);
gif_ptr->img_row_offset += gif_ptr->img_row_avail_size;
gif_ptr->img_row_avail_size = gif_img_row_bytes - gif_ptr->img_row_offset;
int32_t ret = img_decoder_ptr->Decode(
@@ -996,32 +913,32 @@ int32_t _gif_load_frame(gif_decompress_struct_p gif_ptr, int32_t frame_num) {
if (ret == 0) {
FX_Free(gif_image_ptr->image_row_buf);
gif_image_ptr->image_row_buf = NULL;
- _gif_save_decoding_status(gif_ptr, GIF_D_STATUS_TAIL);
- _gif_error(gif_ptr, "Decode Image Data Error");
+ gif_save_decoding_status(gif_ptr, GIF_D_STATUS_TAIL);
+ gif_error(gif_ptr, "Decode Image Data Error");
return 0;
}
while (ret != 0) {
if (ret == 1) {
- gif_ptr->_gif_get_row_fn(gif_ptr, gif_image_ptr->image_row_num,
- gif_image_ptr->image_row_buf);
+ gif_ptr->gif_get_row_fn(gif_ptr, gif_image_ptr->image_row_num,
+ gif_image_ptr->image_row_buf);
FX_Free(gif_image_ptr->image_row_buf);
gif_image_ptr->image_row_buf = NULL;
- _gif_save_decoding_status(gif_ptr, GIF_D_STATUS_TAIL);
+ gif_save_decoding_status(gif_ptr, GIF_D_STATUS_TAIL);
return 1;
}
if (ret == 2) {
ASSERT(img_decoder_ptr->GetAvailInput() == 0);
skip_size_org = gif_ptr->skip_size;
- if (_gif_read_data(gif_ptr, &data_size_ptr, 1) == NULL) {
+ if (gif_read_data(gif_ptr, &data_size_ptr, 1) == NULL) {
return 2;
}
if (*data_size_ptr != GIF_BLOCK_TERMINAL) {
- if (_gif_read_data(gif_ptr, &data_ptr, *data_size_ptr) == NULL) {
+ if (gif_read_data(gif_ptr, &data_ptr, *data_size_ptr) == NULL) {
gif_ptr->skip_size = skip_size_org;
return 2;
}
img_decoder_ptr->Input(data_ptr, *data_size_ptr);
- _gif_save_decoding_status(gif_ptr, GIF_D_STATUS_IMG_DATA);
+ gif_save_decoding_status(gif_ptr, GIF_D_STATUS_IMG_DATA);
gif_ptr->img_row_offset += gif_ptr->img_row_avail_size;
gif_ptr->img_row_avail_size =
gif_img_row_bytes - gif_ptr->img_row_offset;
@@ -1032,8 +949,8 @@ int32_t _gif_load_frame(gif_decompress_struct_p gif_ptr, int32_t frame_num) {
}
if (ret == 3) {
if (((GifLF*)&gif_image_ptr->image_info_ptr->local_flag)->interlace) {
- gif_ptr->_gif_get_row_fn(gif_ptr, gif_image_ptr->image_row_num,
- gif_image_ptr->image_row_buf);
+ gif_ptr->gif_get_row_fn(gif_ptr, gif_image_ptr->image_row_num,
+ gif_image_ptr->image_row_buf);
gif_image_ptr->image_row_num +=
s_gif_interlace_step[gif_ptr->img_pass_num];
if (gif_image_ptr->image_row_num >=
@@ -1043,8 +960,8 @@ int32_t _gif_load_frame(gif_decompress_struct_p gif_ptr, int32_t frame_num) {
s_gif_interlace_step[gif_ptr->img_pass_num] / 2;
}
} else {
- gif_ptr->_gif_get_row_fn(gif_ptr, gif_image_ptr->image_row_num++,
- gif_image_ptr->image_row_buf);
+ gif_ptr->gif_get_row_fn(gif_ptr, gif_image_ptr->image_row_num++,
+ gif_image_ptr->image_row_buf);
}
gif_ptr->img_row_offset = 0;
gif_ptr->img_row_avail_size = gif_img_row_bytes;
@@ -1055,27 +972,26 @@ int32_t _gif_load_frame(gif_decompress_struct_p gif_ptr, int32_t frame_num) {
if (ret == 0) {
FX_Free(gif_image_ptr->image_row_buf);
gif_image_ptr->image_row_buf = NULL;
- _gif_save_decoding_status(gif_ptr, GIF_D_STATUS_TAIL);
- _gif_error(gif_ptr, "Decode Image Data Error");
+ gif_save_decoding_status(gif_ptr, GIF_D_STATUS_TAIL);
+ gif_error(gif_ptr, "Decode Image Data Error");
return 0;
}
}
}
- _gif_save_decoding_status(gif_ptr, GIF_D_STATUS_TAIL);
+ gif_save_decoding_status(gif_ptr, GIF_D_STATUS_TAIL);
}
- _gif_error(gif_ptr, "Decode Image Data Error");
+ gif_error(gif_ptr, "Decode Image Data Error");
return 0;
}
-void _gif_save_decoding_status(gif_decompress_struct_p gif_ptr,
- int32_t status) {
+void gif_save_decoding_status(gif_decompress_struct_p gif_ptr, int32_t status) {
gif_ptr->decode_status = status;
gif_ptr->next_in += gif_ptr->skip_size;
gif_ptr->avail_in -= gif_ptr->skip_size;
gif_ptr->skip_size = 0;
}
-uint8_t* _gif_read_data(gif_decompress_struct_p gif_ptr,
- uint8_t** des_buf_pp,
- FX_DWORD data_size) {
+uint8_t* gif_read_data(gif_decompress_struct_p gif_ptr,
+ uint8_t** des_buf_pp,
+ FX_DWORD data_size) {
if (gif_ptr == NULL || gif_ptr->avail_in < gif_ptr->skip_size + data_size) {
return NULL;
}
@@ -1083,15 +999,15 @@ uint8_t* _gif_read_data(gif_decompress_struct_p gif_ptr,
gif_ptr->skip_size += data_size;
return *des_buf_pp;
}
-void _gif_input_buffer(gif_decompress_struct_p gif_ptr,
- uint8_t* src_buf,
- FX_DWORD src_size) {
+void gif_input_buffer(gif_decompress_struct_p gif_ptr,
+ uint8_t* src_buf,
+ FX_DWORD src_size) {
gif_ptr->next_in = src_buf;
gif_ptr->avail_in = src_size;
gif_ptr->skip_size = 0;
}
-FX_DWORD _gif_get_avail_input(gif_decompress_struct_p gif_ptr,
- uint8_t** avial_buf_ptr) {
+FX_DWORD gif_get_avail_input(gif_decompress_struct_p gif_ptr,
+ uint8_t** avial_buf_ptr) {
if (avial_buf_ptr) {
*avial_buf_ptr = NULL;
if (gif_ptr->avail_in > 0) {
@@ -1100,12 +1016,12 @@ FX_DWORD _gif_get_avail_input(gif_decompress_struct_p gif_ptr,
}
return gif_ptr->avail_in;
}
-int32_t _gif_get_frame_num(gif_decompress_struct_p gif_ptr) {
+int32_t gif_get_frame_num(gif_decompress_struct_p gif_ptr) {
return gif_ptr->img_ptr_arr_ptr->GetSize();
}
-static FX_BOOL _gif_write_header(gif_compress_struct_p gif_ptr,
- uint8_t*& dst_buf,
- FX_DWORD& dst_len) {
+static FX_BOOL gif_write_header(gif_compress_struct_p gif_ptr,
+ uint8_t*& dst_buf,
+ FX_DWORD& dst_len) {
if (gif_ptr->cur_offset) {
return TRUE;
}
@@ -1117,16 +1033,16 @@ static FX_BOOL _gif_write_header(gif_compress_struct_p gif_ptr,
FXSYS_memset(dst_buf, 0, dst_len);
FXSYS_memcpy(dst_buf, gif_ptr->header_ptr, sizeof(GifHeader));
gif_ptr->cur_offset += sizeof(GifHeader);
- _SetWord_LSBFirst(dst_buf + gif_ptr->cur_offset, gif_ptr->lsd_ptr->width);
+ SetWord_LSBFirst(dst_buf + gif_ptr->cur_offset, gif_ptr->lsd_ptr->width);
gif_ptr->cur_offset += 2;
- _SetWord_LSBFirst(dst_buf + gif_ptr->cur_offset, gif_ptr->lsd_ptr->height);
+ SetWord_LSBFirst(dst_buf + gif_ptr->cur_offset, gif_ptr->lsd_ptr->height);
gif_ptr->cur_offset += 2;
dst_buf[gif_ptr->cur_offset++] = gif_ptr->lsd_ptr->global_flag;
dst_buf[gif_ptr->cur_offset++] = gif_ptr->lsd_ptr->bc_index;
dst_buf[gif_ptr->cur_offset++] = gif_ptr->lsd_ptr->pixel_aspect;
if (gif_ptr->global_pal) {
FX_WORD size = sizeof(GifPalette) * gif_ptr->gpal_num;
- if (!_gif_grow_buf(dst_buf, dst_len, gif_ptr->cur_offset + size)) {
+ if (!gif_grow_buf(dst_buf, dst_len, gif_ptr->cur_offset + size)) {
return FALSE;
}
FXSYS_memcpy(&dst_buf[gif_ptr->cur_offset], gif_ptr->global_pal, size);
@@ -1165,11 +1081,11 @@ void interlace_buf(const uint8_t* buf, FX_DWORD pitch, FX_DWORD height) {
}
}
}
-static void _gif_write_block_data(const uint8_t* src_buf,
- FX_DWORD src_len,
- uint8_t*& dst_buf,
- FX_DWORD& dst_len,
- FX_DWORD& dst_offset) {
+static void gif_write_block_data(const uint8_t* src_buf,
+ FX_DWORD src_len,
+ uint8_t*& dst_buf,
+ FX_DWORD& dst_len,
+ FX_DWORD& dst_offset) {
FX_DWORD src_offset = 0;
while (src_len > GIF_DATA_BLOCK) {
dst_buf[dst_offset++] = GIF_DATA_BLOCK;
@@ -1182,13 +1098,12 @@ static void _gif_write_block_data(const uint8_t* src_buf,
FXSYS_memcpy(&dst_buf[dst_offset], &src_buf[src_offset], src_len);
dst_offset += src_len;
}
-static FX_BOOL _gif_write_data(gif_compress_struct_p gif_ptr,
- uint8_t*& dst_buf,
- FX_DWORD& dst_len) {
- if (!_gif_grow_buf(dst_buf, dst_len, gif_ptr->cur_offset + GIF_DATA_BLOCK)) {
+static FX_BOOL gif_write_data(gif_compress_struct_p gif_ptr,
+ uint8_t*& dst_buf,
+ FX_DWORD& dst_len) {
+ if (!gif_grow_buf(dst_buf, dst_len, gif_ptr->cur_offset + GIF_DATA_BLOCK)) {
return FALSE;
}
-#ifdef GIF_SUPPORT_GRAPHIC_CONTROL_EXTENSION
if (FXSYS_memcmp(gif_ptr->header_ptr->version, "89a", 3) == 0) {
dst_buf[gif_ptr->cur_offset++] = GIF_SIG_EXTENSION;
dst_buf[gif_ptr->cur_offset++] = GIF_BLOCK_GCE;
@@ -1197,32 +1112,30 @@ static FX_BOOL _gif_write_data(gif_compress_struct_p gif_ptr,
gif_ptr->gce_ptr->gce_flag = 0;
dst_buf[gif_ptr->cur_offset++] = gif_ptr->gce_ptr->gce_flag;
gif_ptr->gce_ptr->delay_time = 10;
- _SetWord_LSBFirst(dst_buf + gif_ptr->cur_offset,
- gif_ptr->gce_ptr->delay_time);
+ SetWord_LSBFirst(dst_buf + gif_ptr->cur_offset,
+ gif_ptr->gce_ptr->delay_time);
gif_ptr->cur_offset += 2;
gif_ptr->gce_ptr->trans_index = 0;
dst_buf[gif_ptr->cur_offset++] = gif_ptr->gce_ptr->trans_index;
dst_buf[gif_ptr->cur_offset++] = 0;
}
-#endif
dst_buf[gif_ptr->cur_offset++] = GIF_SIG_IMAGE;
- _SetWord_LSBFirst(dst_buf + gif_ptr->cur_offset,
- gif_ptr->image_info_ptr->left);
+ SetWord_LSBFirst(dst_buf + gif_ptr->cur_offset,
+ gif_ptr->image_info_ptr->left);
gif_ptr->cur_offset += 2;
- _SetWord_LSBFirst(dst_buf + gif_ptr->cur_offset,
- gif_ptr->image_info_ptr->top);
+ SetWord_LSBFirst(dst_buf + gif_ptr->cur_offset, gif_ptr->image_info_ptr->top);
gif_ptr->cur_offset += 2;
- _SetWord_LSBFirst(dst_buf + gif_ptr->cur_offset,
- gif_ptr->image_info_ptr->width);
+ SetWord_LSBFirst(dst_buf + gif_ptr->cur_offset,
+ gif_ptr->image_info_ptr->width);
gif_ptr->cur_offset += 2;
- _SetWord_LSBFirst(dst_buf + gif_ptr->cur_offset,
- gif_ptr->image_info_ptr->height);
+ SetWord_LSBFirst(dst_buf + gif_ptr->cur_offset,
+ gif_ptr->image_info_ptr->height);
gif_ptr->cur_offset += 2;
GifLF& lf = (GifLF&)gif_ptr->image_info_ptr->local_flag;
dst_buf[gif_ptr->cur_offset++] = gif_ptr->image_info_ptr->local_flag;
if (gif_ptr->local_pal) {
FX_DWORD pal_size = sizeof(GifPalette) * gif_ptr->lpal_num;
- if (!_gif_grow_buf(dst_buf, dst_len, pal_size + gif_ptr->cur_offset)) {
+ if (!gif_grow_buf(dst_buf, dst_len, pal_size + gif_ptr->cur_offset)) {
return FALSE;
}
FXSYS_memcpy(&dst_buf[gif_ptr->cur_offset], gif_ptr->local_pal, pal_size);
@@ -1250,75 +1163,52 @@ static FX_BOOL _gif_write_data(gif_compress_struct_p gif_ptr,
}
gif_ptr->img_encoder_ptr->Finish(dst_buf, dst_len, gif_ptr->cur_offset);
dst_buf[gif_ptr->cur_offset++] = 0;
-#ifdef GIF_SUPPORT_COMMENT_EXTENSION
if (FXSYS_memcmp(gif_ptr->header_ptr->version, "89a", 3) == 0 &&
gif_ptr->cmt_data_ptr) {
dst_buf[gif_ptr->cur_offset++] = GIF_SIG_EXTENSION;
dst_buf[gif_ptr->cur_offset++] = GIF_BLOCK_CE;
- _gif_write_block_data(gif_ptr->cmt_data_ptr, gif_ptr->cmt_data_len, dst_buf,
- dst_len, gif_ptr->cur_offset);
+ gif_write_block_data(gif_ptr->cmt_data_ptr, gif_ptr->cmt_data_len, dst_buf,
+ dst_len, gif_ptr->cur_offset);
dst_buf[gif_ptr->cur_offset++] = 0;
}
-#endif
-#ifdef GIF_SUPPORT_PLAIN_TEXT_EXTENSION
if (FXSYS_memcmp(gif_ptr->header_ptr->version, "89a", 3) == 0 &&
gif_ptr->pte_data_ptr) {
dst_buf[gif_ptr->cur_offset++] = GIF_SIG_EXTENSION;
dst_buf[gif_ptr->cur_offset++] = GIF_BLOCK_PTE;
dst_buf[gif_ptr->cur_offset++] = gif_ptr->pte_ptr->block_size;
- _SetWord_LSBFirst(dst_buf + gif_ptr->cur_offset,
- gif_ptr->pte_ptr->grid_left);
+ SetWord_LSBFirst(dst_buf + gif_ptr->cur_offset,
+ gif_ptr->pte_ptr->grid_left);
gif_ptr->cur_offset += 2;
- _SetWord_LSBFirst(dst_buf + gif_ptr->cur_offset,
- gif_ptr->pte_ptr->grid_top);
+ SetWord_LSBFirst(dst_buf + gif_ptr->cur_offset, gif_ptr->pte_ptr->grid_top);
gif_ptr->cur_offset += 2;
- _SetWord_LSBFirst(dst_buf + gif_ptr->cur_offset,
- gif_ptr->pte_ptr->grid_width);
+ SetWord_LSBFirst(dst_buf + gif_ptr->cur_offset,
+ gif_ptr->pte_ptr->grid_width);
gif_ptr->cur_offset += 2;
- _SetWord_LSBFirst(dst_buf + gif_ptr->cur_offset,
- gif_ptr->pte_ptr->grid_height);
+ SetWord_LSBFirst(dst_buf + gif_ptr->cur_offset,
+ gif_ptr->pte_ptr->grid_height);
gif_ptr->cur_offset += 2;
- _SetWord_LSBFirst(dst_buf + gif_ptr->cur_offset,
- gif_ptr->pte_ptr->char_width);
+ SetWord_LSBFirst(dst_buf + gif_ptr->cur_offset,
+ gif_ptr->pte_ptr->char_width);
gif_ptr->cur_offset += 2;
- _SetWord_LSBFirst(dst_buf + gif_ptr->cur_offset,
- gif_ptr->pte_ptr->char_height);
+ SetWord_LSBFirst(dst_buf + gif_ptr->cur_offset,
+ gif_ptr->pte_ptr->char_height);
gif_ptr->cur_offset += 2;
- _SetWord_LSBFirst(dst_buf + gif_ptr->cur_offset,
- gif_ptr->pte_ptr->fc_index);
+ SetWord_LSBFirst(dst_buf + gif_ptr->cur_offset, gif_ptr->pte_ptr->fc_index);
gif_ptr->cur_offset += 2;
- _SetWord_LSBFirst(dst_buf + gif_ptr->cur_offset,
- gif_ptr->pte_ptr->bc_index);
+ SetWord_LSBFirst(dst_buf + gif_ptr->cur_offset, gif_ptr->pte_ptr->bc_index);
gif_ptr->cur_offset += 2;
- _gif_write_block_data(gif_ptr->pte_data_ptr, gif_ptr->pte_data_len, dst_buf,
- dst_len, gif_ptr->cur_offset);
+ gif_write_block_data(gif_ptr->pte_data_ptr, gif_ptr->pte_data_len, dst_buf,
+ dst_len, gif_ptr->cur_offset);
gif_ptr->cur_offset += gif_ptr->pte_data_len;
dst_buf[gif_ptr->cur_offset++] = 0;
}
-#endif
-#ifdef GIF_SUPPORT_APPLICATION_EXTENSION
- if (FXSYS_memcmp(gif_ptr->header_ptr->version, "89a", 3) == 0 &&
- gif_ptr->app_data) {
- dst_buf[gif_ptr->cur_offset++] = GIF_SIG_EXTENSION;
- dst_buf[gif_ptr->cur_offset++] = GIF_BLOCK_AE;
- dst_buf[gif_ptr->cur_offset++] = 11;
- FXSYS_memcpy(&dst_buf[gif_ptr->cur_offset], gif_ptr->app_identify, 8);
- gif_ptr->cur_offset += 8;
- FXSYS_memcpy(&dst_buf[gif_ptr->cur_offset], gif_ptr->app_authentication, 8);
- gif_ptr->cur_offset += 3;
- FXSYS_memcpy(&dst_buf[gif_ptr->cur_offset], gif_ptr->app_data,
- gif_ptr->app_data_size);
- gif_ptr->cur_offset += gif_ptr->app_data_size;
- dst_buf[gif_ptr->cur_offset++] = 0;
- }
-#endif
dst_buf[gif_ptr->cur_offset++] = GIF_SIG_TRAILER;
return TRUE;
}
-FX_BOOL _gif_encode(gif_compress_struct_p gif_ptr,
- uint8_t*& dst_buf,
- FX_DWORD& dst_len) {
- if (!_gif_write_header(gif_ptr, dst_buf, dst_len)) {
+FX_BOOL gif_encode(gif_compress_struct_p gif_ptr,
+ uint8_t*& dst_buf,
+ FX_DWORD& dst_len) {
+ if (!gif_write_header(gif_ptr, dst_buf, dst_len)) {
return FALSE;
}
FX_DWORD cur_offset = gif_ptr->cur_offset;
@@ -1326,7 +1216,7 @@ FX_BOOL _gif_encode(gif_compress_struct_p gif_ptr,
if (gif_ptr->frames) {
gif_ptr->cur_offset--;
}
- if (!_gif_write_data(gif_ptr, dst_buf, dst_len)) {
+ if (!gif_write_data(gif_ptr, dst_buf, dst_len)) {
gif_ptr->cur_offset = cur_offset;
res = FALSE;
}
diff --git a/core/src/fxcodec/lgif/fx_gif.h b/core/src/fxcodec/lgif/fx_gif.h
index 19e21751d6..32300a50e5 100644
--- a/core/src/fxcodec/lgif/fx_gif.h
+++ b/core/src/fxcodec/lgif/fx_gif.h
@@ -11,17 +11,6 @@
#include "core/include/fxcrt/fx_basic.h"
-extern FX_WORD _GetWord_LSBFirst(uint8_t* p);
-extern void _SetWord_LSBFirst(uint8_t* p, FX_WORD v);
-extern void _BpcConvert(const uint8_t* src_buf,
- FX_DWORD src_len,
- int32_t src_bpc,
- int32_t dst_bpc,
- uint8_t*& dst_buf,
- FX_DWORD& dst_len);
-#define GIF_SUPPORT_COMMENT_EXTENSION
-#define GIF_SUPPORT_GRAPHIC_CONTROL_EXTENSION
-#define GIF_SUPPORT_PLAIN_TEXT_EXTENSION
#define GIF_SIGNATURE "GIF"
#define GIF_SIG_EXTENSION 0x21
#define GIF_SIG_IMAGE 0x2C
@@ -208,12 +197,11 @@ class CGifLZWEncoder {
typedef struct tag_gif_decompress_struct gif_decompress_struct;
typedef gif_decompress_struct* gif_decompress_struct_p;
typedef gif_decompress_struct_p* gif_decompress_struct_pp;
-static int32_t s_gif_interlace_step[4] = {8, 8, 4, 2};
+static const int32_t s_gif_interlace_step[4] = {8, 8, 4, 2};
struct tag_gif_decompress_struct {
jmp_buf jmpbuf;
FX_CHAR* err_ptr;
- void (*_gif_error_fn)(gif_decompress_struct_p gif_ptr,
- const FX_CHAR* err_msg);
+ void (*gif_error_fn)(gif_decompress_struct_p gif_ptr, const FX_CHAR* err_msg);
void* context_ptr;
int width;
int height;
@@ -229,38 +217,26 @@ struct tag_gif_decompress_struct {
FX_DWORD img_row_avail_size;
uint8_t img_pass_num;
CFX_ArrayTemplate<GifImage*>* img_ptr_arr_ptr;
- uint8_t* (*_gif_ask_buf_for_pal_fn)(gif_decompress_struct_p gif_ptr,
- int32_t pal_size);
+ uint8_t* (*gif_ask_buf_for_pal_fn)(gif_decompress_struct_p gif_ptr,
+ int32_t pal_size);
uint8_t* next_in;
FX_DWORD avail_in;
int32_t decode_status;
FX_DWORD skip_size;
- void (*_gif_record_current_position_fn)(gif_decompress_struct_p gif_ptr,
- FX_DWORD* cur_pos_ptr);
- void (*_gif_get_row_fn)(gif_decompress_struct_p gif_ptr,
- int32_t row_num,
- uint8_t* row_buf);
- FX_BOOL (*_gif_get_record_position_fn)(gif_decompress_struct_p gif_ptr,
+ void (*gif_record_current_position_fn)(gif_decompress_struct_p gif_ptr,
+ FX_DWORD* cur_pos_ptr);
+ void (*gif_get_row_fn)(gif_decompress_struct_p gif_ptr,
+ int32_t row_num,
+ uint8_t* row_buf);
+ FX_BOOL (*gif_get_record_position_fn)(gif_decompress_struct_p gif_ptr,
FX_DWORD cur_pos,
int32_t left, int32_t top, int32_t width, int32_t height,
int32_t pal_num, void* pal_ptr,
int32_t delay_time, FX_BOOL user_input,
int32_t trans_index, int32_t disposal_method, FX_BOOL interlace);
-#ifdef GIF_SUPPORT_APPLICATION_EXTENSION
- uint8_t app_identify[8];
- uint8_t app_authentication[3];
- FX_DWORD app_data_size;
- uint8_t* app_data;
-#endif
-#ifdef GIF_SUPPORT_COMMENT_EXTENSION
CFX_ByteString* cmt_data_ptr;
-#endif
-#ifdef GIF_SUPPORT_GRAPHIC_CONTROL_EXTENSION
GifGCE* gce_ptr;
-#endif
-#ifdef GIF_SUPPORT_PLAIN_TEXT_EXTENSION
CFX_ArrayTemplate<GifPlainText*>* pt_ptr_arr_ptr;
-#endif
};
typedef struct tag_gif_compress_struct gif_compress_struct;
typedef gif_compress_struct* gif_compress_struct_p;
@@ -280,55 +256,41 @@ struct tag_gif_compress_struct {
FX_WORD lpal_num;
GifImageInfo* image_info_ptr;
CGifLZWEncoder* img_encoder_ptr;
-#ifdef GIF_SUPPORT_APPLICATION_EXTENSION
- uint8_t app_identify[8];
- uint8_t app_authentication[3];
- FX_DWORD app_data_size;
- uint8_t* app_data;
-#endif
-#ifdef GIF_SUPPORT_COMMENT_EXTENSION
uint8_t* cmt_data_ptr;
FX_DWORD cmt_data_len;
-#endif
-
-#ifdef GIF_SUPPORT_GRAPHIC_CONTROL_EXTENSION
GifGCE* gce_ptr;
-#endif
-
-#ifdef GIF_SUPPORT_PLAIN_TEXT_EXTENSION
GifPTE* pte_ptr;
const uint8_t* pte_data_ptr;
FX_DWORD pte_data_len;
-#endif
};
-void _gif_error(gif_decompress_struct_p gif_ptr, const FX_CHAR* err_msg);
-void _gif_warn(gif_decompress_struct_p gif_ptr, const FX_CHAR* err_msg);
-gif_decompress_struct_p _gif_create_decompress();
-void _gif_destroy_decompress(gif_decompress_struct_pp gif_ptr_ptr);
-gif_compress_struct_p _gif_create_compress();
-void _gif_destroy_compress(gif_compress_struct_pp gif_ptr_ptr);
-int32_t _gif_read_header(gif_decompress_struct_p gif_ptr);
-int32_t _gif_get_frame(gif_decompress_struct_p gif_ptr);
-int32_t _gif_get_frame_num(gif_decompress_struct_p gif_ptr);
-int32_t _gif_decode_extension(gif_decompress_struct_p gif_ptr);
-int32_t _gif_decode_image_info(gif_decompress_struct_p gif_ptr);
-void _gif_takeover_gce_ptr(gif_decompress_struct_p gif_ptr,
- GifGCE** gce_ptr_ptr);
-int32_t _gif_load_frame(gif_decompress_struct_p gif_ptr, int32_t frame_num);
-uint8_t* _gif_read_data(gif_decompress_struct_p gif_ptr,
- uint8_t** des_buf_pp,
- FX_DWORD data_size);
-void _gif_save_decoding_status(gif_decompress_struct_p gif_ptr, int32_t status);
-void _gif_input_buffer(gif_decompress_struct_p gif_ptr,
- uint8_t* src_buf,
- FX_DWORD src_size);
-FX_DWORD _gif_get_avail_input(gif_decompress_struct_p gif_ptr,
- uint8_t** avial_buf_ptr);
+void gif_error(gif_decompress_struct_p gif_ptr, const FX_CHAR* err_msg);
+void gif_warn(gif_decompress_struct_p gif_ptr, const FX_CHAR* err_msg);
+gif_decompress_struct_p gif_create_decompress();
+void gif_destroy_decompress(gif_decompress_struct_pp gif_ptr_ptr);
+gif_compress_struct_p gif_create_compress();
+void gif_destroy_compress(gif_compress_struct_pp gif_ptr_ptr);
+int32_t gif_read_header(gif_decompress_struct_p gif_ptr);
+int32_t gif_get_frame(gif_decompress_struct_p gif_ptr);
+int32_t gif_get_frame_num(gif_decompress_struct_p gif_ptr);
+int32_t gif_decode_extension(gif_decompress_struct_p gif_ptr);
+int32_t gif_decode_image_info(gif_decompress_struct_p gif_ptr);
+void gif_takeover_gce_ptr(gif_decompress_struct_p gif_ptr,
+ GifGCE** gce_ptr_ptr);
+int32_t gif_load_frame(gif_decompress_struct_p gif_ptr, int32_t frame_num);
+uint8_t* gif_read_data(gif_decompress_struct_p gif_ptr,
+ uint8_t** des_buf_pp,
+ FX_DWORD data_size);
+void gif_save_decoding_status(gif_decompress_struct_p gif_ptr, int32_t status);
+void gif_input_buffer(gif_decompress_struct_p gif_ptr,
+ uint8_t* src_buf,
+ FX_DWORD src_size);
+FX_DWORD gif_get_avail_input(gif_decompress_struct_p gif_ptr,
+ uint8_t** avial_buf_ptr);
void interlace_buf(const uint8_t* buf, FX_DWORD width, FX_DWORD height);
-FX_BOOL _gif_encode(gif_compress_struct_p gif_ptr,
- uint8_t*& dst_buf,
- FX_DWORD& dst_len);
+FX_BOOL gif_encode(gif_compress_struct_p gif_ptr,
+ uint8_t*& dst_buf,
+ FX_DWORD& dst_len);
#endif // CORE_SRC_FXCODEC_LGIF_FX_GIF_H_
diff --git a/core/src/fxge/dib/fx_dib_convert.cpp b/core/src/fxge/dib/fx_dib_convert.cpp
index d87b1f9a97..91ccfc109e 100644
--- a/core/src/fxge/dib/fx_dib_convert.cpp
+++ b/core/src/fxge/dib/fx_dib_convert.cpp
@@ -253,13 +253,13 @@ FX_BOOL CFX_Palette::BuildPalette(const CFX_DIBSource* pBitmap, int pal_type) {
_Obtain_Pal(m_aLut, m_cLut, m_pPalette, pal_type, win_mac_pal, m_lut);
return TRUE;
}
-FX_BOOL _ConvertBuffer_1bppMask2Gray(uint8_t* dest_buf,
- int dest_pitch,
- int width,
- int height,
- const CFX_DIBSource* pSrcBitmap,
- int src_left,
- int src_top) {
+FX_BOOL ConvertBuffer_1bppMask2Gray(uint8_t* dest_buf,
+ int dest_pitch,
+ int width,
+ int height,
+ const CFX_DIBSource* pSrcBitmap,
+ int src_left,
+ int src_top) {
uint8_t set_gray, reset_gray;
set_gray = 0xff;
reset_gray = 0x00;
@@ -276,13 +276,13 @@ FX_BOOL _ConvertBuffer_1bppMask2Gray(uint8_t* dest_buf,
}
return TRUE;
}
-FX_BOOL _ConvertBuffer_8bppMask2Gray(uint8_t* dest_buf,
- int dest_pitch,
- int width,
- int height,
- const CFX_DIBSource* pSrcBitmap,
- int src_left,
- int src_top) {
+FX_BOOL ConvertBuffer_8bppMask2Gray(uint8_t* dest_buf,
+ int dest_pitch,
+ int width,
+ int height,
+ const CFX_DIBSource* pSrcBitmap,
+ int src_left,
+ int src_top) {
for (int row = 0; row < height; row++) {
uint8_t* dest_scan = dest_buf + row * dest_pitch;
const uint8_t* src_scan = pSrcBitmap->GetScanline(src_top + row) + src_left;
@@ -290,14 +290,14 @@ FX_BOOL _ConvertBuffer_8bppMask2Gray(uint8_t* dest_buf,
}
return TRUE;
}
-FX_BOOL _ConvertBuffer_1bppPlt2Gray(uint8_t* dest_buf,
- int dest_pitch,
- int width,
- int height,
- const CFX_DIBSource* pSrcBitmap,
- int src_left,
- int src_top,
- void* pIccTransform) {
+FX_BOOL ConvertBuffer_1bppPlt2Gray(uint8_t* dest_buf,
+ int dest_pitch,
+ int width,
+ int height,
+ const CFX_DIBSource* pSrcBitmap,
+ int src_left,
+ int src_top,
+ void* pIccTransform) {
FX_DWORD* src_plt = pSrcBitmap->GetPalette();
uint8_t gray[2];
if (pIccTransform) {
@@ -352,14 +352,14 @@ FX_BOOL _ConvertBuffer_1bppPlt2Gray(uint8_t* dest_buf,
}
return TRUE;
}
-FX_BOOL _ConvertBuffer_8bppPlt2Gray(uint8_t* dest_buf,
- int dest_pitch,
- int width,
- int height,
- const CFX_DIBSource* pSrcBitmap,
- int src_left,
- int src_top,
- void* pIccTransform) {
+FX_BOOL ConvertBuffer_8bppPlt2Gray(uint8_t* dest_buf,
+ int dest_pitch,
+ int width,
+ int height,
+ const CFX_DIBSource* pSrcBitmap,
+ int src_left,
+ int src_top,
+ void* pIccTransform) {
FX_DWORD* src_plt = pSrcBitmap->GetPalette();
uint8_t gray[256];
if (pIccTransform) {
@@ -404,14 +404,14 @@ FX_BOOL _ConvertBuffer_8bppPlt2Gray(uint8_t* dest_buf,
}
return TRUE;
}
-FX_BOOL _ConvertBuffer_RgbOrCmyk2Gray(uint8_t* dest_buf,
- int dest_pitch,
- int width,
- int height,
- const CFX_DIBSource* pSrcBitmap,
- int src_left,
- int src_top,
- void* pIccTransform) {
+FX_BOOL ConvertBuffer_RgbOrCmyk2Gray(uint8_t* dest_buf,
+ int dest_pitch,
+ int width,
+ int height,
+ const CFX_DIBSource* pSrcBitmap,
+ int src_left,
+ int src_top,
+ void* pIccTransform) {
int Bpp = pSrcBitmap->GetBPP() / 8;
if (pIccTransform) {
ICodec_IccModule* pIccModule =
@@ -466,13 +466,13 @@ FX_BOOL _ConvertBuffer_RgbOrCmyk2Gray(uint8_t* dest_buf,
}
return TRUE;
}
-inline void _ConvertBuffer_IndexCopy(uint8_t* dest_buf,
- int dest_pitch,
- int width,
- int height,
- const CFX_DIBSource* pSrcBitmap,
- int src_left,
- int src_top) {
+inline void ConvertBuffer_IndexCopy(uint8_t* dest_buf,
+ int dest_pitch,
+ int width,
+ int height,
+ const CFX_DIBSource* pSrcBitmap,
+ int src_left,
+ int src_top) {
if (pSrcBitmap->GetBPP() == 1) {
for (int row = 0; row < height; row++) {
uint8_t* dest_scan = dest_buf + row * dest_pitch;
@@ -494,17 +494,17 @@ inline void _ConvertBuffer_IndexCopy(uint8_t* dest_buf,
}
}
}
-FX_BOOL _ConvertBuffer_Plt2PltRgb8(uint8_t* dest_buf,
- int dest_pitch,
- int width,
- int height,
- const CFX_DIBSource* pSrcBitmap,
- int src_left,
- int src_top,
- FX_DWORD* dst_plt,
- void* pIccTransform) {
- _ConvertBuffer_IndexCopy(dest_buf, dest_pitch, width, height, pSrcBitmap,
- src_left, src_top);
+FX_BOOL ConvertBuffer_Plt2PltRgb8(uint8_t* dest_buf,
+ int dest_pitch,
+ int width,
+ int height,
+ const CFX_DIBSource* pSrcBitmap,
+ int src_left,
+ int src_top,
+ FX_DWORD* dst_plt,
+ void* pIccTransform) {
+ ConvertBuffer_IndexCopy(dest_buf, dest_pitch, width, height, pSrcBitmap,
+ src_left, src_top);
FX_DWORD* src_plt = pSrcBitmap->GetPalette();
int plt_size = pSrcBitmap->GetPaletteSize();
if (pIccTransform) {
@@ -545,15 +545,14 @@ FX_BOOL _ConvertBuffer_Plt2PltRgb8(uint8_t* dest_buf,
}
return TRUE;
}
-inline FX_BOOL _ConvertBuffer_Rgb2PltRgb8_NoTransform(
- uint8_t* dest_buf,
- int dest_pitch,
- int width,
- int height,
- const CFX_DIBSource* pSrcBitmap,
- int src_left,
- int src_top,
- FX_DWORD* dst_plt) {
+FX_BOOL ConvertBuffer_Rgb2PltRgb8_NoTransform(uint8_t* dest_buf,
+ int dest_pitch,
+ int width,
+ int height,
+ const CFX_DIBSource* pSrcBitmap,
+ int src_left,
+ int src_top,
+ FX_DWORD* dst_plt) {
int bpp = pSrcBitmap->GetBPP() / 8;
int row, col;
CFX_Palette palette;
@@ -608,22 +607,16 @@ inline FX_BOOL _ConvertBuffer_Rgb2PltRgb8_NoTransform(
FXSYS_memcpy(dst_plt, pPalette, sizeof(FX_DWORD) * 256);
return TRUE;
}
-FX_BOOL _ConvertBuffer_Rgb2PltRgb8(uint8_t* dest_buf,
- int dest_pitch,
- int width,
- int height,
- const CFX_DIBSource* pSrcBitmap,
- int src_left,
- int src_top,
- FX_DWORD* dst_plt,
- void* pIccTransform) {
-#ifdef PDF_ENABLE_XFA
- ICodec_IccModule* pIccModule = NULL;
- if (pIccTransform) {
- pIccModule = CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
- }
-#endif // PDF_ENABLE_XFA
- FX_BOOL ret = _ConvertBuffer_Rgb2PltRgb8_NoTransform(
+FX_BOOL ConvertBuffer_Rgb2PltRgb8(uint8_t* dest_buf,
+ int dest_pitch,
+ int width,
+ int height,
+ const CFX_DIBSource* pSrcBitmap,
+ int src_left,
+ int src_top,
+ FX_DWORD* dst_plt,
+ void* pIccTransform) {
+ FX_BOOL ret = ConvertBuffer_Rgb2PltRgb8_NoTransform(
dest_buf, dest_pitch, width, height, pSrcBitmap, src_left, src_top,
dst_plt);
if (ret && pIccTransform) {
@@ -639,14 +632,14 @@ FX_BOOL _ConvertBuffer_Rgb2PltRgb8(uint8_t* dest_buf,
}
return ret;
}
-FX_BOOL _ConvertBuffer_1bppMask2Rgb(FXDIB_Format dst_format,
- uint8_t* dest_buf,
- int dest_pitch,
- int width,
- int height,
- const CFX_DIBSource* pSrcBitmap,
- int src_left,
- int src_top) {
+FX_BOOL ConvertBuffer_1bppMask2Rgb(FXDIB_Format dst_format,
+ uint8_t* dest_buf,
+ int dest_pitch,
+ int width,
+ int height,
+ const CFX_DIBSource* pSrcBitmap,
+ int src_left,
+ int src_top) {
int comps = (dst_format & 0xff) / 8;
uint8_t set_gray, reset_gray;
set_gray = 0xff;
@@ -669,14 +662,14 @@ FX_BOOL _ConvertBuffer_1bppMask2Rgb(FXDIB_Format dst_format,
}
return TRUE;
}
-FX_BOOL _ConvertBuffer_8bppMask2Rgb(FXDIB_Format dst_format,
- uint8_t* dest_buf,
- int dest_pitch,
- int width,
- int height,
- const CFX_DIBSource* pSrcBitmap,
- int src_left,
- int src_top) {
+FX_BOOL ConvertBuffer_8bppMask2Rgb(FXDIB_Format dst_format,
+ uint8_t* dest_buf,
+ int dest_pitch,
+ int width,
+ int height,
+ const CFX_DIBSource* pSrcBitmap,
+ int src_left,
+ int src_top) {
int comps = (dst_format & 0xff) / 8;
for (int row = 0; row < height; row++) {
uint8_t* dest_scan = dest_buf + row * dest_pitch;
@@ -692,15 +685,15 @@ FX_BOOL _ConvertBuffer_8bppMask2Rgb(FXDIB_Format dst_format,
}
return TRUE;
}
-FX_BOOL _ConvertBuffer_1bppPlt2Rgb(FXDIB_Format dst_format,
- uint8_t* dest_buf,
- int dest_pitch,
- int width,
- int height,
- const CFX_DIBSource* pSrcBitmap,
- int src_left,
- int src_top,
- void* pIccTransform) {
+FX_BOOL ConvertBuffer_1bppPlt2Rgb(FXDIB_Format dst_format,
+ uint8_t* dest_buf,
+ int dest_pitch,
+ int width,
+ int height,
+ const CFX_DIBSource* pSrcBitmap,
+ int src_left,
+ int src_top,
+ void* pIccTransform) {
int comps = (dst_format & 0xff) / 8;
FX_DWORD* src_plt = pSrcBitmap->GetPalette();
FX_DWORD plt[2];
@@ -751,15 +744,15 @@ FX_BOOL _ConvertBuffer_1bppPlt2Rgb(FXDIB_Format dst_format,
}
return TRUE;
}
-FX_BOOL _ConvertBuffer_8bppPlt2Rgb(FXDIB_Format dst_format,
- uint8_t* dest_buf,
- int dest_pitch,
- int width,
- int height,
- const CFX_DIBSource* pSrcBitmap,
- int src_left,
- int src_top,
- void* pIccTransform) {
+FX_BOOL ConvertBuffer_8bppPlt2Rgb(FXDIB_Format dst_format,
+ uint8_t* dest_buf,
+ int dest_pitch,
+ int width,
+ int height,
+ const CFX_DIBSource* pSrcBitmap,
+ int src_left,
+ int src_top,
+ void* pIccTransform) {
int comps = (dst_format & 0xff) / 8;
FX_DWORD* src_plt = pSrcBitmap->GetPalette();
FX_DWORD plt[256];
@@ -807,14 +800,14 @@ FX_BOOL _ConvertBuffer_8bppPlt2Rgb(FXDIB_Format dst_format,
}
return TRUE;
}
-FX_BOOL _ConvertBuffer_24bppRgb2Rgb24(uint8_t* dest_buf,
- int dest_pitch,
- int width,
- int height,
- const CFX_DIBSource* pSrcBitmap,
- int src_left,
- int src_top,
- void* pIccTransform) {
+FX_BOOL ConvertBuffer_24bppRgb2Rgb24(uint8_t* dest_buf,
+ int dest_pitch,
+ int width,
+ int height,
+ const CFX_DIBSource* pSrcBitmap,
+ int src_left,
+ int src_top,
+ void* pIccTransform) {
if (pIccTransform) {
ICodec_IccModule* pIccModule =
CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
@@ -834,14 +827,14 @@ FX_BOOL _ConvertBuffer_24bppRgb2Rgb24(uint8_t* dest_buf,
}
return TRUE;
}
-FX_BOOL _ConvertBuffer_32bppRgb2Rgb24(uint8_t* dest_buf,
- int dest_pitch,
- int width,
- int height,
- const CFX_DIBSource* pSrcBitmap,
- int src_left,
- int src_top,
- void* pIccTransform) {
+FX_BOOL ConvertBuffer_32bppRgb2Rgb24(uint8_t* dest_buf,
+ int dest_pitch,
+ int width,
+ int height,
+ const CFX_DIBSource* pSrcBitmap,
+ int src_left,
+ int src_top,
+ void* pIccTransform) {
for (int row = 0; row < height; row++) {
uint8_t* dest_scan = dest_buf + row * dest_pitch;
const uint8_t* src_scan =
@@ -863,14 +856,14 @@ FX_BOOL _ConvertBuffer_32bppRgb2Rgb24(uint8_t* dest_buf,
}
return TRUE;
}
-FX_BOOL _ConvertBuffer_Rgb2Rgb32(uint8_t* dest_buf,
- int dest_pitch,
- int width,
- int height,
- const CFX_DIBSource* pSrcBitmap,
- int src_left,
- int src_top,
- void* pIccTransform) {
+FX_BOOL ConvertBuffer_Rgb2Rgb32(uint8_t* dest_buf,
+ int dest_pitch,
+ int width,
+ int height,
+ const CFX_DIBSource* pSrcBitmap,
+ int src_left,
+ int src_top,
+ void* pIccTransform) {
int comps = pSrcBitmap->GetBPP() / 8;
if (pIccTransform) {
ICodec_IccModule* pIccModule =
@@ -901,14 +894,14 @@ FX_BOOL _ConvertBuffer_Rgb2Rgb32(uint8_t* dest_buf,
}
return TRUE;
}
-FX_BOOL _ConvertBuffer_32bppCmyk2Rgb32(uint8_t* dest_buf,
- int dest_pitch,
- int width,
- int height,
- const CFX_DIBSource* pSrcBitmap,
- int src_left,
- int src_top,
- void* pIccTransform) {
+FX_BOOL ConvertBuffer_32bppCmyk2Rgb32(uint8_t* dest_buf,
+ int dest_pitch,
+ int width,
+ int height,
+ const CFX_DIBSource* pSrcBitmap,
+ int src_left,
+ int src_top,
+ void* pIccTransform) {
if (pIccTransform) {
ICodec_IccModule* pIccModule =
CFX_GEModule::Get()->GetCodecModule()->GetIccModule();
@@ -962,26 +955,26 @@ FX_BOOL ConvertBuffer(FXDIB_Format dest_format,
case FXDIB_8bppMask: {
if ((src_format & 0xff) == 1) {
if (pSrcBitmap->GetPalette()) {
- return _ConvertBuffer_1bppPlt2Gray(dest_buf, dest_pitch, width,
- height, pSrcBitmap, src_left,
- src_top, pIccTransform);
+ return ConvertBuffer_1bppPlt2Gray(dest_buf, dest_pitch, width, height,
+ pSrcBitmap, src_left, src_top,
+ pIccTransform);
}
- return _ConvertBuffer_1bppMask2Gray(dest_buf, dest_pitch, width, height,
- pSrcBitmap, src_left, src_top);
+ return ConvertBuffer_1bppMask2Gray(dest_buf, dest_pitch, width, height,
+ pSrcBitmap, src_left, src_top);
}
if ((src_format & 0xff) == 8) {
if (pSrcBitmap->GetPalette()) {
- return _ConvertBuffer_8bppPlt2Gray(dest_buf, dest_pitch, width,
- height, pSrcBitmap, src_left,
- src_top, pIccTransform);
+ return ConvertBuffer_8bppPlt2Gray(dest_buf, dest_pitch, width, height,
+ pSrcBitmap, src_left, src_top,
+ pIccTransform);
}
- return _ConvertBuffer_8bppMask2Gray(dest_buf, dest_pitch, width, height,
- pSrcBitmap, src_left, src_top);
+ return ConvertBuffer_8bppMask2Gray(dest_buf, dest_pitch, width, height,
+ pSrcBitmap, src_left, src_top);
}
if ((src_format & 0xff) >= 24) {
- return _ConvertBuffer_RgbOrCmyk2Gray(dest_buf, dest_pitch, width,
- height, pSrcBitmap, src_left,
- src_top, pIccTransform);
+ return ConvertBuffer_RgbOrCmyk2Gray(dest_buf, dest_pitch, width, height,
+ pSrcBitmap, src_left, src_top,
+ pIccTransform);
}
return FALSE;
}
@@ -995,14 +988,14 @@ FX_BOOL ConvertBuffer(FXDIB_Format dest_format,
d_pal = FX_Alloc(FX_DWORD, 256);
if (((src_format & 0xff) == 1 || (src_format & 0xff) == 8) &&
pSrcBitmap->GetPalette()) {
- return _ConvertBuffer_Plt2PltRgb8(dest_buf, dest_pitch, width, height,
- pSrcBitmap, src_left, src_top, d_pal,
- pIccTransform);
+ return ConvertBuffer_Plt2PltRgb8(dest_buf, dest_pitch, width, height,
+ pSrcBitmap, src_left, src_top, d_pal,
+ pIccTransform);
}
if ((src_format & 0xff) >= 24) {
- return _ConvertBuffer_Rgb2PltRgb8(dest_buf, dest_pitch, width, height,
- pSrcBitmap, src_left, src_top, d_pal,
- pIccTransform);
+ return ConvertBuffer_Rgb2PltRgb8(dest_buf, dest_pitch, width, height,
+ pSrcBitmap, src_left, src_top, d_pal,
+ pIccTransform);
}
return FALSE;
}
@@ -1010,33 +1003,33 @@ FX_BOOL ConvertBuffer(FXDIB_Format dest_format,
case FXDIB_Rgba: {
if ((src_format & 0xff) == 1) {
if (pSrcBitmap->GetPalette()) {
- return _ConvertBuffer_1bppPlt2Rgb(dest_format, dest_buf, dest_pitch,
- width, height, pSrcBitmap, src_left,
- src_top, pIccTransform);
- }
- return _ConvertBuffer_1bppMask2Rgb(dest_format, dest_buf, dest_pitch,
+ return ConvertBuffer_1bppPlt2Rgb(dest_format, dest_buf, dest_pitch,
width, height, pSrcBitmap, src_left,
- src_top);
+ src_top, pIccTransform);
+ }
+ return ConvertBuffer_1bppMask2Rgb(dest_format, dest_buf, dest_pitch,
+ width, height, pSrcBitmap, src_left,
+ src_top);
}
if ((src_format & 0xff) == 8) {
if (pSrcBitmap->GetPalette()) {
- return _ConvertBuffer_8bppPlt2Rgb(dest_format, dest_buf, dest_pitch,
- width, height, pSrcBitmap, src_left,
- src_top, pIccTransform);
- }
- return _ConvertBuffer_8bppMask2Rgb(dest_format, dest_buf, dest_pitch,
+ return ConvertBuffer_8bppPlt2Rgb(dest_format, dest_buf, dest_pitch,
width, height, pSrcBitmap, src_left,
- src_top);
+ src_top, pIccTransform);
+ }
+ return ConvertBuffer_8bppMask2Rgb(dest_format, dest_buf, dest_pitch,
+ width, height, pSrcBitmap, src_left,
+ src_top);
}
if ((src_format & 0xff) == 24) {
- return _ConvertBuffer_24bppRgb2Rgb24(dest_buf, dest_pitch, width,
- height, pSrcBitmap, src_left,
- src_top, pIccTransform);
+ return ConvertBuffer_24bppRgb2Rgb24(dest_buf, dest_pitch, width, height,
+ pSrcBitmap, src_left, src_top,
+ pIccTransform);
}
if ((src_format & 0xff) == 32) {
- return _ConvertBuffer_32bppRgb2Rgb24(dest_buf, dest_pitch, width,
- height, pSrcBitmap, src_left,
- src_top, pIccTransform);
+ return ConvertBuffer_32bppRgb2Rgb24(dest_buf, dest_pitch, width, height,
+ pSrcBitmap, src_left, src_top,
+ pIccTransform);
}
return FALSE;
}
@@ -1044,33 +1037,33 @@ FX_BOOL ConvertBuffer(FXDIB_Format dest_format,
case FXDIB_Rgb32: {
if ((src_format & 0xff) == 1) {
if (pSrcBitmap->GetPalette()) {
- return _ConvertBuffer_1bppPlt2Rgb(dest_format, dest_buf, dest_pitch,
- width, height, pSrcBitmap, src_left,
- src_top, pIccTransform);
- }
- return _ConvertBuffer_1bppMask2Rgb(dest_format, dest_buf, dest_pitch,
+ return ConvertBuffer_1bppPlt2Rgb(dest_format, dest_buf, dest_pitch,
width, height, pSrcBitmap, src_left,
- src_top);
+ src_top, pIccTransform);
+ }
+ return ConvertBuffer_1bppMask2Rgb(dest_format, dest_buf, dest_pitch,
+ width, height, pSrcBitmap, src_left,
+ src_top);
}
if ((src_format & 0xff) == 8) {
if (pSrcBitmap->GetPalette()) {
- return _ConvertBuffer_8bppPlt2Rgb(dest_format, dest_buf, dest_pitch,
- width, height, pSrcBitmap, src_left,
- src_top, pIccTransform);
- }
- return _ConvertBuffer_8bppMask2Rgb(dest_format, dest_buf, dest_pitch,
+ return ConvertBuffer_8bppPlt2Rgb(dest_format, dest_buf, dest_pitch,
width, height, pSrcBitmap, src_left,
- src_top);
+ src_top, pIccTransform);
+ }
+ return ConvertBuffer_8bppMask2Rgb(dest_format, dest_buf, dest_pitch,
+ width, height, pSrcBitmap, src_left,
+ src_top);
}
if ((src_format & 0xff) >= 24) {
if (src_format & 0x0400) {
- return _ConvertBuffer_32bppCmyk2Rgb32(dest_buf, dest_pitch, width,
- height, pSrcBitmap, src_left,
- src_top, pIccTransform);
+ return ConvertBuffer_32bppCmyk2Rgb32(dest_buf, dest_pitch, width,
+ height, pSrcBitmap, src_left,
+ src_top, pIccTransform);
}
- return _ConvertBuffer_Rgb2Rgb32(dest_buf, dest_pitch, width, height,
- pSrcBitmap, src_left, src_top,
- pIccTransform);
+ return ConvertBuffer_Rgb2Rgb32(dest_buf, dest_pitch, width, height,
+ pSrcBitmap, src_left, src_top,
+ pIccTransform);
}
return FALSE;
}
diff --git a/fpdfsdk/src/fsdk_baseannot.cpp b/fpdfsdk/src/fsdk_baseannot.cpp
index 2495897408..79418d972e 100644
--- a/fpdfsdk/src/fsdk_baseannot.cpp
+++ b/fpdfsdk/src/fsdk_baseannot.cpp
@@ -15,7 +15,7 @@
#include "fpdfsdk/include/fpdfxfa/fpdfxfa_doc.h"
#endif // PDF_ENABLE_XFA
-int _gAfxGetTimeZoneInSeconds(FX_CHAR tzhour, uint8_t tzminute) {
+int gAfxGetTimeZoneInSeconds(int8_t tzhour, uint8_t tzminute) {
return (int)tzhour * 3600 + (int)tzminute * (tzhour >= 0 ? 60 : -60);
}
@@ -404,7 +404,7 @@ void CPDFSDK_DateTime::ToSystemTime(FX_SYSTEMTIME& st) {
CPDFSDK_DateTime CPDFSDK_DateTime::ToGMT() {
CPDFSDK_DateTime dt = *this;
- dt.AddSeconds(-_gAfxGetTimeZoneInSeconds(dt.dt.tzHour, dt.dt.tzMinute));
+ dt.AddSeconds(-gAfxGetTimeZoneInSeconds(dt.dt.tzHour, dt.dt.tzMinute));
dt.dt.tzHour = 0;
dt.dt.tzMinute = 0;
return dt;
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-05 03:47:43 +0000