// 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/fxcodec/include/fx_codec.h"
|
#include "core/fxge/include/fx_dib.h"
|
|
extern "C" {
|
#include "third_party/libtiff/tiffiop.h"
|
}
|
|
class CCodec_TiffContext {
|
public:
|
CCodec_TiffContext();
|
~CCodec_TiffContext();
|
|
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:
|
bool IsSupport(const CFX_DIBitmap* pDIBitmap) const;
|
void SetPalette(CFX_DIBitmap* pDIBitmap, uint16_t bps);
|
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;
|
};
|
|
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;
|
|
namespace {
|
|
tsize_t tiff_read(thandle_t context, tdata_t buf, tsize_t length) {
|
CCodec_TiffContext* pTiffContext = (CCodec_TiffContext*)context;
|
if (!pTiffContext->io_in()->ReadBlock(buf, pTiffContext->offset(), length))
|
return 0;
|
|
pTiffContext->increment_offset(length);
|
return length;
|
}
|
|
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->set_offset(offset);
|
break;
|
case 1:
|
pTiffContext->increment_offset(offset);
|
break;
|
case 2:
|
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->offset() <= (uint32_t)pTiffContext->io_in()->GetSize());
|
return pTiffContext->offset();
|
}
|
|
int tiff_close(thandle_t context) {
|
return 0;
|
}
|
|
toff_t tiff_get_size(thandle_t context) {
|
CCodec_TiffContext* pTiffContext = (CCodec_TiffContext*)context;
|
return (toff_t)pTiffContext->io_in()->GetSize();
|
}
|
|
int tiff_map(thandle_t context, tdata_t*, toff_t*) {
|
return 0;
|
}
|
|
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;
|
}
|
|
template <class T>
|
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;
|
}
|
|
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
|
|
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;
|
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(m_tif_ctx, TIFFTAG_RESOLUTIONUNIT,
|
&pAttribute->m_wDPIUnit)) {
|
pAttribute->m_wDPIUnit--;
|
}
|
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>(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(m_tif_ctx, TIFFTAG_IMAGEDESCRIPTION, pAttribute);
|
Tiff_Exif_GetStringInfo(m_tif_ctx, TIFFTAG_MAKE, pAttribute);
|
Tiff_Exif_GetStringInfo(m_tif_ctx, TIFFTAG_MODEL, pAttribute);
|
}
|
*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;
|
}
|
|
bool CCodec_TiffContext::IsSupport(const CFX_DIBitmap* pDIBitmap) const {
|
if (TIFFIsTiled(m_tif_ctx))
|
return false;
|
|
uint16_t photometric;
|
if (!TIFFGetField(m_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(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;
|
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]);
|
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);
|
}
|
}
|
|
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(m_tif_ctx);
|
uint8_t* buf = (uint8_t*)_TIFFmalloc(size);
|
if (!buf) {
|
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(m_tif_ctx, buf, row, 0);
|
for (int32_t j = 0; j < size; j++) {
|
bitMapbuffer[row * pitch + j] = buf[j];
|
}
|
}
|
_TIFFfree(buf);
|
return true;
|
}
|
|
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(m_tif_ctx);
|
uint8_t* buf = (uint8_t*)_TIFFmalloc(size);
|
if (!buf) {
|
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(m_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;
|
}
|
|
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(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(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];
|
bitMapbuffer[row * pitch + j + 2] = buf[j + 0];
|
}
|
}
|
_TIFFfree(buf);
|
return true;
|
}
|
|
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(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(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);
|
}
|
return true;
|
}
|
}
|
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)
|
return Decode1bppRGB(pDIBitmap, height, width, bps, spp);
|
if (bpp <= 8)
|
return Decode8bppRGB(pDIBitmap, height, width, bps, spp);
|
if (bpp <= 24)
|
return Decode24bppRGB(pDIBitmap, height, width, bps, spp);
|
return false;
|
}
|
|
CCodec_TiffContext* CCodec_TiffModule::CreateDecoder(IFX_FileRead* file_ptr) {
|
CCodec_TiffContext* pDecoder = new CCodec_TiffContext;
|
if (!pDecoder->InitDecoder(file_ptr)) {
|
delete pDecoder;
|
return nullptr;
|
}
|
return pDecoder;
|
}
|
|
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);
|
}
|
|
bool CCodec_TiffModule::Decode(CCodec_TiffContext* ctx,
|
class CFX_DIBitmap* pDIBitmap) {
|
return ctx->Decode(pDIBitmap);
|
}
|
|
void CCodec_TiffModule::DestroyDecoder(CCodec_TiffContext* ctx) {
|
delete ctx;
|
}
|
