| // Copyright 2014 PDFium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com |
| |
| #include "core/fxcodec/codec/codec_int.h" |
| #include "core/include/fxcodec/fx_codec.h" |
| #include "core/include/fxge/fx_dib.h" |
| |
| 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; |
| |
| private: |
| FX_BOOL isSupport(CFX_DIBitmap* pDIBitmap); |
| 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); |
| }; |
| CCodec_TiffContext::CCodec_TiffContext() { |
| offset = 0; |
| frame_num = 0; |
| frame_cur = 0; |
| io.in = NULL; |
| tif_ctx = NULL; |
| icc_ctx = NULL; |
| isDecoder = TRUE; |
| } |
| CCodec_TiffContext::~CCodec_TiffContext() { |
| if (icc_ctx) { |
| IccLib_DestroyTransform(icc_ctx); |
| icc_ctx = NULL; |
| } |
| if (tif_ctx) { |
| TIFFClose(tif_ctx); |
| } |
| } |
| 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; |
| } |
| static tsize_t _tiff_write(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)) { |
| return 0; |
| } |
| pTiffContext->offset += (uint32_t)length; |
| return length; |
| } |
| static 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; |
| break; |
| case 1: |
| pTiffContext->offset += (uint32_t)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); |
| } |
| break; |
| default: |
| return static_cast<toff_t>(-1); |
| } |
| ASSERT(pTiffContext->isDecoder ? (pTiffContext->offset <= |
| (uint32_t)pTiffContext->io.in->GetSize()) |
| : TRUE); |
| return pTiffContext->offset; |
| } |
| static int _tiff_close(thandle_t context) { |
| return 0; |
| } |
| static 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(); |
| } |
| static 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); |
| 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 == NULL) { |
| 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; |
| tif_ctx = _tiff_open(this, "r"); |
| if (tif_ctx == NULL) { |
| return FALSE; |
| } |
| return TRUE; |
| } |
| 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) = NULL; |
| #define TIFF_EXIF_GETSTRINGINFO(key, tag) \ |
| { \ |
| uint32_t size = 0; \ |
| uint8_t* buf = NULL; \ |
| 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) = NULL; |
| |
| namespace { |
| |
| template <class T> |
| FX_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; |
| T* ptr = FX_Alloc(T, 1); |
| *ptr = val; |
| pAttr->m_Exif[tag] = (void*)ptr; |
| return TRUE; |
| } |
| void Tiff_Exif_GetStringInfo(TIFF* tif_ctx, |
| ttag_t tag, |
| CFX_DIBAttribute* pAttr) { |
| FX_CHAR* buf = nullptr; |
| TIFFGetField(tif_ctx, tag, &buf); |
| if (!buf) |
| return; |
| FX_STRSIZE size = FXSYS_strlen(buf); |
| uint8_t* ptr = FX_Alloc(uint8_t, size + 1); |
| FXSYS_memcpy(ptr, buf, size); |
| ptr[size] = 0; |
| pAttr->m_Exif[tag] = ptr; |
| } |
| |
| } // 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 = NULL; |
| 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); |
| if (pAttribute) { |
| pAttribute->m_wDPIUnit = FXCODEC_RESUNIT_INCH; |
| if (TIFFGetField(tif_ctx, TIFFTAG_RESOLUTIONUNIT, |
| &pAttribute->m_wDPIUnit)) { |
| pAttribute->m_wDPIUnit -= 1; |
| } |
| Tiff_Exif_GetInfo<uint16_t>(tif_ctx, TIFFTAG_ORIENTATION, pAttribute); |
| if (Tiff_Exif_GetInfo<FX_FLOAT>(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)) { |
| 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); |
| } |
| 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; |
| } |
| } |
| FX_BOOL CCodec_TiffContext::isSupport(CFX_DIBitmap* pDIBitmap) { |
| if (TIFFIsTiled(tif_ctx)) { |
| return FALSE; |
| } |
| uint16_t photometric; |
| if (!TIFFGetField(tif_ctx, TIFFTAG_PHOTOMETRIC, &photometric)) { |
| return FALSE; |
| } |
| switch (pDIBitmap->GetBPP()) { |
| case 1: |
| case 8: |
| if (photometric != PHOTOMETRIC_PALETTE) { |
| return FALSE; |
| } |
| break; |
| case 24: |
| if (photometric != PHOTOMETRIC_RGB) { |
| return FALSE; |
| } |
| break; |
| default: |
| return FALSE; |
| } |
| uint16_t planarconfig; |
| if (!TIFFGetFieldDefaulted(tif_ctx, TIFFTAG_PLANARCONFIG, &planarconfig)) { |
| return FALSE; |
| } |
| if (planarconfig == PLANARCONFIG_SEPARATE) { |
| return FALSE; |
| } |
| return TRUE; |
| } |
| 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); |
| for (int32_t i = (1L << bps) - 1; i >= 0; i--) { |
| #define CVT(x) ((uint16_t)((x) >> 8)) |
| red_orig[i] = CVT(red_orig[i]); |
| green_orig[i] = CVT(green_orig[i]); |
| blue_orig[i] = CVT(blue_orig[i]); |
| #undef CVT |
| } |
| int32_t len = 1 << bps; |
| for (int32_t index = 0; index < len; index++) { |
| uint32_t r = red_orig[index] & 0xFF; |
| uint32_t g = green_orig[index] & 0xFF; |
| uint32_t b = blue_orig[index] & 0xFF; |
| uint32_t color = (uint32_t)b | ((uint32_t)g << 8) | ((uint32_t)r << 16) | |
| (((uint32)0xffL) << 24); |
| pDIBitmap->SetPaletteEntry(index, color); |
| } |
| } |
| FX_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; |
| } |
| SetPalette(pDIBitmap, bps); |
| int32_t size = (int32_t)TIFFScanlineSize(tif_ctx); |
| uint8_t* buf = (uint8_t*)_TIFFmalloc(size); |
| if (buf == NULL) { |
| TIFFError(TIFFFileName(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); |
| for (int32_t j = 0; j < size; j++) { |
| bitMapbuffer[row * pitch + j] = buf[j]; |
| } |
| } |
| _TIFFfree(buf); |
| return TRUE; |
| } |
| FX_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; |
| } |
| SetPalette(pDIBitmap, bps); |
| int32_t size = (int32_t)TIFFScanlineSize(tif_ctx); |
| uint8_t* buf = (uint8_t*)_TIFFmalloc(size); |
| if (buf == NULL) { |
| TIFFError(TIFFFileName(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); |
| for (int32_t j = 0; j < size; j++) { |
| switch (bps) { |
| case 4: |
| bitMapbuffer[row * pitch + 2 * j + 0] = (buf[j] & 0xF0) >> 4; |
| bitMapbuffer[row * pitch + 2 * j + 1] = (buf[j] & 0x0F) >> 0; |
| break; |
| case 8: |
| bitMapbuffer[row * pitch + j] = buf[j]; |
| break; |
| } |
| } |
| } |
| _TIFFfree(buf); |
| 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); |
| uint8_t* buf = (uint8_t*)_TIFFmalloc(size); |
| if (buf == NULL) { |
| TIFFError(TIFFFileName(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); |
| 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]; |
| bitMapbuffer[row * pitch + j + 2] = buf[j + 0]; |
| } |
| } |
| _TIFFfree(buf); |
| return TRUE; |
| } |
| FX_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; |
| } |
| if (pDIBitmap->GetBPP() == 32) { |
| uint16_t rotation = ORIENTATION_TOPLEFT; |
| TIFFGetField(tif_ctx, TIFFTAG_ORIENTATION, &rotation); |
| if (TIFFReadRGBAImageOriented(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); |
| } |
| return TRUE; |
| } |
| } |
| uint16_t spp, bps; |
| TIFFGetField(tif_ctx, TIFFTAG_SAMPLESPERPIXEL, &spp); |
| TIFFGetField(tif_ctx, TIFFTAG_BITSPERSAMPLE, &bps); |
| uint32_t bpp = bps * spp; |
| if (bpp == 1) { |
| return Decode1bppRGB(pDIBitmap, height, width, bps, spp); |
| } else if (bpp <= 8) { |
| return Decode8bppRGB(pDIBitmap, height, width, bps, spp); |
| } else if (bpp <= 24) { |
| return Decode24bppRGB(pDIBitmap, height, width, bps, spp); |
| } |
| return FALSE; |
| } |
| void* CCodec_TiffModule::CreateDecoder(IFX_FileRead* file_ptr) { |
| CCodec_TiffContext* pDecoder = new CCodec_TiffContext; |
| if (!pDecoder->InitDecoder(file_ptr)) { |
| delete pDecoder; |
| return NULL; |
| } |
| return pDecoder; |
| } |
| void CCodec_TiffModule::GetFrames(void* ctx, int32_t& frames) { |
| CCodec_TiffContext* pDecoder = (CCodec_TiffContext*)ctx; |
| pDecoder->GetFrames(frames); |
| } |
| FX_BOOL CCodec_TiffModule::LoadFrameInfo(void* ctx, |
| int32_t frame, |
| uint32_t& width, |
| uint32_t& height, |
| uint32_t& comps, |
| uint32_t& bpc, |
| CFX_DIBAttribute* pAttribute) { |
| CCodec_TiffContext* pDecoder = (CCodec_TiffContext*)ctx; |
| return pDecoder->LoadFrameInfo(frame, width, height, comps, bpc, pAttribute); |
| } |
| FX_BOOL CCodec_TiffModule::Decode(void* ctx, class CFX_DIBitmap* pDIBitmap) { |
| CCodec_TiffContext* pDecoder = (CCodec_TiffContext*)ctx; |
| return pDecoder->Decode(pDIBitmap); |
| } |
| void CCodec_TiffModule::DestroyDecoder(void* ctx) { |
| CCodec_TiffContext* pDecoder = (CCodec_TiffContext*)ctx; |
| delete pDecoder; |
| } |
