summaryrefslogtreecommitdiff
path: root/core/fxcodec/codec
diff options
context:
space:
mode:
Diffstat (limited to 'core/fxcodec/codec')
-rw-r--r--core/fxcodec/codec/ccodec_tiffmodule.h17
-rw-r--r--core/fxcodec/codec/fx_codec_progress.cpp780
-rw-r--r--core/fxcodec/codec/fx_codec_tiff.cpp570
-rw-r--r--core/fxcodec/codec/include/ccodec_progressivedecoder.h34
4 files changed, 690 insertions, 711 deletions
diff --git a/core/fxcodec/codec/ccodec_tiffmodule.h b/core/fxcodec/codec/ccodec_tiffmodule.h
index d746bb7e85..7b89584a3f 100644
--- a/core/fxcodec/codec/ccodec_tiffmodule.h
+++ b/core/fxcodec/codec/ccodec_tiffmodule.h
@@ -20,15 +20,14 @@ class CCodec_TiffModule {
CCodec_TiffContext* CreateDecoder(IFX_FileRead* file_ptr);
- void GetFrames(CCodec_TiffContext* ctx, int32_t& frames);
- FX_BOOL LoadFrameInfo(CCodec_TiffContext* ctx,
- int32_t frame,
- uint32_t& width,
- uint32_t& height,
- uint32_t& comps,
- uint32_t& bpc,
- CFX_DIBAttribute* pAttribute);
- FX_BOOL Decode(CCodec_TiffContext* ctx, class CFX_DIBitmap* pDIBitmap);
+ bool LoadFrameInfo(CCodec_TiffContext* ctx,
+ int32_t frame,
+ int32_t* width,
+ int32_t* height,
+ int32_t* comps,
+ int32_t* bpc,
+ CFX_DIBAttribute* pAttribute);
+ bool Decode(CCodec_TiffContext* ctx, class CFX_DIBitmap* pDIBitmap);
void DestroyDecoder(CCodec_TiffContext* ctx);
};
diff --git a/core/fxcodec/codec/fx_codec_progress.cpp b/core/fxcodec/codec/fx_codec_progress.cpp
index ec3347cdaa..bdb158f7ca 100644
--- a/core/fxcodec/codec/fx_codec_progress.cpp
+++ b/core/fxcodec/codec/fx_codec_progress.cpp
@@ -6,17 +6,37 @@
#include "core/fxcodec/codec/include/ccodec_progressivedecoder.h"
+#include <algorithm>
+
#include "core/fxcodec/include/fx_codec.h"
#include "core/fxge/include/fx_dib.h"
+#include "third_party/base/numerics/safe_math.h"
#define FXCODEC_BLOCK_SIZE 4096
-#define FXCODEC_PNG_GAMMA 2.2
+
+namespace {
#if _FX_OS_ == _FX_MACOSX_ || _FX_OS_ == _FX_IOS_
-#undef FXCODEC_PNG_GAMMA
-#define FXCODEC_PNG_GAMMA 1.7
+const double kPngGamma = 1.7;
+#else
+const double kPngGamma = 2.2;
#endif
+void RGB2BGR(uint8_t* buffer, int width = 1) {
+ if (buffer && width > 0) {
+ uint8_t temp;
+ int i = 0;
+ int j = 0;
+ for (; i < width; i++, j += 3) {
+ temp = buffer[j];
+ buffer[j] = buffer[j + 2];
+ buffer[j + 2] = temp;
+ }
+ }
+}
+
+} // namespace
+
void CCodec_ProgressiveDecoder::CFXCODEC_WeightTable::Calc(int dest_len,
int dest_min,
int dest_max,
@@ -24,9 +44,6 @@ void CCodec_ProgressiveDecoder::CFXCODEC_WeightTable::Calc(int dest_len,
int src_min,
int src_max,
FX_BOOL bInterpol) {
- if (m_pWeightTables) {
- FX_Free(m_pWeightTables);
- }
double scale, base;
scale = (FX_FLOAT)src_len / (FX_FLOAT)dest_len;
if (dest_len < 0) {
@@ -38,7 +55,7 @@ void CCodec_ProgressiveDecoder::CFXCODEC_WeightTable::Calc(int dest_len,
(int)(sizeof(int) * 2 +
sizeof(int) * (FXSYS_ceil(FXSYS_fabs((FX_FLOAT)scale)) + 1));
m_DestMin = dest_min;
- m_pWeightTables = FX_Alloc(uint8_t, (dest_max - dest_min) * m_ItemSize + 4);
+ m_pWeightTables.resize((dest_max - dest_min) * m_ItemSize + 4);
if (FXSYS_fabs((FX_FLOAT)scale) < 1.0f) {
for (int dest_pixel = dest_min; dest_pixel < dest_max; dest_pixel++) {
PixelWeight& pixel_weights = *GetPixelWeight(dest_pixel);
@@ -118,32 +135,27 @@ void CCodec_ProgressiveDecoder::CFXCODEC_WeightTable::Calc(int dest_len,
}
}
}
+
void CCodec_ProgressiveDecoder::CFXCODEC_HorzTable::Calc(int dest_len,
int src_len,
FX_BOOL bInterpol) {
- if (m_pWeightTables) {
- FX_Free(m_pWeightTables);
- }
double scale = (double)dest_len / (double)src_len;
m_ItemSize = sizeof(int) * 4;
int size = dest_len * m_ItemSize + 4;
- m_pWeightTables = FX_Alloc(uint8_t, size);
- FXSYS_memset(m_pWeightTables, 0, size);
+ m_pWeightTables.resize(size, 0);
if (scale > 1) {
int pre_des_col = 0;
for (int src_col = 0; src_col < src_len; src_col++) {
double des_col_f = src_col * scale;
int des_col = FXSYS_round((FX_FLOAT)des_col_f);
- PixelWeight* pWeight =
- (PixelWeight*)(m_pWeightTables + des_col * m_ItemSize);
+ PixelWeight* pWeight = GetPixelWeight(des_col);
pWeight->m_SrcStart = pWeight->m_SrcEnd = src_col;
pWeight->m_Weights[0] = 65536;
pWeight->m_Weights[1] = 0;
if (src_col == src_len - 1 && des_col < dest_len - 1) {
for (int des_col_index = pre_des_col + 1; des_col_index < dest_len;
des_col_index++) {
- pWeight =
- (PixelWeight*)(m_pWeightTables + des_col_index * m_ItemSize);
+ pWeight = GetPixelWeight(des_col_index);
pWeight->m_SrcStart = pWeight->m_SrcEnd = src_col;
pWeight->m_Weights[0] = 65536;
pWeight->m_Weights[1] = 0;
@@ -153,7 +165,7 @@ void CCodec_ProgressiveDecoder::CFXCODEC_HorzTable::Calc(int dest_len,
int des_col_len = des_col - pre_des_col;
for (int des_col_index = pre_des_col + 1; des_col_index < des_col;
des_col_index++) {
- pWeight = (PixelWeight*)(m_pWeightTables + des_col_index * m_ItemSize);
+ pWeight = GetPixelWeight(des_col_index);
pWeight->m_SrcStart = src_col - 1;
pWeight->m_SrcEnd = src_col;
pWeight->m_Weights[0] =
@@ -170,72 +182,66 @@ void CCodec_ProgressiveDecoder::CFXCODEC_HorzTable::Calc(int dest_len,
for (int des_col = 0; des_col < dest_len; des_col++) {
double src_col_f = des_col / scale;
int src_col = FXSYS_round((FX_FLOAT)src_col_f);
- PixelWeight* pWeight =
- (PixelWeight*)(m_pWeightTables + des_col * m_ItemSize);
+ PixelWeight* pWeight = GetPixelWeight(des_col);
pWeight->m_SrcStart = pWeight->m_SrcEnd = src_col;
pWeight->m_Weights[0] = 65536;
pWeight->m_Weights[1] = 0;
}
}
+
void CCodec_ProgressiveDecoder::CFXCODEC_VertTable::Calc(int dest_len,
int src_len) {
- if (m_pWeightTables) {
- FX_Free(m_pWeightTables);
- }
double scale = (double)dest_len / (double)src_len;
m_ItemSize = sizeof(int) * 4;
int size = dest_len * m_ItemSize + 4;
- m_pWeightTables = FX_Alloc(uint8_t, size);
- FXSYS_memset(m_pWeightTables, 0, size);
- if (scale > 1) {
- double step = 0.0;
- int src_row = 0;
- while (step < (double)dest_len) {
- int start_step = (int)step;
- step = scale * (++src_row);
- int end_step = (int)step;
- if (end_step >= dest_len) {
- end_step = dest_len;
- for (int des_row = start_step; des_row < end_step; des_row++) {
- PixelWeight* pWeight =
- (PixelWeight*)(m_pWeightTables + des_row * m_ItemSize);
- pWeight->m_SrcStart = start_step;
- pWeight->m_SrcEnd = start_step;
- pWeight->m_Weights[0] = 65536;
- pWeight->m_Weights[1] = 0;
- }
- return;
- }
- int length = end_step - start_step;
- {
- PixelWeight* pWeight =
- (PixelWeight*)(m_pWeightTables + start_step * m_ItemSize);
+ m_pWeightTables.resize(size, 0);
+ if (scale <= 1) {
+ for (int des_row = 0; des_row < dest_len; des_row++) {
+ PixelWeight* pWeight = GetPixelWeight(des_row);
+ pWeight->m_SrcStart = des_row;
+ pWeight->m_SrcEnd = des_row;
+ pWeight->m_Weights[0] = 65536;
+ pWeight->m_Weights[1] = 0;
+ }
+ return;
+ }
+
+ double step = 0.0;
+ int src_row = 0;
+ while (step < (double)dest_len) {
+ int start_step = (int)step;
+ step = scale * (++src_row);
+ int end_step = (int)step;
+ if (end_step >= dest_len) {
+ end_step = dest_len;
+ for (int des_row = start_step; des_row < end_step; des_row++) {
+ PixelWeight* pWeight = GetPixelWeight(des_row);
pWeight->m_SrcStart = start_step;
pWeight->m_SrcEnd = start_step;
pWeight->m_Weights[0] = 65536;
pWeight->m_Weights[1] = 0;
}
- for (int des_row = start_step + 1; des_row < end_step; des_row++) {
- PixelWeight* pWeight =
- (PixelWeight*)(m_pWeightTables + des_row * m_ItemSize);
- pWeight->m_SrcStart = start_step;
- pWeight->m_SrcEnd = end_step;
- pWeight->m_Weights[0] = FXSYS_round((FX_FLOAT)(end_step - des_row) /
- (FX_FLOAT)length * 65536);
- pWeight->m_Weights[1] = 65536 - pWeight->m_Weights[0];
- }
+ return;
}
- } else {
- for (int des_row = 0; des_row < dest_len; des_row++) {
- PixelWeight* pWeight =
- (PixelWeight*)(m_pWeightTables + des_row * m_ItemSize);
- pWeight->m_SrcStart = des_row;
- pWeight->m_SrcEnd = des_row;
+ int length = end_step - start_step;
+ {
+ PixelWeight* pWeight = GetPixelWeight(start_step);
+ pWeight->m_SrcStart = start_step;
+ pWeight->m_SrcEnd = start_step;
pWeight->m_Weights[0] = 65536;
pWeight->m_Weights[1] = 0;
}
+ for (int des_row = start_step + 1; des_row < end_step; des_row++) {
+ PixelWeight* pWeight = GetPixelWeight(des_row);
+ pWeight->m_SrcStart = start_step;
+ pWeight->m_SrcEnd = end_step;
+ pWeight->m_Weights[0] = FXSYS_round((FX_FLOAT)(end_step - des_row) /
+ (FX_FLOAT)length * 65536);
+ pWeight->m_Weights[1] = 65536 - pWeight->m_Weights[0];
+ }
}
}
+
CCodec_ProgressiveDecoder::CCodec_ProgressiveDecoder(
CCodec_ModuleMgr* pCodecMgr) {
m_pFile = nullptr;
@@ -253,7 +259,8 @@ CCodec_ProgressiveDecoder::CCodec_ProgressiveDecoder(
m_offSet = 0;
m_SrcSize = 0;
m_ScanlineSize = 0;
- m_SrcWidth = m_SrcHeight = 0;
+ m_SrcWidth = 0;
+ m_SrcHeight = 0;
m_SrcComponents = 0;
m_SrcBPC = 0;
m_SrcPassNumber = 0;
@@ -274,27 +281,24 @@ CCodec_ProgressiveDecoder::CCodec_ProgressiveDecoder(
m_GifFrameRect = FX_RECT(0, 0, 0, 0);
m_BmpIsTopBottom = FALSE;
}
+
CCodec_ProgressiveDecoder::~CCodec_ProgressiveDecoder() {
m_pFile = nullptr;
- if (m_pJpegContext) {
+ if (m_pJpegContext)
m_pCodecMgr->GetJpegModule()->Finish(m_pJpegContext);
- }
- if (m_pPngContext) {
+ if (m_pPngContext)
m_pCodecMgr->GetPngModule()->Finish(m_pPngContext);
- }
- if (m_pGifContext) {
+ if (m_pGifContext)
m_pCodecMgr->GetGifModule()->Finish(m_pGifContext);
- }
- if (m_pBmpContext) {
+ if (m_pBmpContext)
m_pCodecMgr->GetBmpModule()->Finish(m_pBmpContext);
- }
- if (m_pTiffContext) {
+ if (m_pTiffContext)
m_pCodecMgr->GetTiffModule()->DestroyDecoder(m_pTiffContext);
- }
FX_Free(m_pSrcBuf);
FX_Free(m_pDecodeBuf);
FX_Free(m_pSrcPalette);
}
+
FX_BOOL CCodec_ProgressiveDecoder::JpegReadMoreData(
CCodec_JpegModule* pJpegModule,
FXCODEC_STATUS& err_status) {
@@ -332,6 +336,7 @@ FX_BOOL CCodec_ProgressiveDecoder::JpegReadMoreData(
pJpegModule->Input(m_pJpegContext, m_pSrcBuf, dwSize + dwAvail);
return TRUE;
}
+
FX_BOOL CCodec_ProgressiveDecoder::PngReadHeaderFunc(void* pModule,
int width,
int height,
@@ -345,14 +350,24 @@ FX_BOOL CCodec_ProgressiveDecoder::PngReadHeaderFunc(void* pModule,
pCodec->m_SrcHeight = height;
pCodec->m_SrcBPC = bpc;
pCodec->m_SrcPassNumber = pass;
- pCodec->m_SrcComponents =
- *color_type == 0 ? 1 : *color_type == 2
- ? 3
- : *color_type == 3
- ? 4
- : *color_type == 4
- ? 2
- : *color_type == 6 ? 4 : 0;
+ switch (*color_type) {
+ case 0:
+ pCodec->m_SrcComponents = 1;
+ break;
+ case 4:
+ pCodec->m_SrcComponents = 2;
+ break;
+ case 2:
+ pCodec->m_SrcComponents = 3;
+ break;
+ case 3:
+ case 6:
+ pCodec->m_SrcComponents = 4;
+ break;
+ default:
+ pCodec->m_SrcComponents = 0;
+ break;
+ }
pCodec->m_clipBox = FX_RECT(0, 0, width, height);
return FALSE;
}
@@ -377,9 +392,10 @@ FX_BOOL CCodec_ProgressiveDecoder::PngReadHeaderFunc(void* pModule,
ASSERT(FALSE);
return FALSE;
}
- *gamma = FXCODEC_PNG_GAMMA;
+ *gamma = kPngGamma;
return TRUE;
}
+
FX_BOOL CCodec_ProgressiveDecoder::PngAskScanlineBufFunc(void* pModule,
int line,
uint8_t*& src_buf) {
@@ -454,6 +470,7 @@ FX_BOOL CCodec_ProgressiveDecoder::PngAskScanlineBufFunc(void* pModule,
}
return TRUE;
}
+
void CCodec_ProgressiveDecoder::PngOneOneMapResampleHorz(
CFX_DIBitmap* pDeviceBitmap,
int32_t des_line,
@@ -525,6 +542,7 @@ void CCodec_ProgressiveDecoder::PngOneOneMapResampleHorz(
}
}
}
+
void CCodec_ProgressiveDecoder::PngFillScanlineBufCompletedFunc(void* pModule,
int pass,
int line) {
@@ -554,6 +572,7 @@ void CCodec_ProgressiveDecoder::PngFillScanlineBufCompletedFunc(void* pModule,
}
}
}
+
FX_BOOL CCodec_ProgressiveDecoder::GifReadMoreData(CCodec_GifModule* pGifModule,
FXCODEC_STATUS& err_status) {
uint32_t dwSize = (uint32_t)m_pFile->GetSize();
@@ -590,6 +609,7 @@ FX_BOOL CCodec_ProgressiveDecoder::GifReadMoreData(CCodec_GifModule* pGifModule,
pGifModule->Input(m_pGifContext, m_pSrcBuf, dwSize + dwAvail);
return TRUE;
}
+
void CCodec_ProgressiveDecoder::GifRecordCurrentPositionCallback(
void* pModule,
uint32_t& cur_pos) {
@@ -598,12 +618,14 @@ void CCodec_ProgressiveDecoder::GifRecordCurrentPositionCallback(
pCodec->m_pCodecMgr->GetGifModule()->GetAvailInput(pCodec->m_pGifContext);
cur_pos = pCodec->m_offSet - remain_size;
}
+
uint8_t* CCodec_ProgressiveDecoder::GifAskLocalPaletteBufCallback(
void* pModule,
int32_t frame_num,
int32_t pal_size) {
return FX_Alloc(uint8_t, pal_size);
}
+
FX_BOOL CCodec_ProgressiveDecoder::GifInputRecordPositionBufCallback(
void* pModule,
uint32_t rcd_pos,
@@ -693,6 +715,7 @@ FX_BOOL CCodec_ProgressiveDecoder::GifInputRecordPositionBufCallback(
}
return TRUE;
}
+
void CCodec_ProgressiveDecoder::GifReadScanlineCallback(void* pModule,
int32_t row_num,
uint8_t* row_buf) {
@@ -723,41 +746,42 @@ void CCodec_ProgressiveDecoder::GifReadScanlineCallback(void* pModule,
int des_top = pCodec->m_startY;
int src_hei = pCodec->m_clipBox.Height();
int des_hei = pCodec->m_sizeY;
- if (line >= src_top && line < src_bottom) {
- double scale_y = (double)des_hei / (double)src_hei;
- int src_row = line - src_top;
- int des_row = (int)(src_row * scale_y) + des_top;
- if (des_row >= des_top + des_hei) {
- return;
- }
- pCodec->ReSampleScanline(pDIBitmap, des_row, pCodec->m_pDecodeBuf,
- pCodec->m_SrcFormat);
- if (scale_y > 1.0 &&
- (!pCodec->m_bInterpol || pCodec->m_SrcPassNumber == 1)) {
- pCodec->ResampleVert(pDIBitmap, scale_y, des_row);
- return;
- }
- if (scale_y > 1.0) {
- int des_bottom = des_top + pCodec->m_sizeY;
- int des_Bpp = pDIBitmap->GetBPP() >> 3;
- uint32_t des_ScanOffet = pCodec->m_startX * des_Bpp;
- if (des_row + (int)scale_y >= des_bottom - 1) {
- uint8_t* scan_src =
- (uint8_t*)pDIBitmap->GetScanline(des_row) + des_ScanOffet;
- int cur_row = des_row;
- while (++cur_row < des_bottom) {
- uint8_t* scan_des =
- (uint8_t*)pDIBitmap->GetScanline(cur_row) + des_ScanOffet;
- uint32_t size = pCodec->m_sizeX * des_Bpp;
- FXSYS_memcpy(scan_des, scan_src, size);
- }
- }
- if (bLastPass) {
- pCodec->GifDoubleLineResampleVert(pDIBitmap, scale_y, des_row);
- }
+ if (line < src_top || line >= src_bottom)
+ return;
+
+ double scale_y = (double)des_hei / (double)src_hei;
+ int src_row = line - src_top;
+ int des_row = (int)(src_row * scale_y) + des_top;
+ if (des_row >= des_top + des_hei)
+ return;
+
+ pCodec->ReSampleScanline(pDIBitmap, des_row, pCodec->m_pDecodeBuf,
+ pCodec->m_SrcFormat);
+ if (scale_y > 1.0 && (!pCodec->m_bInterpol || pCodec->m_SrcPassNumber == 1)) {
+ pCodec->ResampleVert(pDIBitmap, scale_y, des_row);
+ return;
+ }
+ if (scale_y <= 1.0)
+ return;
+
+ int des_bottom = des_top + pCodec->m_sizeY;
+ int des_Bpp = pDIBitmap->GetBPP() >> 3;
+ uint32_t des_ScanOffet = pCodec->m_startX * des_Bpp;
+ if (des_row + (int)scale_y >= des_bottom - 1) {
+ uint8_t* scan_src =
+ (uint8_t*)pDIBitmap->GetScanline(des_row) + des_ScanOffet;
+ int cur_row = des_row;
+ while (++cur_row < des_bottom) {
+ uint8_t* scan_des =
+ (uint8_t*)pDIBitmap->GetScanline(cur_row) + des_ScanOffet;
+ uint32_t size = pCodec->m_sizeX * des_Bpp;
+ FXSYS_memcpy(scan_des, scan_src, size);
}
}
+ if (bLastPass)
+ pCodec->GifDoubleLineResampleVert(pDIBitmap, scale_y, des_row);
}
+
void CCodec_ProgressiveDecoder::GifDoubleLineResampleVert(
CFX_DIBitmap* pDeviceBitmap,
double scale_y,
@@ -765,10 +789,12 @@ void CCodec_ProgressiveDecoder::GifDoubleLineResampleVert(
int des_Bpp = pDeviceBitmap->GetBPP() >> 3;
uint32_t des_ScanOffet = m_startX * des_Bpp;
int des_top = m_startY;
- int des_row_1 = des_row - int(2 * scale_y);
- if (des_row_1 < des_top) {
- des_row_1 = des_top;
- }
+ pdfium::base::CheckedNumeric<double> scale_y2 = scale_y;
+ scale_y2 *= 2;
+ pdfium::base::CheckedNumeric<int> check_des_row_1 = des_row;
+ check_des_row_1 -= scale_y2.ValueOrDie();
+ int des_row_1 = check_des_row_1.ValueOrDie();
+ des_row_1 = std::max(des_row_1, des_top);
for (; des_row_1 < des_row; des_row_1++) {
uint8_t* scan_des =
(uint8_t*)pDeviceBitmap->GetScanline(des_row_1) + des_ScanOffet;
@@ -836,12 +862,13 @@ void CCodec_ProgressiveDecoder::GifDoubleLineResampleVert(
GifDoubleLineResampleVert(pDeviceBitmap, scale_y, des_row + (int)scale_y);
}
}
+
FX_BOOL CCodec_ProgressiveDecoder::BmpReadMoreData(CCodec_BmpModule* pBmpModule,
FXCODEC_STATUS& err_status) {
uint32_t dwSize = (uint32_t)m_pFile->GetSize();
- if (dwSize <= m_offSet) {
+ if (dwSize <= m_offSet)
return FALSE;
- }
+
dwSize = dwSize - m_offSet;
uint32_t dwAvail = pBmpModule->GetAvailInput(m_pBmpContext, nullptr);
if (dwAvail == m_SrcSize) {
@@ -872,18 +899,17 @@ FX_BOOL CCodec_ProgressiveDecoder::BmpReadMoreData(CCodec_BmpModule* pBmpModule,
pBmpModule->Input(m_pBmpContext, m_pSrcBuf, dwSize + dwAvail);
return TRUE;
}
+
FX_BOOL CCodec_ProgressiveDecoder::BmpInputImagePositionBufCallback(
void* pModule,
uint32_t rcd_pos) {
CCodec_ProgressiveDecoder* pCodec = (CCodec_ProgressiveDecoder*)pModule;
pCodec->m_offSet = rcd_pos;
FXCODEC_STATUS error_status = FXCODEC_STATUS_ERROR;
- if (!pCodec->BmpReadMoreData(pCodec->m_pCodecMgr->GetBmpModule(),
- error_status)) {
- return FALSE;
- }
- return TRUE;
+ return pCodec->BmpReadMoreData(pCodec->m_pCodecMgr->GetBmpModule(),
+ error_status);
}
+
void CCodec_ProgressiveDecoder::BmpReadScanlineCallback(void* pModule,
int32_t row_num,
uint8_t* row_buf) {
@@ -896,25 +922,27 @@ void CCodec_ProgressiveDecoder::BmpReadScanlineCallback(void* pModule,
int des_top = pCodec->m_startY;
int src_hei = pCodec->m_clipBox.Height();
int des_hei = pCodec->m_sizeY;
- if (row_num >= src_top && row_num < src_bottom) {
- double scale_y = (double)des_hei / (double)src_hei;
- int src_row = row_num - src_top;
- int des_row = (int)(src_row * scale_y) + des_top;
- if (des_row >= des_top + des_hei) {
- return;
- }
- pCodec->ReSampleScanline(pDIBitmap, des_row, pCodec->m_pDecodeBuf,
- pCodec->m_SrcFormat);
- if (scale_y > 1.0) {
- if (pCodec->m_BmpIsTopBottom || !pCodec->m_bInterpol) {
- pCodec->ResampleVert(pDIBitmap, scale_y, des_row);
- return;
- } else {
- pCodec->ResampleVertBT(pDIBitmap, scale_y, des_row);
- }
- }
+ if (row_num < src_top || row_num >= src_bottom)
+ return;
+
+ double scale_y = (double)des_hei / (double)src_hei;
+ int src_row = row_num - src_top;
+ int des_row = (int)(src_row * scale_y) + des_top;
+ if (des_row >= des_top + des_hei)
+ return;
+
+ pCodec->ReSampleScanline(pDIBitmap, des_row, pCodec->m_pDecodeBuf,
+ pCodec->m_SrcFormat);
+ if (scale_y <= 1.0)
+ return;
+
+ if (pCodec->m_BmpIsTopBottom || !pCodec->m_bInterpol) {
+ pCodec->ResampleVert(pDIBitmap, scale_y, des_row);
+ return;
}
+ pCodec->ResampleVertBT(pDIBitmap, scale_y, des_row);
}
+
void CCodec_ProgressiveDecoder::ResampleVertBT(CFX_DIBitmap* pDeviceBitmap,
double scale_y,
int des_row) {
@@ -922,7 +950,9 @@ void CCodec_ProgressiveDecoder::ResampleVertBT(CFX_DIBitmap* pDeviceBitmap,
uint32_t des_ScanOffet = m_startX * des_Bpp;
int des_top = m_startY;
int des_bottom = m_startY + m_sizeY;
- int des_row_1 = des_row + int(scale_y);
+ pdfium::base::CheckedNumeric<int> check_des_row_1 = des_row;
+ check_des_row_1 += pdfium::base::checked_cast<int>(scale_y);
+ int des_row_1 = check_des_row_1.ValueOrDie();
if (des_row_1 >= des_bottom - 1) {
uint8_t* scan_src =
(uint8_t*)pDeviceBitmap->GetScanline(des_row) + des_ScanOffet;
@@ -996,6 +1026,7 @@ void CCodec_ProgressiveDecoder::ResampleVertBT(CFX_DIBitmap* pDeviceBitmap,
}
}
}
+
FX_BOOL CCodec_ProgressiveDecoder::DetectImageType(
FXCODEC_IMAGE_TYPE imageType,
CFX_DIBAttribute* pAttribute) {
@@ -1063,7 +1094,7 @@ FX_BOOL CCodec_ProgressiveDecoder::DetectImageType(
}
m_status = FXCODEC_STATUS_ERR_FORMAT;
return FALSE;
- } break;
+ }
case FXCODEC_IMAGE_JPG: {
CCodec_JpegModule* pJpegModule = m_pCodecMgr->GetJpegModule();
if (!pJpegModule) {
@@ -1106,7 +1137,7 @@ FX_BOOL CCodec_ProgressiveDecoder::DetectImageType(
}
m_status = FXCODEC_STATUS_ERR_FORMAT;
return FALSE;
- } break;
+ }
case FXCODEC_IMAGE_PNG: {
CCodec_PngModule* pPngModule = m_pCodecMgr->GetPngModule();
if (!pPngModule) {
@@ -1167,7 +1198,8 @@ FX_BOOL CCodec_ProgressiveDecoder::DetectImageType(
m_status = FXCODEC_STATUS_ERR_FORMAT;
return FALSE;
}
- } break;
+ return TRUE;
+ }
case FXCODEC_IMAGE_GIF: {
CCodec_GifModule* pGifModule = m_pCodecMgr->GetGifModule();
if (!pGifModule) {
@@ -1219,7 +1251,7 @@ FX_BOOL CCodec_ProgressiveDecoder::DetectImageType(
}
m_status = FXCODEC_STATUS_ERR_FORMAT;
return FALSE;
- } break;
+ }
case FXCODEC_IMAGE_TIF: {
CCodec_TiffModule* pTiffModule = m_pCodecMgr->GetTiffModule();
if (!pTiffModule) {
@@ -1231,27 +1263,26 @@ FX_BOOL CCodec_ProgressiveDecoder::DetectImageType(
m_status = FXCODEC_STATUS_ERR_FORMAT;
return FALSE;
}
- int32_t frames = 0;
- pTiffModule->GetFrames(m_pTiffContext, frames);
- uint32_t bpc;
- FX_BOOL ret = pTiffModule->LoadFrameInfo(
- m_pTiffContext, 0, (uint32_t&)m_SrcWidth, (uint32_t&)m_SrcHeight,
- (uint32_t&)m_SrcComponents, bpc, pAttribute);
+ int32_t dummy_bpc;
+ FX_BOOL ret = pTiffModule->LoadFrameInfo(m_pTiffContext, 0, &m_SrcWidth,
+ &m_SrcHeight, &m_SrcComponents,
+ &dummy_bpc, pAttribute);
m_SrcComponents = 4;
m_clipBox = FX_RECT(0, 0, m_SrcWidth, m_SrcHeight);
if (!ret) {
pTiffModule->DestroyDecoder(m_pTiffContext);
- (m_pTiffContext = nullptr);
- (m_status = FXCODEC_STATUS_ERR_FORMAT);
+ m_pTiffContext = nullptr;
+ m_status = FXCODEC_STATUS_ERR_FORMAT;
return FALSE;
}
- } break;
+ return TRUE;
+ }
default:
m_status = FXCODEC_STATUS_ERR_FORMAT;
return FALSE;
}
- return TRUE;
}
+
FXCODEC_STATUS CCodec_ProgressiveDecoder::LoadImageInfo(
IFX_FileRead* pFile,
FXCODEC_IMAGE_TYPE imageType,
@@ -1295,32 +1326,26 @@ FXCODEC_STATUS CCodec_ProgressiveDecoder::LoadImageInfo(
m_pFile = nullptr;
return m_status;
}
+
void CCodec_ProgressiveDecoder::SetClipBox(FX_RECT* clip) {
- if (m_status != FXCODEC_STATUS_FRAME_READY) {
+ if (m_status != FXCODEC_STATUS_FRAME_READY)
return;
- }
+
if (clip->IsEmpty()) {
m_clipBox = FX_RECT(0, 0, 0, 0);
return;
}
- if (clip->left < 0) {
- clip->left = 0;
- }
- if (clip->right > m_SrcWidth) {
- clip->right = m_SrcWidth;
- }
- if (clip->top < 0) {
- clip->top = 0;
- }
- if (clip->bottom > m_SrcHeight) {
- clip->bottom = m_SrcHeight;
- }
+ clip->left = std::max(clip->left, 0);
+ clip->right = std::min(clip->right, m_SrcWidth);
+ clip->top = std::max(clip->top, 0);
+ clip->bottom = std::min(clip->bottom, m_SrcHeight);
if (clip->IsEmpty()) {
m_clipBox = FX_RECT(0, 0, 0, 0);
return;
}
m_clipBox = *clip;
}
+
void CCodec_ProgressiveDecoder::GetDownScale(int& down_scale) {
down_scale = 1;
int ratio_w = m_clipBox.Width() / m_sizeX;
@@ -1344,6 +1369,7 @@ void CCodec_ProgressiveDecoder::GetDownScale(int& down_scale) {
m_clipBox.bottom = m_clipBox.top + 1;
}
}
+
void CCodec_ProgressiveDecoder::GetTransMethod(FXDIB_Format des_format,
FXCodec_Format src_format) {
switch (des_format) {
@@ -1441,18 +1467,7 @@ void CCodec_ProgressiveDecoder::GetTransMethod(FXDIB_Format des_format,
m_TransMethod = -1;
}
}
-void _RGB2BGR(uint8_t* buffer, int width = 1) {
- if (buffer && width > 0) {
- uint8_t temp;
- int i = 0;
- int j = 0;
- for (; i < width; i++, j += 3) {
- temp = buffer[j];
- buffer[j] = buffer[j + 2];
- buffer[j + 2] = temp;
- }
- }
-}
+
void CCodec_ProgressiveDecoder::ReSampleScanline(CFX_DIBitmap* pDeviceBitmap,
int des_line,
uint8_t* src_scan,
@@ -1654,6 +1669,7 @@ void CCodec_ProgressiveDecoder::ReSampleScanline(CFX_DIBitmap* pDeviceBitmap,
}
}
}
+
void CCodec_ProgressiveDecoder::ResampleVert(CFX_DIBitmap* pDeviceBitmap,
double scale_y,
int des_row) {
@@ -1661,7 +1677,9 @@ void CCodec_ProgressiveDecoder::ResampleVert(CFX_DIBitmap* pDeviceBitmap,
uint32_t des_ScanOffet = m_startX * des_Bpp;
if (m_bInterpol) {
int des_top = m_startY;
- int des_row_1 = des_row - int(scale_y);
+ pdfium::base::CheckedNumeric<int> check_des_row_1 = des_row;
+ check_des_row_1 -= pdfium::base::checked_cast<int>(scale_y);
+ int des_row_1 = check_des_row_1.ValueOrDie();
if (des_row_1 < des_top) {
int des_bottom = des_top + m_sizeY;
if (des_row + (int)scale_y >= des_bottom - 1) {
@@ -1766,6 +1784,7 @@ void CCodec_ProgressiveDecoder::ResampleVert(CFX_DIBitmap* pDeviceBitmap,
}
}
}
+
void CCodec_ProgressiveDecoder::Resample(CFX_DIBitmap* pDeviceBitmap,
int32_t src_line,
uint8_t* src_scan,
@@ -1787,6 +1806,7 @@ void CCodec_ProgressiveDecoder::Resample(CFX_DIBitmap* pDeviceBitmap,
}
}
}
+
FXCODEC_STATUS CCodec_ProgressiveDecoder::GetFrames(int32_t& frames,
IFX_Pause* pPause) {
if (!(m_status == FXCODEC_STATUS_FRAME_READY ||
@@ -1799,10 +1819,11 @@ FXCODEC_STATUS CCodec_ProgressiveDecoder::GetFrames(int32_t& frames,
case FXCODEC_IMAGE_PNG:
case FXCODEC_IMAGE_TIF:
frames = m_FrameNumber = 1;
- return m_status = FXCODEC_STATUS_DECODE_READY;
+ m_status = FXCODEC_STATUS_DECODE_READY;
+ return m_status;
case FXCODEC_IMAGE_GIF: {
CCodec_GifModule* pGifModule = m_pCodecMgr->GetGifModule();
- while (TRUE) {
+ while (true) {
int32_t readResult =
pGifModule->LoadFrameInfo(m_pGifContext, &m_FrameNumber);
while (readResult == 2) {
@@ -1811,26 +1832,29 @@ FXCODEC_STATUS CCodec_ProgressiveDecoder::GetFrames(int32_t& frames,
return error_status;
}
if (pPause && pPause->NeedToPauseNow()) {
- return m_status = FXCODEC_STATUS_FRAME_TOBECONTINUE;
+ m_status = FXCODEC_STATUS_FRAME_TOBECONTINUE;
+ return m_status;
}
readResult = pGifModule->LoadFrameInfo(m_pGifContext, &m_FrameNumber);
}
if (readResult == 1) {
frames = m_FrameNumber;
- return m_status = FXCODEC_STATUS_DECODE_READY;
+ m_status = FXCODEC_STATUS_DECODE_READY;
+ return m_status;
}
if (m_pGifContext) {
pGifModule->Finish(m_pGifContext);
m_pGifContext = nullptr;
}
- return m_status = FXCODEC_STATUS_ERROR;
+ m_status = FXCODEC_STATUS_ERROR;
+ return m_status;
}
- } break;
+ }
default:
- break;
+ return FXCODEC_STATUS_ERROR;
}
- return FXCODEC_STATUS_ERROR;
}
+
FXCODEC_STATUS CCodec_ProgressiveDecoder::StartDecode(CFX_DIBitmap* pDIBitmap,
int start_x,
int start_y,
@@ -1846,21 +1870,20 @@ FXCODEC_STATUS CCodec_ProgressiveDecoder::StartDecode(CFX_DIBitmap* pDIBitmap,
return FXCODEC_STATUS_ERR_PARAMS;
}
m_pDeviceBitmap = pDIBitmap;
- if (m_clipBox.IsEmpty()) {
+ if (m_clipBox.IsEmpty())
return FXCODEC_STATUS_ERR_PARAMS;
- }
- if (size_x <= 0 || size_x > 65535 || size_y <= 0 || size_y > 65535) {
+ if (size_x <= 0 || size_x > 65535 || size_y <= 0 || size_y > 65535)
return FXCODEC_STATUS_ERR_PARAMS;
- }
+
FX_RECT device_rc =
FX_RECT(start_x, start_y, start_x + size_x, start_y + size_y);
int32_t out_range_x = device_rc.right - pDIBitmap->GetWidth();
int32_t out_range_y = device_rc.bottom - pDIBitmap->GetHeight();
device_rc.Intersect(
FX_RECT(0, 0, pDIBitmap->GetWidth(), pDIBitmap->GetHeight()));
- if (device_rc.IsEmpty()) {
+ if (device_rc.IsEmpty())
return FXCODEC_STATUS_ERR_PARAMS;
- }
+
m_startX = device_rc.left;
m_startY = device_rc.top;
m_sizeX = device_rc.Width();
@@ -1899,7 +1922,8 @@ FXCODEC_STATUS CCodec_ProgressiveDecoder::StartDecode(CFX_DIBitmap* pDIBitmap,
if (!JpegReadMoreData(pJpegModule, error_status)) {
m_pDeviceBitmap = nullptr;
m_pFile = nullptr;
- return m_status = error_status;
+ m_status = error_status;
+ return m_status;
}
bStart = pJpegModule->StartScanline(m_pJpegContext, down_scale);
}
@@ -1923,14 +1947,16 @@ FXCODEC_STATUS CCodec_ProgressiveDecoder::StartDecode(CFX_DIBitmap* pDIBitmap,
break;
}
GetTransMethod(pDIBitmap->GetFormat(), m_SrcFormat);
- return m_status = FXCODEC_STATUS_DECODE_TOBECONTINUE;
- } break;
+ m_status = FXCODEC_STATUS_DECODE_TOBECONTINUE;
+ return m_status;
+ }
case FXCODEC_IMAGE_PNG: {
CCodec_PngModule* pPngModule = m_pCodecMgr->GetPngModule();
if (!pPngModule) {
m_pDeviceBitmap = nullptr;
m_pFile = nullptr;
- return m_status = FXCODEC_STATUS_ERR_MEMORY;
+ m_status = FXCODEC_STATUS_ERR_MEMORY;
+ return m_status;
}
if (m_pPngContext) {
pPngModule->Finish(m_pPngContext);
@@ -1940,7 +1966,8 @@ FXCODEC_STATUS CCodec_ProgressiveDecoder::StartDecode(CFX_DIBitmap* pDIBitmap,
if (!m_pPngContext) {
m_pDeviceBitmap = nullptr;
m_pFile = nullptr;
- return m_status = FXCODEC_STATUS_ERR_MEMORY;
+ m_status = FXCODEC_STATUS_ERR_MEMORY;
+ return m_status;
}
m_offSet = 0;
switch (m_pDeviceBitmap->GetFormat()) {
@@ -1961,7 +1988,8 @@ FXCODEC_STATUS CCodec_ProgressiveDecoder::StartDecode(CFX_DIBitmap* pDIBitmap,
default: {
m_pDeviceBitmap = nullptr;
m_pFile = nullptr;
- return m_status = FXCODEC_STATUS_ERR_PARAMS;
+ m_status = FXCODEC_STATUS_ERR_PARAMS;
+ return m_status;
}
}
GetTransMethod(m_pDeviceBitmap->GetFormat(), m_SrcFormat);
@@ -1971,14 +1999,16 @@ FXCODEC_STATUS CCodec_ProgressiveDecoder::StartDecode(CFX_DIBitmap* pDIBitmap,
FXSYS_memset(m_pDecodeBuf, 0, scanline_size);
m_WeightHorzOO.Calc(m_sizeX, m_clipBox.Width(), m_bInterpol);
m_WeightVert.Calc(m_sizeY, m_clipBox.Height());
- return m_status = FXCODEC_STATUS_DECODE_TOBECONTINUE;
- } break;
+ m_status = FXCODEC_STATUS_DECODE_TOBECONTINUE;
+ return m_status;
+ }
case FXCODEC_IMAGE_GIF: {
CCodec_GifModule* pGifModule = m_pCodecMgr->GetGifModule();
if (!pGifModule) {
m_pDeviceBitmap = nullptr;
m_pFile = nullptr;
- return m_status = FXCODEC_STATUS_ERR_MEMORY;
+ m_status = FXCODEC_STATUS_ERR_MEMORY;
+ return m_status;
}
m_SrcFormat = FXCodec_8bppRgb;
GetTransMethod(m_pDeviceBitmap->GetFormat(), m_SrcFormat);
@@ -1990,14 +2020,16 @@ FXCODEC_STATUS CCodec_ProgressiveDecoder::StartDecode(CFX_DIBitmap* pDIBitmap,
m_clipBox.Width(), m_bInterpol);
m_WeightVert.Calc(m_sizeY, m_clipBox.Height());
m_FrameCur = frames;
- return m_status = FXCODEC_STATUS_DECODE_TOBECONTINUE;
- } break;
+ m_status = FXCODEC_STATUS_DECODE_TOBECONTINUE;
+ return m_status;
+ }
case FXCODEC_IMAGE_BMP: {
CCodec_BmpModule* pBmpModule = m_pCodecMgr->GetBmpModule();
if (!pBmpModule) {
m_pDeviceBitmap = nullptr;
m_pFile = nullptr;
- return m_status = FXCODEC_STATUS_ERR_MEMORY;
+ m_status = FXCODEC_STATUS_ERR_MEMORY;
+ return m_status;
}
switch (m_SrcComponents) {
case 1:
@@ -2018,23 +2050,25 @@ FXCODEC_STATUS CCodec_ProgressiveDecoder::StartDecode(CFX_DIBitmap* pDIBitmap,
m_WeightHorz.Calc(m_sizeX, 0, m_sizeX, m_clipBox.Width(), 0,
m_clipBox.Width(), m_bInterpol);
m_WeightVert.Calc(m_sizeY, m_clipBox.Height());
- return m_status = FXCODEC_STATUS_DECODE_TOBECONTINUE;
- } break;
+ m_status = FXCODEC_STATUS_DECODE_TOBECONTINUE;
+ return m_status;
+ }
case FXCODEC_IMAGE_TIF:
- return m_status = FXCODEC_STATUS_DECODE_TOBECONTINUE;
+ m_status = FXCODEC_STATUS_DECODE_TOBECONTINUE;
+ return m_status;
default:
- break;
+ return FXCODEC_STATUS_ERROR;
}
- return FXCODEC_STATUS_ERROR;
}
+
FXCODEC_STATUS CCodec_ProgressiveDecoder::ContinueDecode(IFX_Pause* pPause) {
- if (m_status != FXCODEC_STATUS_DECODE_TOBECONTINUE) {
+ if (m_status != FXCODEC_STATUS_DECODE_TOBECONTINUE)
return FXCODEC_STATUS_ERROR;
- }
+
switch (m_imagType) {
case FXCODEC_IMAGE_JPG: {
CCodec_JpegModule* pJpegModule = m_pCodecMgr->GetJpegModule();
- while (TRUE) {
+ while (true) {
FX_BOOL readRes =
pJpegModule->ReadScanline(m_pJpegContext, m_pDecodeBuf);
while (!readRes) {
@@ -2042,29 +2076,32 @@ FXCODEC_STATUS CCodec_ProgressiveDecoder::ContinueDecode(IFX_Pause* pPause) {
if (!JpegReadMoreData(pJpegModule, error_status)) {
m_pDeviceBitmap = nullptr;
m_pFile = nullptr;
- return m_status = error_status;
+ m_status = error_status;
+ return m_status;
}
readRes = pJpegModule->ReadScanline(m_pJpegContext, m_pDecodeBuf);
}
if (m_SrcFormat == FXCodec_Rgb) {
int src_Bpp = (m_SrcFormat & 0xff) >> 3;
- _RGB2BGR(m_pDecodeBuf + m_clipBox.left * src_Bpp, m_clipBox.Width());
+ RGB2BGR(m_pDecodeBuf + m_clipBox.left * src_Bpp, m_clipBox.Width());
}
if (m_SrcRow >= m_clipBox.bottom) {
m_pDeviceBitmap = nullptr;
m_pFile = nullptr;
- return m_status = FXCODEC_STATUS_DECODE_FINISH;
+ m_status = FXCODEC_STATUS_DECODE_FINISH;
+ return m_status;
}
Resample(m_pDeviceBitmap, m_SrcRow, m_pDecodeBuf, m_SrcFormat);
m_SrcRow++;
if (pPause && pPause->NeedToPauseNow()) {
- return m_status = FXCODEC_STATUS_DECODE_TOBECONTINUE;
+ m_status = FXCODEC_STATUS_DECODE_TOBECONTINUE;
+ return m_status;
}
}
- } break;
+ }
case FXCODEC_IMAGE_PNG: {
CCodec_PngModule* pPngModule = m_pCodecMgr->GetPngModule();
- while (TRUE) {
+ while (true) {
uint32_t remain_size = (uint32_t)m_pFile->GetSize() - m_offSet;
uint32_t input_size =
remain_size > FXCODEC_BLOCK_SIZE ? FXCODEC_BLOCK_SIZE : remain_size;
@@ -2075,7 +2112,8 @@ FXCODEC_STATUS CCodec_ProgressiveDecoder::ContinueDecode(IFX_Pause* pPause) {
m_pPngContext = nullptr;
m_pDeviceBitmap = nullptr;
m_pFile = nullptr;
- return m_status = FXCODEC_STATUS_DECODE_FINISH;
+ m_status = FXCODEC_STATUS_DECODE_FINISH;
+ return m_status;
}
if (m_pSrcBuf && input_size > m_SrcSize) {
FX_Free(m_pSrcBuf);
@@ -2087,7 +2125,8 @@ FXCODEC_STATUS CCodec_ProgressiveDecoder::ContinueDecode(IFX_Pause* pPause) {
if (!bResult) {
m_pDeviceBitmap = nullptr;
m_pFile = nullptr;
- return m_status = FXCODEC_STATUS_ERR_READ;
+ m_status = FXCODEC_STATUS_ERR_READ;
+ return m_status;
}
m_offSet += input_size;
bResult =
@@ -2095,16 +2134,18 @@ FXCODEC_STATUS CCodec_ProgressiveDecoder::ContinueDecode(IFX_Pause* pPause) {
if (!bResult) {
m_pDeviceBitmap = nullptr;
m_pFile = nullptr;
- return m_status = FXCODEC_STATUS_ERROR;
+ m_status = FXCODEC_STATUS_ERROR;
+ return m_status;
}
if (pPause && pPause->NeedToPauseNow()) {
- return m_status = FXCODEC_STATUS_DECODE_TOBECONTINUE;
+ m_status = FXCODEC_STATUS_DECODE_TOBECONTINUE;
+ return m_status;
}
}
- } break;
+ }
case FXCODEC_IMAGE_GIF: {
CCodec_GifModule* pGifModule = m_pCodecMgr->GetGifModule();
- while (TRUE) {
+ while (true) {
int32_t readRes =
pGifModule->LoadFrame(m_pGifContext, m_FrameCur, nullptr);
while (readRes == 2) {
@@ -2112,49 +2153,57 @@ FXCODEC_STATUS CCodec_ProgressiveDecoder::ContinueDecode(IFX_Pause* pPause) {
if (!GifReadMoreData(pGifModule, error_status)) {
m_pDeviceBitmap = nullptr;
m_pFile = nullptr;
- return m_status = error_status;
+ m_status = error_status;
+ return m_status;
}
if (pPause && pPause->NeedToPauseNow()) {
- return m_status = FXCODEC_STATUS_DECODE_TOBECONTINUE;
+ m_status = FXCODEC_STATUS_DECODE_TOBECONTINUE;
+ return m_status;
}
readRes = pGifModule->LoadFrame(m_pGifContext, m_FrameCur, nullptr);
}
if (readRes == 1) {
m_pDeviceBitmap = nullptr;
m_pFile = nullptr;
- return m_status = FXCODEC_STATUS_DECODE_FINISH;
+ m_status = FXCODEC_STATUS_DECODE_FINISH;
+ return m_status;
}
m_pDeviceBitmap = nullptr;
m_pFile = nullptr;
- return m_status = FXCODEC_STATUS_ERROR;
+ m_status = FXCODEC_STATUS_ERROR;
+ return m_status;
}
- } break;
+ }
case FXCODEC_IMAGE_BMP: {
CCodec_BmpModule* pBmpModule = m_pCodecMgr->GetBmpModule();
- while (TRUE) {
+ while (true) {
int32_t readRes = pBmpModule->LoadImage(m_pBmpContext);
while (readRes == 2) {
FXCODEC_STATUS error_status = FXCODEC_STATUS_DECODE_FINISH;
if (!BmpReadMoreData(pBmpModule, error_status)) {
m_pDeviceBitmap = nullptr;
m_pFile = nullptr;
- return m_status = error_status;
+ m_status = error_status;
+ return m_status;
}
if (pPause && pPause->NeedToPauseNow()) {
- return m_status = FXCODEC_STATUS_DECODE_TOBECONTINUE;
+ m_status = FXCODEC_STATUS_DECODE_TOBECONTINUE;
+ return m_status;
}
readRes = pBmpModule->LoadImage(m_pBmpContext);
}
if (readRes == 1) {
m_pDeviceBitmap = nullptr;
m_pFile = nullptr;
- return m_status = FXCODEC_STATUS_DECODE_FINISH;
+ m_status = FXCODEC_STATUS_DECODE_FINISH;
+ return m_status;
}
m_pDeviceBitmap = nullptr;
m_pFile = nullptr;
- return m_status = FXCODEC_STATUS_ERROR;
+ m_status = FXCODEC_STATUS_ERROR;
+ return m_status;
}
- } break;
+ };
case FXCODEC_IMAGE_TIF: {
CCodec_TiffModule* pTiffModule = m_pCodecMgr->GetTiffModule();
FX_BOOL ret = FALSE;
@@ -2168,136 +2217,143 @@ FXCODEC_STATUS CCodec_ProgressiveDecoder::ContinueDecode(IFX_Pause* pPause) {
m_pDeviceBitmap = nullptr;
m_pFile = nullptr;
if (!ret) {
- return m_status = FXCODEC_STATUS_ERROR;
- }
- return m_status = FXCODEC_STATUS_DECODE_FINISH;
- } else {
- CFX_DIBitmap* pDIBitmap = new CFX_DIBitmap;
- pDIBitmap->Create(m_SrcWidth, m_SrcHeight, FXDIB_Argb);
- if (!pDIBitmap->GetBuffer()) {
- delete pDIBitmap;
- m_pDeviceBitmap = nullptr;
- m_pFile = nullptr;
- return m_status = FXCODEC_STATUS_ERR_MEMORY;
- }
- ret = pTiffModule->Decode(m_pTiffContext, pDIBitmap);
- if (!ret) {
- delete pDIBitmap;
- m_pDeviceBitmap = nullptr;
- m_pFile = nullptr;
- return m_status = FXCODEC_STATUS_ERROR;
- }
- CFX_DIBitmap* pClipBitmap =
- (m_clipBox.left == 0 && m_clipBox.top == 0 &&
- m_clipBox.right == m_SrcWidth && m_clipBox.bottom == m_SrcHeight)
- ? pDIBitmap
- : pDIBitmap->Clone(&m_clipBox);
- if (pDIBitmap != pClipBitmap) {
- delete pDIBitmap;
- }
- if (!pClipBitmap) {
- m_pDeviceBitmap = nullptr;
- m_pFile = nullptr;
- return m_status = FXCODEC_STATUS_ERR_MEMORY;
- }
- CFX_DIBitmap* pFormatBitmap = nullptr;
- switch (m_pDeviceBitmap->GetFormat()) {
- case FXDIB_8bppRgb:
- pFormatBitmap = new CFX_DIBitmap;
- pFormatBitmap->Create(pClipBitmap->GetWidth(),
- pClipBitmap->GetHeight(), FXDIB_8bppRgb);
- break;
- case FXDIB_8bppMask:
- pFormatBitmap = new CFX_DIBitmap;
- pFormatBitmap->Create(pClipBitmap->GetWidth(),
- pClipBitmap->GetHeight(), FXDIB_8bppMask);
- break;
- case FXDIB_Rgb:
- pFormatBitmap = new CFX_DIBitmap;
- pFormatBitmap->Create(pClipBitmap->GetWidth(),
- pClipBitmap->GetHeight(), FXDIB_Rgb);
- break;
- case FXDIB_Rgb32:
- pFormatBitmap = new CFX_DIBitmap;
- pFormatBitmap->Create(pClipBitmap->GetWidth(),
- pClipBitmap->GetHeight(), FXDIB_Rgb32);
- break;
- case FXDIB_Argb:
- pFormatBitmap = pClipBitmap;
- break;
- default:
- break;
+ m_status = FXCODEC_STATUS_ERROR;
+ return m_status;
}
- switch (m_pDeviceBitmap->GetFormat()) {
- case FXDIB_8bppRgb:
- case FXDIB_8bppMask: {
- for (int32_t row = 0; row < pClipBitmap->GetHeight(); row++) {
- uint8_t* src_line = (uint8_t*)pClipBitmap->GetScanline(row);
- uint8_t* des_line = (uint8_t*)pFormatBitmap->GetScanline(row);
- for (int32_t col = 0; col < pClipBitmap->GetWidth(); col++) {
- uint8_t _a = 255 - src_line[3];
- uint8_t b = (src_line[0] * src_line[3] + 0xFF * _a) / 255;
- uint8_t g = (src_line[1] * src_line[3] + 0xFF * _a) / 255;
- uint8_t r = (src_line[2] * src_line[3] + 0xFF * _a) / 255;
- *des_line++ = FXRGB2GRAY(r, g, b);
- src_line += 4;
- }
+ m_status = FXCODEC_STATUS_DECODE_FINISH;
+ return m_status;
+ }
+
+ CFX_DIBitmap* pDIBitmap = new CFX_DIBitmap;
+ pDIBitmap->Create(m_SrcWidth, m_SrcHeight, FXDIB_Argb);
+ if (!pDIBitmap->GetBuffer()) {
+ delete pDIBitmap;
+ m_pDeviceBitmap = nullptr;
+ m_pFile = nullptr;
+ m_status = FXCODEC_STATUS_ERR_MEMORY;
+ return m_status;
+ }
+ ret = pTiffModule->Decode(m_pTiffContext, pDIBitmap);
+ if (!ret) {
+ delete pDIBitmap;
+ m_pDeviceBitmap = nullptr;
+ m_pFile = nullptr;
+ m_status = FXCODEC_STATUS_ERROR;
+ return m_status;
+ }
+ CFX_DIBitmap* pClipBitmap =
+ (m_clipBox.left == 0 && m_clipBox.top == 0 &&
+ m_clipBox.right == m_SrcWidth && m_clipBox.bottom == m_SrcHeight)
+ ? pDIBitmap
+ : pDIBitmap->Clone(&m_clipBox);
+ if (pDIBitmap != pClipBitmap) {
+ delete pDIBitmap;
+ }
+ if (!pClipBitmap) {
+ m_pDeviceBitmap = nullptr;
+ m_pFile = nullptr;
+ m_status = FXCODEC_STATUS_ERR_MEMORY;
+ return m_status;
+ }
+ CFX_DIBitmap* pFormatBitmap = nullptr;
+ switch (m_pDeviceBitmap->GetFormat()) {
+ case FXDIB_8bppRgb:
+ pFormatBitmap = new CFX_DIBitmap;
+ pFormatBitmap->Create(pClipBitmap->GetWidth(),
+ pClipBitmap->GetHeight(), FXDIB_8bppRgb);
+ break;
+ case FXDIB_8bppMask:
+ pFormatBitmap = new CFX_DIBitmap;
+ pFormatBitmap->Create(pClipBitmap->GetWidth(),
+ pClipBitmap->GetHeight(), FXDIB_8bppMask);
+ break;
+ case FXDIB_Rgb:
+ pFormatBitmap = new CFX_DIBitmap;
+ pFormatBitmap->Create(pClipBitmap->GetWidth(),
+ pClipBitmap->GetHeight(), FXDIB_Rgb);
+ break;
+ case FXDIB_Rgb32:
+ pFormatBitmap = new CFX_DIBitmap;
+ pFormatBitmap->Create(pClipBitmap->GetWidth(),
+ pClipBitmap->GetHeight(), FXDIB_Rgb32);
+ break;
+ case FXDIB_Argb:
+ pFormatBitmap = pClipBitmap;
+ break;
+ default:
+ break;
+ }
+ switch (m_pDeviceBitmap->GetFormat()) {
+ case FXDIB_8bppRgb:
+ case FXDIB_8bppMask: {
+ for (int32_t row = 0; row < pClipBitmap->GetHeight(); row++) {
+ uint8_t* src_line = (uint8_t*)pClipBitmap->GetScanline(row);
+ uint8_t* des_line = (uint8_t*)pFormatBitmap->GetScanline(row);
+ for (int32_t col = 0; col < pClipBitmap->GetWidth(); col++) {
+ uint8_t _a = 255 - src_line[3];
+ uint8_t b = (src_line[0] * src_line[3] + 0xFF * _a) / 255;
+ uint8_t g = (src_line[1] * src_line[3] + 0xFF * _a) / 255;
+ uint8_t r = (src_line[2] * src_line[3] + 0xFF * _a) / 255;
+ *des_line++ = FXRGB2GRAY(r, g, b);
+ src_line += 4;
}
- } break;
- case FXDIB_Rgb:
- case FXDIB_Rgb32: {
- int32_t desBpp =
- (m_pDeviceBitmap->GetFormat() == FXDIB_Rgb) ? 3 : 4;
- for (int32_t row = 0; row < pClipBitmap->GetHeight(); row++) {
- uint8_t* src_line = (uint8_t*)pClipBitmap->GetScanline(row);
- uint8_t* des_line = (uint8_t*)pFormatBitmap->GetScanline(row);
- for (int32_t col = 0; col < pClipBitmap->GetWidth(); col++) {
- uint8_t _a = 255 - src_line[3];
- uint8_t b = (src_line[0] * src_line[3] + 0xFF * _a) / 255;
- uint8_t g = (src_line[1] * src_line[3] + 0xFF * _a) / 255;
- uint8_t r = (src_line[2] * src_line[3] + 0xFF * _a) / 255;
- *des_line++ = b;
- *des_line++ = g;
- *des_line++ = r;
- des_line += desBpp - 3;
- src_line += 4;
- }
+ }
+ } break;
+ case FXDIB_Rgb:
+ case FXDIB_Rgb32: {
+ int32_t desBpp = (m_pDeviceBitmap->GetFormat() == FXDIB_Rgb) ? 3 : 4;
+ for (int32_t row = 0; row < pClipBitmap->GetHeight(); row++) {
+ uint8_t* src_line = (uint8_t*)pClipBitmap->GetScanline(row);
+ uint8_t* des_line = (uint8_t*)pFormatBitmap->GetScanline(row);
+ for (int32_t col = 0; col < pClipBitmap->GetWidth(); col++) {
+ uint8_t _a = 255 - src_line[3];
+ uint8_t b = (src_line[0] * src_line[3] + 0xFF * _a) / 255;
+ uint8_t g = (src_line[1] * src_line[3] + 0xFF * _a) / 255;
+ uint8_t r = (src_line[2] * src_line[3] + 0xFF * _a) / 255;
+ *des_line++ = b;
+ *des_line++ = g;
+ *des_line++ = r;
+ des_line += desBpp - 3;
+ src_line += 4;
}
- } break;
- default:
- break;
- }
- if (pClipBitmap != pFormatBitmap) {
- delete pClipBitmap;
- }
- if (!pFormatBitmap) {
- m_pDeviceBitmap = nullptr;
- m_pFile = nullptr;
- return m_status = FXCODEC_STATUS_ERR_MEMORY;
- }
- CFX_DIBitmap* pStrechBitmap = pFormatBitmap->StretchTo(
- m_sizeX, m_sizeY, m_bInterpol ? FXDIB_INTERPOL : FXDIB_DOWNSAMPLE);
- delete pFormatBitmap;
- pFormatBitmap = nullptr;
- if (!pStrechBitmap) {
- m_pDeviceBitmap = nullptr;
- m_pFile = nullptr;
- return m_status = FXCODEC_STATUS_ERR_MEMORY;
- }
- m_pDeviceBitmap->TransferBitmap(m_startX, m_startY, m_sizeX, m_sizeY,
- pStrechBitmap, 0, 0);
- delete pStrechBitmap;
- pStrechBitmap = nullptr;
+ }
+ } break;
+ default:
+ break;
+ }
+ if (pClipBitmap != pFormatBitmap) {
+ delete pClipBitmap;
+ }
+ if (!pFormatBitmap) {
m_pDeviceBitmap = nullptr;
m_pFile = nullptr;
- return m_status = FXCODEC_STATUS_DECODE_FINISH;
+ m_status = FXCODEC_STATUS_ERR_MEMORY;
+ return m_status;
}
- } break;
+ CFX_DIBitmap* pStrechBitmap = pFormatBitmap->StretchTo(
+ m_sizeX, m_sizeY, m_bInterpol ? FXDIB_INTERPOL : FXDIB_DOWNSAMPLE);
+ delete pFormatBitmap;
+ pFormatBitmap = nullptr;
+ if (!pStrechBitmap) {
+ m_pDeviceBitmap = nullptr;
+ m_pFile = nullptr;
+ m_status = FXCODEC_STATUS_ERR_MEMORY;
+ return m_status;
+ }
+ m_pDeviceBitmap->TransferBitmap(m_startX, m_startY, m_sizeX, m_sizeY,
+ pStrechBitmap, 0, 0);
+ delete pStrechBitmap;
+ pStrechBitmap = nullptr;
+ m_pDeviceBitmap = nullptr;
+ m_pFile = nullptr;
+ m_status = FXCODEC_STATUS_DECODE_FINISH;
+ return m_status;
+ }
default:
- break;
+ return FXCODEC_STATUS_ERROR;
}
- return FXCODEC_STATUS_ERROR;
}
+
CCodec_ProgressiveDecoder* CCodec_ModuleMgr::CreateProgressiveDecoder() {
return new CCodec_ProgressiveDecoder(this);
}
diff --git a/core/fxcodec/codec/fx_codec_tiff.cpp b/core/fxcodec/codec/fx_codec_tiff.cpp
index c8c94dbcdb..09cfea4111 100644
--- a/core/fxcodec/codec/fx_codec_tiff.cpp
+++ b/core/fxcodec/codec/fx_codec_tiff.cpp
@@ -12,250 +12,150 @@ extern "C" {
#include "third_party/libtiff/tiffiop.h"
}
-void* IccLib_CreateTransform_sRGB(const unsigned char* pProfileData,
- unsigned int dwProfileSize,
- int nComponents,
- int intent,
- uint32_t dwSrcFormat = Icc_FORMAT_DEFAULT);
-void IccLib_TranslateImage(void* pTransform,
- unsigned char* pDest,
- const unsigned char* pSrc,
- int pixels);
-void IccLib_DestroyTransform(void* pTransform);
class CCodec_TiffContext {
public:
CCodec_TiffContext();
~CCodec_TiffContext();
- FX_BOOL InitDecoder(IFX_FileRead* file_ptr);
- void GetFrames(int32_t& frames);
- FX_BOOL LoadFrameInfo(int32_t frame,
- uint32_t& width,
- uint32_t& height,
- uint32_t& comps,
- uint32_t& bpc,
- CFX_DIBAttribute* pAttribute);
- FX_BOOL Decode(CFX_DIBitmap* pDIBitmap);
-
- union {
- IFX_FileRead* in;
- IFX_FileStream* out;
- } io;
-
- uint32_t offset;
-
- TIFF* tif_ctx;
- void* icc_ctx;
- int32_t frame_num;
- int32_t frame_cur;
- FX_BOOL isDecoder;
+ bool InitDecoder(IFX_FileRead* file_ptr);
+ bool LoadFrameInfo(int32_t frame,
+ int32_t* width,
+ int32_t* height,
+ int32_t* comps,
+ int32_t* bpc,
+ CFX_DIBAttribute* pAttribute);
+ bool Decode(CFX_DIBitmap* pDIBitmap);
+
+ IFX_FileRead* io_in() const { return m_io_in; }
+ uint32_t offset() const { return m_offset; }
+ void set_offset(uint32_t offset) { m_offset = offset; }
+ void increment_offset(uint32_t offset) { m_offset += offset; }
private:
- FX_BOOL isSupport(CFX_DIBitmap* pDIBitmap);
+ bool IsSupport(const CFX_DIBitmap* pDIBitmap) const;
void SetPalette(CFX_DIBitmap* pDIBitmap, uint16_t bps);
- FX_BOOL Decode1bppRGB(CFX_DIBitmap* pDIBitmap,
- int32_t height,
- int32_t width,
- uint16_t bps,
- uint16_t spp);
- FX_BOOL Decode8bppRGB(CFX_DIBitmap* pDIBitmap,
- int32_t height,
- int32_t width,
- uint16_t bps,
- uint16_t spp);
- FX_BOOL Decode24bppRGB(CFX_DIBitmap* pDIBitmap,
- int32_t height,
- int32_t width,
- uint16_t bps,
- uint16_t spp);
+ bool Decode1bppRGB(CFX_DIBitmap* pDIBitmap,
+ int32_t height,
+ int32_t width,
+ uint16_t bps,
+ uint16_t spp);
+ bool Decode8bppRGB(CFX_DIBitmap* pDIBitmap,
+ int32_t height,
+ int32_t width,
+ uint16_t bps,
+ uint16_t spp);
+ bool Decode24bppRGB(CFX_DIBitmap* pDIBitmap,
+ int32_t height,
+ int32_t width,
+ uint16_t bps,
+ uint16_t spp);
+
+ IFX_FileRead* m_io_in;
+ uint32_t m_offset;
+ TIFF* m_tif_ctx;
};
-CCodec_TiffContext::CCodec_TiffContext() {
- offset = 0;
- frame_num = 0;
- frame_cur = 0;
- io.in = nullptr;
- tif_ctx = nullptr;
- icc_ctx = nullptr;
- isDecoder = TRUE;
+
+void* _TIFFmalloc(tmsize_t size) {
+ return FXMEM_DefaultAlloc(size, 0);
}
-CCodec_TiffContext::~CCodec_TiffContext() {
- if (icc_ctx) {
- IccLib_DestroyTransform(icc_ctx);
- icc_ctx = nullptr;
- }
- if (tif_ctx) {
- TIFFClose(tif_ctx);
- }
+
+void _TIFFfree(void* ptr) {
+ FXMEM_DefaultFree(ptr, 0);
}
-static tsize_t _tiff_read(thandle_t context, tdata_t buf, tsize_t length) {
- CCodec_TiffContext* pTiffContext = (CCodec_TiffContext*)context;
- FX_BOOL ret = FALSE;
- if (pTiffContext->isDecoder) {
- ret = pTiffContext->io.in->ReadBlock(buf, pTiffContext->offset, length);
- } else {
- ret = pTiffContext->io.out->ReadBlock(buf, pTiffContext->offset, length);
- }
- if (!ret) {
- return 0;
- }
- pTiffContext->offset += (uint32_t)length;
- return length;
+
+void* _TIFFrealloc(void* ptr, tmsize_t size) {
+ return FXMEM_DefaultRealloc(ptr, size, 0);
+}
+
+void _TIFFmemset(void* ptr, int val, tmsize_t size) {
+ FXSYS_memset(ptr, val, (size_t)size);
+}
+
+void _TIFFmemcpy(void* des, const void* src, tmsize_t size) {
+ FXSYS_memcpy(des, src, (size_t)size);
+}
+
+int _TIFFmemcmp(const void* ptr1, const void* ptr2, tmsize_t size) {
+ return FXSYS_memcmp(ptr1, ptr2, (size_t)size);
}
-static tsize_t _tiff_write(thandle_t context, tdata_t buf, tsize_t length) {
+
+TIFFErrorHandler _TIFFwarningHandler = nullptr;
+TIFFErrorHandler _TIFFerrorHandler = nullptr;
+
+namespace {
+
+tsize_t tiff_read(thandle_t context, tdata_t buf, tsize_t length) {
CCodec_TiffContext* pTiffContext = (CCodec_TiffContext*)context;
- ASSERT(!pTiffContext->isDecoder);
- if (!pTiffContext->io.out->WriteBlock(buf, pTiffContext->offset, length)) {
+ if (!pTiffContext->io_in()->ReadBlock(buf, pTiffContext->offset(), length))
return 0;
- }
- pTiffContext->offset += (uint32_t)length;
+
+ pTiffContext->increment_offset(length);
return length;
}
-static toff_t _tiff_seek(thandle_t context, toff_t offset, int whence) {
+
+tsize_t tiff_write(thandle_t context, tdata_t buf, tsize_t length) {
+ ASSERT(false);
+ return 0;
+}
+
+toff_t tiff_seek(thandle_t context, toff_t offset, int whence) {
CCodec_TiffContext* pTiffContext = (CCodec_TiffContext*)context;
switch (whence) {
case 0:
- pTiffContext->offset = (uint32_t)offset;
+ pTiffContext->set_offset(offset);
break;
case 1:
- pTiffContext->offset += (uint32_t)offset;
+ pTiffContext->increment_offset(offset);
break;
case 2:
- if (pTiffContext->isDecoder) {
- if (pTiffContext->io.in->GetSize() < (FX_FILESIZE)offset) {
- return static_cast<toff_t>(-1);
- }
- pTiffContext->offset =
- (uint32_t)(pTiffContext->io.in->GetSize() - offset);
- } else {
- if (pTiffContext->io.out->GetSize() < (FX_FILESIZE)offset) {
- return static_cast<toff_t>(-1);
- }
- pTiffContext->offset =
- (uint32_t)(pTiffContext->io.out->GetSize() - offset);
- }
+ if (pTiffContext->io_in()->GetSize() < (FX_FILESIZE)offset)
+ return static_cast<toff_t>(-1);
+ pTiffContext->set_offset(pTiffContext->io_in()->GetSize() - offset);
break;
default:
return static_cast<toff_t>(-1);
}
- ASSERT(pTiffContext->isDecoder ? (pTiffContext->offset <=
- (uint32_t)pTiffContext->io.in->GetSize())
- : TRUE);
- return pTiffContext->offset;
+ ASSERT(pTiffContext->offset() <= (uint32_t)pTiffContext->io_in()->GetSize());
+ return pTiffContext->offset();
}
-static int _tiff_close(thandle_t context) {
+
+int tiff_close(thandle_t context) {
return 0;
}
-static toff_t _tiff_get_size(thandle_t context) {
+
+toff_t tiff_get_size(thandle_t context) {
CCodec_TiffContext* pTiffContext = (CCodec_TiffContext*)context;
- return pTiffContext->isDecoder ? (toff_t)pTiffContext->io.in->GetSize()
- : (toff_t)pTiffContext->io.out->GetSize();
+ return (toff_t)pTiffContext->io_in()->GetSize();
}
-static int _tiff_map(thandle_t context, tdata_t*, toff_t*) {
+
+int tiff_map(thandle_t context, tdata_t*, toff_t*) {
return 0;
}
-static void _tiff_unmap(thandle_t context, tdata_t, toff_t) {}
-TIFF* _tiff_open(void* context, const char* mode) {
- TIFF* tif = TIFFClientOpen("Tiff Image", mode, (thandle_t)context, _tiff_read,
- _tiff_write, _tiff_seek, _tiff_close,
- _tiff_get_size, _tiff_map, _tiff_unmap);
+
+void tiff_unmap(thandle_t context, tdata_t, toff_t) {}
+
+TIFF* tiff_open(void* context, const char* mode) {
+ TIFF* tif = TIFFClientOpen("Tiff Image", mode, (thandle_t)context, tiff_read,
+ tiff_write, tiff_seek, tiff_close, tiff_get_size,
+ tiff_map, tiff_unmap);
if (tif) {
tif->tif_fd = (int)(intptr_t)context;
}
return tif;
}
-void* _TIFFmalloc(tmsize_t size) {
- return FXMEM_DefaultAlloc(size, 0);
-}
-void _TIFFfree(void* ptr) {
- FXMEM_DefaultFree(ptr, 0);
-}
-void* _TIFFrealloc(void* ptr, tmsize_t size) {
- return FXMEM_DefaultRealloc(ptr, size, 0);
-}
-void _TIFFmemset(void* ptr, int val, tmsize_t size) {
- FXSYS_memset(ptr, val, (size_t)size);
-}
-void _TIFFmemcpy(void* des, const void* src, tmsize_t size) {
- FXSYS_memcpy(des, src, (size_t)size);
-}
-int _TIFFmemcmp(const void* ptr1, const void* ptr2, tmsize_t size) {
- return FXSYS_memcmp(ptr1, ptr2, (size_t)size);
-}
-
-TIFFErrorHandler _TIFFwarningHandler = nullptr;
-TIFFErrorHandler _TIFFerrorHandler = nullptr;
-
-int TIFFCmyk2Rgb(thandle_t context,
- uint8 c,
- uint8 m,
- uint8 y,
- uint8 k,
- uint8* r,
- uint8* g,
- uint8* b) {
- if (!context)
- return 0;
-
- CCodec_TiffContext* p = (CCodec_TiffContext*)context;
- if (p->icc_ctx) {
- unsigned char cmyk[4], bgr[3];
- cmyk[0] = c, cmyk[1] = m, cmyk[2] = y, cmyk[3] = k;
- IccLib_TranslateImage(p->icc_ctx, bgr, cmyk, 1);
- *r = bgr[2], *g = bgr[1], *b = bgr[0];
- } else {
- AdobeCMYK_to_sRGB1(c, m, y, k, *r, *g, *b);
- }
- return 1;
-}
-FX_BOOL CCodec_TiffContext::InitDecoder(IFX_FileRead* file_ptr) {
- io.in = file_ptr;
- return !!_tiff_open(this, "r");
-}
-void CCodec_TiffContext::GetFrames(int32_t& frames) {
- frames = frame_num = TIFFNumberOfDirectories(tif_ctx);
-}
-#define TIFF_EXIF_GETINFO(key, T, tag) \
- { \
- T val = (T)0; \
- TIFFGetField(tif_ctx, tag, &val); \
- if (val) { \
- (key) = FX_Alloc(uint8_t, sizeof(T)); \
- if ((key)) { \
- T* ptr = (T*)(key); \
- *ptr = val; \
- pExif->m_TagVal.SetAt(tag, (key)); \
- } \
- } \
- } \
- (key) = nullptr;
-#define TIFF_EXIF_GETSTRINGINFO(key, tag) \
- { \
- uint32_t size = 0; \
- uint8_t* buf = nullptr; \
- TIFFGetField(tif_ctx, tag, &size, &buf); \
- if (size && buf) { \
- (key) = FX_Alloc(uint8_t, size); \
- if ((key)) { \
- FXSYS_memcpy((key), buf, size); \
- pExif->m_TagVal.SetAt(tag, (key)); \
- } \
- } \
- } \
- (key) = nullptr;
-
-namespace {
template <class T>
-FX_BOOL Tiff_Exif_GetInfo(TIFF* tif_ctx, ttag_t tag, CFX_DIBAttribute* pAttr) {
+bool Tiff_Exif_GetInfo(TIFF* tif_ctx, ttag_t tag, CFX_DIBAttribute* pAttr) {
T val = 0;
TIFFGetField(tif_ctx, tag, &val);
if (!val)
- return FALSE;
+ return false;
T* ptr = FX_Alloc(T, 1);
*ptr = val;
pAttr->m_Exif[tag] = (void*)ptr;
- return TRUE;
+ return true;
}
+
void Tiff_Exif_GetStringInfo(TIFF* tif_ctx,
ttag_t tag,
CFX_DIBAttribute* pAttr) {
@@ -270,102 +170,120 @@ void Tiff_Exif_GetStringInfo(TIFF* tif_ctx,
pAttr->m_Exif[tag] = ptr;
}
+void TiffBGRA2RGBA(uint8_t* pBuf, int32_t pixel, int32_t spp) {
+ for (int32_t n = 0; n < pixel; n++) {
+ uint8_t tmp = pBuf[0];
+ pBuf[0] = pBuf[2];
+ pBuf[2] = tmp;
+ pBuf += spp;
+ }
+}
+
} // namespace
-FX_BOOL CCodec_TiffContext::LoadFrameInfo(int32_t frame,
- uint32_t& width,
- uint32_t& height,
- uint32_t& comps,
- uint32_t& bpc,
- CFX_DIBAttribute* pAttribute) {
- if (!TIFFSetDirectory(tif_ctx, (uint16)frame)) {
- return FALSE;
- }
- uint16_t tif_cs;
- uint32_t tif_icc_size = 0;
- uint8_t* tif_icc_buf = nullptr;
+CCodec_TiffContext::CCodec_TiffContext()
+ : m_io_in(nullptr), m_offset(0), m_tif_ctx(nullptr) {}
+
+CCodec_TiffContext::~CCodec_TiffContext() {
+ if (m_tif_ctx)
+ TIFFClose(m_tif_ctx);
+}
+
+bool CCodec_TiffContext::InitDecoder(IFX_FileRead* file_ptr) {
+ m_io_in = file_ptr;
+ m_tif_ctx = tiff_open(this, "r");
+ return !!m_tif_ctx;
+}
+
+bool CCodec_TiffContext::LoadFrameInfo(int32_t frame,
+ int32_t* width,
+ int32_t* height,
+ int32_t* comps,
+ int32_t* bpc,
+ CFX_DIBAttribute* pAttribute) {
+ if (!TIFFSetDirectory(m_tif_ctx, (uint16)frame))
+ return false;
+
+ uint32_t tif_width = 0;
+ uint32_t tif_height = 0;
+ uint16_t tif_comps = 0;
uint16_t tif_bpc = 0;
- uint16_t tif_cps;
- uint32_t tif_rps;
- width = height = comps = 0;
- TIFFGetField(tif_ctx, TIFFTAG_IMAGEWIDTH, &width);
- TIFFGetField(tif_ctx, TIFFTAG_IMAGELENGTH, &height);
- TIFFGetField(tif_ctx, TIFFTAG_SAMPLESPERPIXEL, &comps);
- TIFFGetField(tif_ctx, TIFFTAG_BITSPERSAMPLE, &tif_bpc);
- TIFFGetField(tif_ctx, TIFFTAG_PHOTOMETRIC, &tif_cs);
- TIFFGetField(tif_ctx, TIFFTAG_COMPRESSION, &tif_cps);
- TIFFGetField(tif_ctx, TIFFTAG_ROWSPERSTRIP, &tif_rps);
- TIFFGetField(tif_ctx, TIFFTAG_ICCPROFILE, &tif_icc_size, &tif_icc_buf);
+ uint32_t tif_rps = 0;
+ TIFFGetField(m_tif_ctx, TIFFTAG_IMAGEWIDTH, &tif_width);
+ TIFFGetField(m_tif_ctx, TIFFTAG_IMAGELENGTH, &tif_height);
+ TIFFGetField(m_tif_ctx, TIFFTAG_SAMPLESPERPIXEL, &tif_comps);
+ TIFFGetField(m_tif_ctx, TIFFTAG_BITSPERSAMPLE, &tif_bpc);
+ TIFFGetField(m_tif_ctx, TIFFTAG_ROWSPERSTRIP, &tif_rps);
+
if (pAttribute) {
pAttribute->m_wDPIUnit = FXCODEC_RESUNIT_INCH;
- if (TIFFGetField(tif_ctx, TIFFTAG_RESOLUTIONUNIT,
+ if (TIFFGetField(m_tif_ctx, TIFFTAG_RESOLUTIONUNIT,
&pAttribute->m_wDPIUnit)) {
- pAttribute->m_wDPIUnit -= 1;
+ pAttribute->m_wDPIUnit--;
}
- Tiff_Exif_GetInfo<uint16_t>(tif_ctx, TIFFTAG_ORIENTATION, pAttribute);
- if (Tiff_Exif_GetInfo<FX_FLOAT>(tif_ctx, TIFFTAG_XRESOLUTION, pAttribute)) {
+ Tiff_Exif_GetInfo<uint16_t>(m_tif_ctx, TIFFTAG_ORIENTATION, pAttribute);
+ if (Tiff_Exif_GetInfo<FX_FLOAT>(m_tif_ctx, TIFFTAG_XRESOLUTION,
+ pAttribute)) {
void* val = pAttribute->m_Exif[TIFFTAG_XRESOLUTION];
FX_FLOAT fDpi = val ? *reinterpret_cast<FX_FLOAT*>(val) : 0;
pAttribute->m_nXDPI = (int32_t)(fDpi + 0.5f);
}
- if (Tiff_Exif_GetInfo<FX_FLOAT>(tif_ctx, TIFFTAG_YRESOLUTION, pAttribute)) {
+ if (Tiff_Exif_GetInfo<FX_FLOAT>(m_tif_ctx, TIFFTAG_YRESOLUTION,
+ pAttribute)) {
void* val = pAttribute->m_Exif[TIFFTAG_YRESOLUTION];
FX_FLOAT fDpi = val ? *reinterpret_cast<FX_FLOAT*>(val) : 0;
pAttribute->m_nYDPI = (int32_t)(fDpi + 0.5f);
}
- Tiff_Exif_GetStringInfo(tif_ctx, TIFFTAG_IMAGEDESCRIPTION, pAttribute);
- Tiff_Exif_GetStringInfo(tif_ctx, TIFFTAG_MAKE, pAttribute);
- Tiff_Exif_GetStringInfo(tif_ctx, TIFFTAG_MODEL, pAttribute);
+ Tiff_Exif_GetStringInfo(m_tif_ctx, TIFFTAG_IMAGEDESCRIPTION, pAttribute);
+ Tiff_Exif_GetStringInfo(m_tif_ctx, TIFFTAG_MAKE, pAttribute);
+ Tiff_Exif_GetStringInfo(m_tif_ctx, TIFFTAG_MODEL, pAttribute);
}
- bpc = tif_bpc;
- if (tif_rps > height) {
- TIFFSetField(tif_ctx, TIFFTAG_ROWSPERSTRIP, tif_rps = height);
- }
- return TRUE;
-}
-void _TiffBGRA2RGBA(uint8_t* pBuf, int32_t pixel, int32_t spp) {
- for (int32_t n = 0; n < pixel; n++) {
- uint8_t tmp = pBuf[0];
- pBuf[0] = pBuf[2];
- pBuf[2] = tmp;
- pBuf += spp;
+ *width = pdfium::base::checked_cast<int32_t>(tif_width);
+ *height = pdfium::base::checked_cast<int32_t>(tif_height);
+ *comps = tif_comps;
+ *bpc = tif_bpc;
+ if (tif_rps > tif_height) {
+ tif_rps = tif_height;
+ TIFFSetField(m_tif_ctx, TIFFTAG_ROWSPERSTRIP, tif_rps);
}
+ return true;
}
-FX_BOOL CCodec_TiffContext::isSupport(CFX_DIBitmap* pDIBitmap) {
- if (TIFFIsTiled(tif_ctx)) {
- return FALSE;
- }
+
+bool CCodec_TiffContext::IsSupport(const CFX_DIBitmap* pDIBitmap) const {
+ if (TIFFIsTiled(m_tif_ctx))
+ return false;
+
uint16_t photometric;
- if (!TIFFGetField(tif_ctx, TIFFTAG_PHOTOMETRIC, &photometric)) {
- return FALSE;
- }
+ if (!TIFFGetField(m_tif_ctx, TIFFTAG_PHOTOMETRIC, &photometric))
+ return false;
+
switch (pDIBitmap->GetBPP()) {
case 1:
case 8:
if (photometric != PHOTOMETRIC_PALETTE) {
- return FALSE;
+ return false;
}
break;
case 24:
if (photometric != PHOTOMETRIC_RGB) {
- return FALSE;
+ return false;
}
break;
default:
- return FALSE;
+ return false;
}
uint16_t planarconfig;
- if (!TIFFGetFieldDefaulted(tif_ctx, TIFFTAG_PLANARCONFIG, &planarconfig)) {
- return FALSE;
- }
- if (planarconfig == PLANARCONFIG_SEPARATE) {
- return FALSE;
- }
- return TRUE;
+ if (!TIFFGetFieldDefaulted(m_tif_ctx, TIFFTAG_PLANARCONFIG, &planarconfig))
+ return false;
+
+ return planarconfig != PLANARCONFIG_SEPARATE;
}
+
void CCodec_TiffContext::SetPalette(CFX_DIBitmap* pDIBitmap, uint16_t bps) {
- uint16_t *red_orig, *green_orig, *blue_orig;
- TIFFGetField(tif_ctx, TIFFTAG_COLORMAP, &red_orig, &green_orig, &blue_orig);
+ uint16_t* red_orig;
+ uint16_t* green_orig;
+ uint16_t* blue_orig;
+ TIFFGetField(m_tif_ctx, TIFFTAG_COLORMAP, &red_orig, &green_orig, &blue_orig);
for (int32_t i = (1L << bps) - 1; i >= 0; i--) {
#define CVT(x) ((uint16_t)((x) >> 8))
red_orig[i] = CVT(red_orig[i]);
@@ -383,53 +301,55 @@ void CCodec_TiffContext::SetPalette(CFX_DIBitmap* pDIBitmap, uint16_t bps) {
pDIBitmap->SetPaletteEntry(index, color);
}
}
-FX_BOOL CCodec_TiffContext::Decode1bppRGB(CFX_DIBitmap* pDIBitmap,
- int32_t height,
- int32_t width,
- uint16_t bps,
- uint16_t spp) {
+
+bool CCodec_TiffContext::Decode1bppRGB(CFX_DIBitmap* pDIBitmap,
+ int32_t height,
+ int32_t width,
+ uint16_t bps,
+ uint16_t spp) {
if (pDIBitmap->GetBPP() != 1 || spp != 1 || bps != 1 ||
- !isSupport(pDIBitmap)) {
- return FALSE;
+ !IsSupport(pDIBitmap)) {
+ return false;
}
SetPalette(pDIBitmap, bps);
- int32_t size = (int32_t)TIFFScanlineSize(tif_ctx);
+ int32_t size = (int32_t)TIFFScanlineSize(m_tif_ctx);
uint8_t* buf = (uint8_t*)_TIFFmalloc(size);
if (!buf) {
- TIFFError(TIFFFileName(tif_ctx), "No space for scanline buffer");
- return FALSE;
+ TIFFError(TIFFFileName(m_tif_ctx), "No space for scanline buffer");
+ return false;
}
uint8_t* bitMapbuffer = (uint8_t*)pDIBitmap->GetBuffer();
uint32_t pitch = pDIBitmap->GetPitch();
for (int32_t row = 0; row < height; row++) {
- TIFFReadScanline(tif_ctx, buf, row, 0);
+ TIFFReadScanline(m_tif_ctx, buf, row, 0);
for (int32_t j = 0; j < size; j++) {
bitMapbuffer[row * pitch + j] = buf[j];
}
}
_TIFFfree(buf);
- return TRUE;
+ return true;
}
-FX_BOOL CCodec_TiffContext::Decode8bppRGB(CFX_DIBitmap* pDIBitmap,
- int32_t height,
- int32_t width,
- uint16_t bps,
- uint16_t spp) {
+
+bool CCodec_TiffContext::Decode8bppRGB(CFX_DIBitmap* pDIBitmap,
+ int32_t height,
+ int32_t width,
+ uint16_t bps,
+ uint16_t spp) {
if (pDIBitmap->GetBPP() != 8 || spp != 1 || (bps != 4 && bps != 8) ||
- !isSupport(pDIBitmap)) {
- return FALSE;
+ !IsSupport(pDIBitmap)) {
+ return false;
}
SetPalette(pDIBitmap, bps);
- int32_t size = (int32_t)TIFFScanlineSize(tif_ctx);
+ int32_t size = (int32_t)TIFFScanlineSize(m_tif_ctx);
uint8_t* buf = (uint8_t*)_TIFFmalloc(size);
if (!buf) {
- TIFFError(TIFFFileName(tif_ctx), "No space for scanline buffer");
- return FALSE;
+ TIFFError(TIFFFileName(m_tif_ctx), "No space for scanline buffer");
+ return false;
}
uint8_t* bitMapbuffer = (uint8_t*)pDIBitmap->GetBuffer();
uint32_t pitch = pDIBitmap->GetPitch();
for (int32_t row = 0; row < height; row++) {
- TIFFReadScanline(tif_ctx, buf, row, 0);
+ TIFFReadScanline(m_tif_ctx, buf, row, 0);
for (int32_t j = 0; j < size; j++) {
switch (bps) {
case 4:
@@ -443,26 +363,27 @@ FX_BOOL CCodec_TiffContext::Decode8bppRGB(CFX_DIBitmap* pDIBitmap,
}
}
_TIFFfree(buf);
- return TRUE;
+ return true;
}
-FX_BOOL CCodec_TiffContext::Decode24bppRGB(CFX_DIBitmap* pDIBitmap,
- int32_t height,
- int32_t width,
- uint16_t bps,
- uint16_t spp) {
- if (pDIBitmap->GetBPP() != 24 || !isSupport(pDIBitmap)) {
- return FALSE;
- }
- int32_t size = (int32_t)TIFFScanlineSize(tif_ctx);
+
+bool CCodec_TiffContext::Decode24bppRGB(CFX_DIBitmap* pDIBitmap,
+ int32_t height,
+ int32_t width,
+ uint16_t bps,
+ uint16_t spp) {
+ if (pDIBitmap->GetBPP() != 24 || !IsSupport(pDIBitmap))
+ return false;
+
+ int32_t size = (int32_t)TIFFScanlineSize(m_tif_ctx);
uint8_t* buf = (uint8_t*)_TIFFmalloc(size);
if (!buf) {
- TIFFError(TIFFFileName(tif_ctx), "No space for scanline buffer");
- return FALSE;
+ TIFFError(TIFFFileName(m_tif_ctx), "No space for scanline buffer");
+ return false;
}
uint8_t* bitMapbuffer = (uint8_t*)pDIBitmap->GetBuffer();
uint32_t pitch = pDIBitmap->GetPitch();
for (int32_t row = 0; row < height; row++) {
- TIFFReadScanline(tif_ctx, buf, row, 0);
+ TIFFReadScanline(m_tif_ctx, buf, row, 0);
for (int32_t j = 0; j < size - 2; j += 3) {
bitMapbuffer[row * pitch + j + 0] = buf[j + 2];
bitMapbuffer[row * pitch + j + 1] = buf[j + 1];
@@ -470,43 +391,44 @@ FX_BOOL CCodec_TiffContext::Decode24bppRGB(CFX_DIBitmap* pDIBitmap,
}
}
_TIFFfree(buf);
- return TRUE;
+ return true;
}
-FX_BOOL CCodec_TiffContext::Decode(CFX_DIBitmap* pDIBitmap) {
+
+bool CCodec_TiffContext::Decode(CFX_DIBitmap* pDIBitmap) {
uint32_t img_wid = pDIBitmap->GetWidth();
uint32_t img_hei = pDIBitmap->GetHeight();
uint32_t width = 0;
uint32_t height = 0;
- TIFFGetField(tif_ctx, TIFFTAG_IMAGEWIDTH, &width);
- TIFFGetField(tif_ctx, TIFFTAG_IMAGELENGTH, &height);
- if (img_wid != width || img_hei != height) {
- return FALSE;
- }
+ TIFFGetField(m_tif_ctx, TIFFTAG_IMAGEWIDTH, &width);
+ TIFFGetField(m_tif_ctx, TIFFTAG_IMAGELENGTH, &height);
+ if (img_wid != width || img_hei != height)
+ return false;
+
if (pDIBitmap->GetBPP() == 32) {
uint16_t rotation = ORIENTATION_TOPLEFT;
- TIFFGetField(tif_ctx, TIFFTAG_ORIENTATION, &rotation);
- if (TIFFReadRGBAImageOriented(tif_ctx, img_wid, img_hei,
+ TIFFGetField(m_tif_ctx, TIFFTAG_ORIENTATION, &rotation);
+ if (TIFFReadRGBAImageOriented(m_tif_ctx, img_wid, img_hei,
(uint32*)pDIBitmap->GetBuffer(), rotation,
1)) {
for (uint32_t row = 0; row < img_hei; row++) {
uint8_t* row_buf = (uint8_t*)pDIBitmap->GetScanline(row);
- _TiffBGRA2RGBA(row_buf, img_wid, 4);
+ TiffBGRA2RGBA(row_buf, img_wid, 4);
}
- return TRUE;
+ return true;
}
}
- uint16_t spp, bps;
- TIFFGetField(tif_ctx, TIFFTAG_SAMPLESPERPIXEL, &spp);
- TIFFGetField(tif_ctx, TIFFTAG_BITSPERSAMPLE, &bps);
+ uint16_t spp;
+ uint16_t bps;
+ TIFFGetField(m_tif_ctx, TIFFTAG_SAMPLESPERPIXEL, &spp);
+ TIFFGetField(m_tif_ctx, TIFFTAG_BITSPERSAMPLE, &bps);
uint32_t bpp = bps * spp;
- if (bpp == 1) {
+ if (bpp == 1)
return Decode1bppRGB(pDIBitmap, height, width, bps, spp);
- } else if (bpp <= 8) {
+ if (bpp <= 8)
return Decode8bppRGB(pDIBitmap, height, width, bps, spp);
- } else if (bpp <= 24) {
+ if (bpp <= 24)
return Decode24bppRGB(pDIBitmap, height, width, bps, spp);
- }
- return FALSE;
+ return false;
}
CCodec_TiffContext* CCodec_TiffModule::CreateDecoder(IFX_FileRead* file_ptr) {
@@ -518,22 +440,18 @@ CCodec_TiffContext* CCodec_TiffModule::CreateDecoder(IFX_FileRead* file_ptr) {
return pDecoder;
}
-void CCodec_TiffModule::GetFrames(CCodec_TiffContext* ctx, int32_t& frames) {
- ctx->GetFrames(frames);
-}
-
-FX_BOOL CCodec_TiffModule::LoadFrameInfo(CCodec_TiffContext* ctx,
- int32_t frame,
- uint32_t& width,
- uint32_t& height,
- uint32_t& comps,
- uint32_t& bpc,
- CFX_DIBAttribute* pAttribute) {
+bool CCodec_TiffModule::LoadFrameInfo(CCodec_TiffContext* ctx,
+ int32_t frame,
+ int32_t* width,
+ int32_t* height,
+ int32_t* comps,
+ int32_t* bpc,
+ CFX_DIBAttribute* pAttribute) {
return ctx->LoadFrameInfo(frame, width, height, comps, bpc, pAttribute);
}
-FX_BOOL CCodec_TiffModule::Decode(CCodec_TiffContext* ctx,
- class CFX_DIBitmap* pDIBitmap) {
+bool CCodec_TiffModule::Decode(CCodec_TiffContext* ctx,
+ class CFX_DIBitmap* pDIBitmap) {
return ctx->Decode(pDIBitmap);
}
diff --git a/core/fxcodec/codec/include/ccodec_progressivedecoder.h b/core/fxcodec/codec/include/ccodec_progressivedecoder.h
index 5421d73494..5774371ff1 100644
--- a/core/fxcodec/codec/include/ccodec_progressivedecoder.h
+++ b/core/fxcodec/codec/include/ccodec_progressivedecoder.h
@@ -7,6 +7,8 @@
#ifndef CORE_FXCODEC_CODEC_INCLUDE_CCODEC_PROGRESSIVEDECODER_H_
#define CORE_FXCODEC_CODEC_INCLUDE_CCODEC_PROGRESSIVEDECODER_H_
+#include <vector>
+
#include "core/fxcodec/include/fx_codec_def.h"
#include "core/fxcrt/include/fx_system.h"
#include "core/fxge/include/fx_dib.h"
@@ -40,7 +42,7 @@ class CCodec_ProgressiveDecoder {
FXCodec_Cmyk = 0x120
};
- CCodec_ProgressiveDecoder(CCodec_ModuleMgr* pCodecMgr);
+ explicit CCodec_ProgressiveDecoder(CCodec_ModuleMgr* pCodecMgr);
~CCodec_ProgressiveDecoder();
FXCODEC_STATUS LoadImageInfo(IFX_FileRead* pFile,
@@ -73,8 +75,8 @@ class CCodec_ProgressiveDecoder {
class CFXCODEC_WeightTable {
public:
- CFXCODEC_WeightTable() { m_pWeightTables = nullptr; }
- ~CFXCODEC_WeightTable() { FX_Free(m_pWeightTables); }
+ CFXCODEC_WeightTable() {}
+ ~CFXCODEC_WeightTable() {}
void Calc(int dest_len,
int dest_min,
@@ -84,37 +86,41 @@ class CCodec_ProgressiveDecoder {
int src_max,
FX_BOOL bInterpol);
PixelWeight* GetPixelWeight(int pixel) {
- return (PixelWeight*)(m_pWeightTables + (pixel - m_DestMin) * m_ItemSize);
+ return reinterpret_cast<PixelWeight*>(m_pWeightTables.data() +
+ (pixel - m_DestMin) * m_ItemSize);
}
- int m_DestMin, m_ItemSize;
- uint8_t* m_pWeightTables;
+ int m_DestMin;
+ int m_ItemSize;
+ std::vector<uint8_t> m_pWeightTables;
};
class CFXCODEC_HorzTable {
public:
- CFXCODEC_HorzTable() { m_pWeightTables = nullptr; }
- ~CFXCODEC_HorzTable() { FX_Free(m_pWeightTables); }
+ CFXCODEC_HorzTable() {}
+ ~CFXCODEC_HorzTable() {}
void Calc(int dest_len, int src_len, FX_BOOL bInterpol);
PixelWeight* GetPixelWeight(int pixel) {
- return (PixelWeight*)(m_pWeightTables + pixel * m_ItemSize);
+ return reinterpret_cast<PixelWeight*>(m_pWeightTables.data() +
+ pixel * m_ItemSize);
}
int m_ItemSize;
- uint8_t* m_pWeightTables;
+ std::vector<uint8_t> m_pWeightTables;
};
class CFXCODEC_VertTable {
public:
- CFXCODEC_VertTable() { m_pWeightTables = nullptr; }
- ~CFXCODEC_VertTable() { FX_Free(m_pWeightTables); }
+ CFXCODEC_VertTable() {}
+ ~CFXCODEC_VertTable() {}
void Calc(int dest_len, int src_len);
PixelWeight* GetPixelWeight(int pixel) {
- return (PixelWeight*)(m_pWeightTables + pixel * m_ItemSize);
+ return reinterpret_cast<PixelWeight*>(m_pWeightTables.data() +
+ pixel * m_ItemSize);
}
int m_ItemSize;
- uint8_t* m_pWeightTables;
+ std::vector<uint8_t> m_pWeightTables;
};
IFX_FileRead* m_pFile;
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-16 09:52:34 +0000