OLD | NEW |
---|---|
1 // Copyright 2014 PDFium Authors. All rights reserved. | 1 // Copyright 2014 PDFium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com | 5 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com |
6 | 6 |
7 #include "core/fxcodec/codec/codec_int.h" | 7 #include "core/fxcodec/codec/codec_int.h" |
8 #include "core/fxcodec/include/fx_codec.h" | 8 #include "core/fxcodec/include/fx_codec.h" |
9 #include "core/fxge/include/fx_dib.h" | 9 #include "core/fxge/include/fx_dib.h" |
10 | 10 |
11 extern "C" { | 11 extern "C" { |
12 #include "third_party/libtiff/tiffiop.h" | 12 #include "third_party/libtiff/tiffiop.h" |
13 } | 13 } |
14 | 14 |
15 void* IccLib_CreateTransform_sRGB(const unsigned char* pProfileData, | |
16 unsigned int dwProfileSize, | |
17 int nComponents, | |
18 int intent, | |
19 uint32_t dwSrcFormat = Icc_FORMAT_DEFAULT); | |
20 void IccLib_TranslateImage(void* pTransform, | |
21 unsigned char* pDest, | |
22 const unsigned char* pSrc, | |
23 int pixels); | |
24 void IccLib_DestroyTransform(void* pTransform); | |
25 class CCodec_TiffContext { | 15 class CCodec_TiffContext { |
26 public: | 16 public: |
27 CCodec_TiffContext(); | 17 CCodec_TiffContext(); |
28 ~CCodec_TiffContext(); | 18 ~CCodec_TiffContext(); |
29 | 19 |
30 FX_BOOL InitDecoder(IFX_FileRead* file_ptr); | 20 FX_BOOL InitDecoder(IFX_FileRead* file_ptr); |
31 void GetFrames(int32_t& frames); | |
32 FX_BOOL LoadFrameInfo(int32_t frame, | 21 FX_BOOL LoadFrameInfo(int32_t frame, |
33 uint32_t& width, | 22 int32_t* width, |
34 uint32_t& height, | 23 int32_t* height, |
35 uint32_t& comps, | 24 int32_t* comps, |
36 uint32_t& bpc, | 25 int32_t* bpc, |
37 CFX_DIBAttribute* pAttribute); | 26 CFX_DIBAttribute* pAttribute); |
38 FX_BOOL Decode(CFX_DIBitmap* pDIBitmap); | 27 FX_BOOL Decode(CFX_DIBitmap* pDIBitmap); |
39 | 28 |
40 union { | 29 IFX_FileRead* m_io_in; |
41 IFX_FileRead* in; | 30 uint32_t m_offset; |
42 IFX_FileStream* out; | 31 TIFF* m_tif_ctx; |
43 } io; | |
44 | |
45 uint32_t offset; | |
46 | |
47 TIFF* tif_ctx; | |
48 void* icc_ctx; | |
49 int32_t frame_num; | |
50 int32_t frame_cur; | |
51 FX_BOOL isDecoder; | |
52 | 32 |
53 private: | 33 private: |
54 FX_BOOL isSupport(CFX_DIBitmap* pDIBitmap); | 34 FX_BOOL isSupport(CFX_DIBitmap* pDIBitmap); |
55 void SetPalette(CFX_DIBitmap* pDIBitmap, uint16_t bps); | 35 void SetPalette(CFX_DIBitmap* pDIBitmap, uint16_t bps); |
56 FX_BOOL Decode1bppRGB(CFX_DIBitmap* pDIBitmap, | 36 FX_BOOL Decode1bppRGB(CFX_DIBitmap* pDIBitmap, |
57 int32_t height, | 37 int32_t height, |
58 int32_t width, | 38 int32_t width, |
59 uint16_t bps, | 39 uint16_t bps, |
60 uint16_t spp); | 40 uint16_t spp); |
61 FX_BOOL Decode8bppRGB(CFX_DIBitmap* pDIBitmap, | 41 FX_BOOL Decode8bppRGB(CFX_DIBitmap* pDIBitmap, |
62 int32_t height, | 42 int32_t height, |
63 int32_t width, | 43 int32_t width, |
64 uint16_t bps, | 44 uint16_t bps, |
65 uint16_t spp); | 45 uint16_t spp); |
66 FX_BOOL Decode24bppRGB(CFX_DIBitmap* pDIBitmap, | 46 FX_BOOL Decode24bppRGB(CFX_DIBitmap* pDIBitmap, |
67 int32_t height, | 47 int32_t height, |
68 int32_t width, | 48 int32_t width, |
69 uint16_t bps, | 49 uint16_t bps, |
70 uint16_t spp); | 50 uint16_t spp); |
71 }; | 51 }; |
72 CCodec_TiffContext::CCodec_TiffContext() { | 52 |
73 offset = 0; | |
74 frame_num = 0; | |
75 frame_cur = 0; | |
76 io.in = nullptr; | |
77 tif_ctx = nullptr; | |
78 icc_ctx = nullptr; | |
79 isDecoder = TRUE; | |
80 } | |
81 CCodec_TiffContext::~CCodec_TiffContext() { | |
82 if (icc_ctx) { | |
83 IccLib_DestroyTransform(icc_ctx); | |
84 icc_ctx = nullptr; | |
85 } | |
86 if (tif_ctx) { | |
87 TIFFClose(tif_ctx); | |
88 } | |
89 } | |
90 static tsize_t _tiff_read(thandle_t context, tdata_t buf, tsize_t length) { | |
91 CCodec_TiffContext* pTiffContext = (CCodec_TiffContext*)context; | |
92 FX_BOOL ret = FALSE; | |
93 if (pTiffContext->isDecoder) { | |
94 ret = pTiffContext->io.in->ReadBlock(buf, pTiffContext->offset, length); | |
95 } else { | |
96 ret = pTiffContext->io.out->ReadBlock(buf, pTiffContext->offset, length); | |
97 } | |
98 if (!ret) { | |
99 return 0; | |
100 } | |
101 pTiffContext->offset += (uint32_t)length; | |
102 return length; | |
103 } | |
104 static tsize_t _tiff_write(thandle_t context, tdata_t buf, tsize_t length) { | |
105 CCodec_TiffContext* pTiffContext = (CCodec_TiffContext*)context; | |
106 ASSERT(!pTiffContext->isDecoder); | |
107 if (!pTiffContext->io.out->WriteBlock(buf, pTiffContext->offset, length)) { | |
108 return 0; | |
109 } | |
110 pTiffContext->offset += (uint32_t)length; | |
111 return length; | |
112 } | |
113 static toff_t _tiff_seek(thandle_t context, toff_t offset, int whence) { | |
114 CCodec_TiffContext* pTiffContext = (CCodec_TiffContext*)context; | |
115 switch (whence) { | |
116 case 0: | |
117 pTiffContext->offset = (uint32_t)offset; | |
118 break; | |
119 case 1: | |
120 pTiffContext->offset += (uint32_t)offset; | |
121 break; | |
122 case 2: | |
123 if (pTiffContext->isDecoder) { | |
124 if (pTiffContext->io.in->GetSize() < (FX_FILESIZE)offset) { | |
125 return static_cast<toff_t>(-1); | |
126 } | |
127 pTiffContext->offset = | |
128 (uint32_t)(pTiffContext->io.in->GetSize() - offset); | |
129 } else { | |
130 if (pTiffContext->io.out->GetSize() < (FX_FILESIZE)offset) { | |
131 return static_cast<toff_t>(-1); | |
132 } | |
133 pTiffContext->offset = | |
134 (uint32_t)(pTiffContext->io.out->GetSize() - offset); | |
135 } | |
136 break; | |
137 default: | |
138 return static_cast<toff_t>(-1); | |
139 } | |
140 ASSERT(pTiffContext->isDecoder ? (pTiffContext->offset <= | |
141 (uint32_t)pTiffContext->io.in->GetSize()) | |
142 : TRUE); | |
143 return pTiffContext->offset; | |
144 } | |
145 static int _tiff_close(thandle_t context) { | |
146 return 0; | |
147 } | |
148 static toff_t _tiff_get_size(thandle_t context) { | |
149 CCodec_TiffContext* pTiffContext = (CCodec_TiffContext*)context; | |
150 return pTiffContext->isDecoder ? (toff_t)pTiffContext->io.in->GetSize() | |
151 : (toff_t)pTiffContext->io.out->GetSize(); | |
152 } | |
153 static int _tiff_map(thandle_t context, tdata_t*, toff_t*) { | |
154 return 0; | |
155 } | |
156 static void _tiff_unmap(thandle_t context, tdata_t, toff_t) {} | |
157 TIFF* _tiff_open(void* context, const char* mode) { | |
158 TIFF* tif = TIFFClientOpen("Tiff Image", mode, (thandle_t)context, _tiff_read, | |
159 _tiff_write, _tiff_seek, _tiff_close, | |
160 _tiff_get_size, _tiff_map, _tiff_unmap); | |
161 if (tif) { | |
162 tif->tif_fd = (int)(intptr_t)context; | |
163 } | |
164 return tif; | |
165 } | |
166 void* _TIFFmalloc(tmsize_t size) { | 53 void* _TIFFmalloc(tmsize_t size) { |
167 return FXMEM_DefaultAlloc(size, 0); | 54 return FXMEM_DefaultAlloc(size, 0); |
168 } | 55 } |
56 | |
169 void _TIFFfree(void* ptr) { | 57 void _TIFFfree(void* ptr) { |
170 FXMEM_DefaultFree(ptr, 0); | 58 FXMEM_DefaultFree(ptr, 0); |
171 } | 59 } |
60 | |
172 void* _TIFFrealloc(void* ptr, tmsize_t size) { | 61 void* _TIFFrealloc(void* ptr, tmsize_t size) { |
173 return FXMEM_DefaultRealloc(ptr, size, 0); | 62 return FXMEM_DefaultRealloc(ptr, size, 0); |
174 } | 63 } |
64 | |
175 void _TIFFmemset(void* ptr, int val, tmsize_t size) { | 65 void _TIFFmemset(void* ptr, int val, tmsize_t size) { |
176 FXSYS_memset(ptr, val, (size_t)size); | 66 FXSYS_memset(ptr, val, (size_t)size); |
177 } | 67 } |
68 | |
178 void _TIFFmemcpy(void* des, const void* src, tmsize_t size) { | 69 void _TIFFmemcpy(void* des, const void* src, tmsize_t size) { |
179 FXSYS_memcpy(des, src, (size_t)size); | 70 FXSYS_memcpy(des, src, (size_t)size); |
180 } | 71 } |
72 | |
181 int _TIFFmemcmp(const void* ptr1, const void* ptr2, tmsize_t size) { | 73 int _TIFFmemcmp(const void* ptr1, const void* ptr2, tmsize_t size) { |
182 return FXSYS_memcmp(ptr1, ptr2, (size_t)size); | 74 return FXSYS_memcmp(ptr1, ptr2, (size_t)size); |
183 } | 75 } |
184 | 76 |
185 TIFFErrorHandler _TIFFwarningHandler = nullptr; | 77 TIFFErrorHandler _TIFFwarningHandler = nullptr; |
186 TIFFErrorHandler _TIFFerrorHandler = nullptr; | 78 TIFFErrorHandler _TIFFerrorHandler = nullptr; |
187 | 79 |
188 int TIFFCmyk2Rgb(thandle_t context, | 80 namespace { |
189 uint8 c, | 81 |
190 uint8 m, | 82 tsize_t tiff_read(thandle_t context, tdata_t buf, tsize_t length) { |
191 uint8 y, | 83 CCodec_TiffContext* pTiffContext = (CCodec_TiffContext*)context; |
192 uint8 k, | 84 if (!pTiffContext->m_io_in->ReadBlock(buf, pTiffContext->m_offset, length)) |
193 uint8* r, | |
194 uint8* g, | |
195 uint8* b) { | |
196 if (!context) | |
197 return 0; | 85 return 0; |
198 | 86 |
199 CCodec_TiffContext* p = (CCodec_TiffContext*)context; | 87 pTiffContext->m_offset += (uint32_t)length; |
200 if (p->icc_ctx) { | 88 return length; |
201 unsigned char cmyk[4], bgr[3]; | 89 } |
202 cmyk[0] = c, cmyk[1] = m, cmyk[2] = y, cmyk[3] = k; | 90 |
203 IccLib_TranslateImage(p->icc_ctx, bgr, cmyk, 1); | 91 tsize_t tiff_write(thandle_t context, tdata_t buf, tsize_t length) { |
204 *r = bgr[2], *g = bgr[1], *b = bgr[0]; | 92 ASSERT(false); |
205 } else { | 93 return 0; |
206 AdobeCMYK_to_sRGB1(c, m, y, k, *r, *g, *b); | 94 } |
95 | |
96 toff_t tiff_seek(thandle_t context, toff_t offset, int whence) { | |
97 CCodec_TiffContext* pTiffContext = (CCodec_TiffContext*)context; | |
98 switch (whence) { | |
99 case 0: | |
100 pTiffContext->m_offset = (uint32_t)offset; | |
101 break; | |
102 case 1: | |
103 pTiffContext->m_offset += (uint32_t)offset; | |
104 break; | |
105 case 2: | |
106 if (pTiffContext->m_io_in->GetSize() < (FX_FILESIZE)offset) { | |
107 return static_cast<toff_t>(-1); | |
108 } | |
109 pTiffContext->m_offset = | |
110 (uint32_t)(pTiffContext->m_io_in->GetSize() - offset); | |
111 break; | |
112 default: | |
113 return static_cast<toff_t>(-1); | |
207 } | 114 } |
208 return 1; | 115 ASSERT(pTiffContext->m_offset <= (uint32_t)pTiffContext->m_io_in->GetSize()); |
116 return pTiffContext->m_offset; | |
209 } | 117 } |
210 FX_BOOL CCodec_TiffContext::InitDecoder(IFX_FileRead* file_ptr) { | 118 |
211 io.in = file_ptr; | 119 int tiff_close(thandle_t context) { |
212 return !!_tiff_open(this, "r"); | 120 return 0; |
213 } | 121 } |
214 void CCodec_TiffContext::GetFrames(int32_t& frames) { | 122 |
215 frames = frame_num = TIFFNumberOfDirectories(tif_ctx); | 123 toff_t tiff_get_size(thandle_t context) { |
124 CCodec_TiffContext* pTiffContext = (CCodec_TiffContext*)context; | |
125 return (toff_t)pTiffContext->m_io_in->GetSize(); | |
216 } | 126 } |
217 #define TIFF_EXIF_GETINFO(key, T, tag) \ | |
218 { \ | |
219 T val = (T)0; \ | |
220 TIFFGetField(tif_ctx, tag, &val); \ | |
221 if (val) { \ | |
222 (key) = FX_Alloc(uint8_t, sizeof(T)); \ | |
223 if ((key)) { \ | |
224 T* ptr = (T*)(key); \ | |
225 *ptr = val; \ | |
226 pExif->m_TagVal.SetAt(tag, (key)); \ | |
227 } \ | |
228 } \ | |
229 } \ | |
230 (key) = nullptr; | |
231 #define TIFF_EXIF_GETSTRINGINFO(key, tag) \ | |
232 { \ | |
233 uint32_t size = 0; \ | |
234 uint8_t* buf = nullptr; \ | |
235 TIFFGetField(tif_ctx, tag, &size, &buf); \ | |
236 if (size && buf) { \ | |
237 (key) = FX_Alloc(uint8_t, size); \ | |
238 if ((key)) { \ | |
239 FXSYS_memcpy((key), buf, size); \ | |
240 pExif->m_TagVal.SetAt(tag, (key)); \ | |
241 } \ | |
242 } \ | |
243 } \ | |
244 (key) = nullptr; | |
245 | 127 |
246 namespace { | 128 int tiff_map(thandle_t context, tdata_t*, toff_t*) { |
129 return 0; | |
130 } | |
131 | |
132 void tiff_unmap(thandle_t context, tdata_t, toff_t) {} | |
133 | |
134 TIFF* tiff_open(void* context, const char* mode) { | |
135 TIFF* tif = TIFFClientOpen("Tiff Image", mode, (thandle_t)context, tiff_read, | |
136 tiff_write, tiff_seek, tiff_close, tiff_get_size, | |
137 tiff_map, tiff_unmap); | |
138 if (tif) { | |
139 tif->tif_fd = (int)(intptr_t)context; | |
140 } | |
141 return tif; | |
142 } | |
247 | 143 |
248 template <class T> | 144 template <class T> |
249 FX_BOOL Tiff_Exif_GetInfo(TIFF* tif_ctx, ttag_t tag, CFX_DIBAttribute* pAttr) { | 145 FX_BOOL Tiff_Exif_GetInfo(TIFF* tif_ctx, ttag_t tag, CFX_DIBAttribute* pAttr) { |
250 T val = 0; | 146 T val = 0; |
251 TIFFGetField(tif_ctx, tag, &val); | 147 TIFFGetField(tif_ctx, tag, &val); |
252 if (!val) | 148 if (!val) |
253 return FALSE; | 149 return FALSE; |
254 T* ptr = FX_Alloc(T, 1); | 150 T* ptr = FX_Alloc(T, 1); |
255 *ptr = val; | 151 *ptr = val; |
256 pAttr->m_Exif[tag] = (void*)ptr; | 152 pAttr->m_Exif[tag] = (void*)ptr; |
257 return TRUE; | 153 return TRUE; |
258 } | 154 } |
155 | |
259 void Tiff_Exif_GetStringInfo(TIFF* tif_ctx, | 156 void Tiff_Exif_GetStringInfo(TIFF* tif_ctx, |
260 ttag_t tag, | 157 ttag_t tag, |
261 CFX_DIBAttribute* pAttr) { | 158 CFX_DIBAttribute* pAttr) { |
262 FX_CHAR* buf = nullptr; | 159 FX_CHAR* buf = nullptr; |
263 TIFFGetField(tif_ctx, tag, &buf); | 160 TIFFGetField(tif_ctx, tag, &buf); |
264 if (!buf) | 161 if (!buf) |
265 return; | 162 return; |
266 FX_STRSIZE size = FXSYS_strlen(buf); | 163 FX_STRSIZE size = FXSYS_strlen(buf); |
267 uint8_t* ptr = FX_Alloc(uint8_t, size + 1); | 164 uint8_t* ptr = FX_Alloc(uint8_t, size + 1); |
268 FXSYS_memcpy(ptr, buf, size); | 165 FXSYS_memcpy(ptr, buf, size); |
269 ptr[size] = 0; | 166 ptr[size] = 0; |
270 pAttr->m_Exif[tag] = ptr; | 167 pAttr->m_Exif[tag] = ptr; |
271 } | 168 } |
272 | 169 |
273 } // namespace | 170 void TiffBGRA2RGBA(uint8_t* pBuf, int32_t pixel, int32_t spp) { |
274 | |
275 FX_BOOL CCodec_TiffContext::LoadFrameInfo(int32_t frame, | |
276 uint32_t& width, | |
277 uint32_t& height, | |
278 uint32_t& comps, | |
279 uint32_t& bpc, | |
280 CFX_DIBAttribute* pAttribute) { | |
281 if (!TIFFSetDirectory(tif_ctx, (uint16)frame)) { | |
282 return FALSE; | |
283 } | |
284 uint16_t tif_cs; | |
285 uint32_t tif_icc_size = 0; | |
286 uint8_t* tif_icc_buf = nullptr; | |
287 uint16_t tif_bpc = 0; | |
288 uint16_t tif_cps; | |
289 uint32_t tif_rps; | |
290 width = height = comps = 0; | |
291 TIFFGetField(tif_ctx, TIFFTAG_IMAGEWIDTH, &width); | |
292 TIFFGetField(tif_ctx, TIFFTAG_IMAGELENGTH, &height); | |
293 TIFFGetField(tif_ctx, TIFFTAG_SAMPLESPERPIXEL, &comps); | |
294 TIFFGetField(tif_ctx, TIFFTAG_BITSPERSAMPLE, &tif_bpc); | |
295 TIFFGetField(tif_ctx, TIFFTAG_PHOTOMETRIC, &tif_cs); | |
296 TIFFGetField(tif_ctx, TIFFTAG_COMPRESSION, &tif_cps); | |
297 TIFFGetField(tif_ctx, TIFFTAG_ROWSPERSTRIP, &tif_rps); | |
298 TIFFGetField(tif_ctx, TIFFTAG_ICCPROFILE, &tif_icc_size, &tif_icc_buf); | |
299 if (pAttribute) { | |
300 pAttribute->m_wDPIUnit = FXCODEC_RESUNIT_INCH; | |
301 if (TIFFGetField(tif_ctx, TIFFTAG_RESOLUTIONUNIT, | |
302 &pAttribute->m_wDPIUnit)) { | |
303 pAttribute->m_wDPIUnit -= 1; | |
304 } | |
305 Tiff_Exif_GetInfo<uint16_t>(tif_ctx, TIFFTAG_ORIENTATION, pAttribute); | |
306 if (Tiff_Exif_GetInfo<FX_FLOAT>(tif_ctx, TIFFTAG_XRESOLUTION, pAttribute)) { | |
307 void* val = pAttribute->m_Exif[TIFFTAG_XRESOLUTION]; | |
308 FX_FLOAT fDpi = val ? *reinterpret_cast<FX_FLOAT*>(val) : 0; | |
309 pAttribute->m_nXDPI = (int32_t)(fDpi + 0.5f); | |
310 } | |
311 if (Tiff_Exif_GetInfo<FX_FLOAT>(tif_ctx, TIFFTAG_YRESOLUTION, pAttribute)) { | |
312 void* val = pAttribute->m_Exif[TIFFTAG_YRESOLUTION]; | |
313 FX_FLOAT fDpi = val ? *reinterpret_cast<FX_FLOAT*>(val) : 0; | |
314 pAttribute->m_nYDPI = (int32_t)(fDpi + 0.5f); | |
315 } | |
316 Tiff_Exif_GetStringInfo(tif_ctx, TIFFTAG_IMAGEDESCRIPTION, pAttribute); | |
317 Tiff_Exif_GetStringInfo(tif_ctx, TIFFTAG_MAKE, pAttribute); | |
318 Tiff_Exif_GetStringInfo(tif_ctx, TIFFTAG_MODEL, pAttribute); | |
319 } | |
320 bpc = tif_bpc; | |
321 if (tif_rps > height) { | |
322 TIFFSetField(tif_ctx, TIFFTAG_ROWSPERSTRIP, tif_rps = height); | |
323 } | |
324 return TRUE; | |
325 } | |
326 void _TiffBGRA2RGBA(uint8_t* pBuf, int32_t pixel, int32_t spp) { | |
327 for (int32_t n = 0; n < pixel; n++) { | 171 for (int32_t n = 0; n < pixel; n++) { |
328 uint8_t tmp = pBuf[0]; | 172 uint8_t tmp = pBuf[0]; |
329 pBuf[0] = pBuf[2]; | 173 pBuf[0] = pBuf[2]; |
330 pBuf[2] = tmp; | 174 pBuf[2] = tmp; |
331 pBuf += spp; | 175 pBuf += spp; |
332 } | 176 } |
333 } | 177 } |
178 | |
179 } // namespace | |
180 | |
181 CCodec_TiffContext::CCodec_TiffContext() | |
182 : m_io_in(nullptr), m_offset(0), m_tif_ctx(nullptr) {} | |
183 | |
184 CCodec_TiffContext::~CCodec_TiffContext() { | |
185 if (m_tif_ctx) | |
186 TIFFClose(m_tif_ctx); | |
187 } | |
188 | |
189 FX_BOOL CCodec_TiffContext::InitDecoder(IFX_FileRead* file_ptr) { | |
190 m_io_in = file_ptr; | |
191 m_tif_ctx = tiff_open(this, "r"); | |
192 return !!m_tif_ctx; | |
193 } | |
194 | |
195 FX_BOOL CCodec_TiffContext::LoadFrameInfo(int32_t frame, | |
196 int32_t* width, | |
Tom Sepez
2016/06/09 17:53:16
Can these instead be unsigned throughout? Worry a
Lei Zhang
2016/06/09 22:00:40
Fixed later.
| |
197 int32_t* height, | |
198 int32_t* comps, | |
199 int32_t* bpc, | |
200 CFX_DIBAttribute* pAttribute) { | |
201 if (!TIFFSetDirectory(m_tif_ctx, (uint16)frame)) | |
202 return FALSE; | |
203 | |
204 uint16_t tif_cs; | |
205 uint32_t tif_icc_size = 0; | |
206 uint8_t* tif_icc_buf = nullptr; | |
207 uint16_t tif_bpc = 0; | |
208 uint16_t tif_cps; | |
209 int32_t tif_rps; | |
210 *width = 0; | |
211 *height = 0; | |
212 *comps = 0; | |
213 TIFFGetField(m_tif_ctx, TIFFTAG_IMAGEWIDTH, width); | |
214 TIFFGetField(m_tif_ctx, TIFFTAG_IMAGELENGTH, height); | |
215 TIFFGetField(m_tif_ctx, TIFFTAG_SAMPLESPERPIXEL, comps); | |
216 TIFFGetField(m_tif_ctx, TIFFTAG_BITSPERSAMPLE, &tif_bpc); | |
217 TIFFGetField(m_tif_ctx, TIFFTAG_PHOTOMETRIC, &tif_cs); | |
218 TIFFGetField(m_tif_ctx, TIFFTAG_COMPRESSION, &tif_cps); | |
219 TIFFGetField(m_tif_ctx, TIFFTAG_ROWSPERSTRIP, &tif_rps); | |
220 TIFFGetField(m_tif_ctx, TIFFTAG_ICCPROFILE, &tif_icc_size, &tif_icc_buf); | |
221 if (pAttribute) { | |
222 pAttribute->m_wDPIUnit = FXCODEC_RESUNIT_INCH; | |
223 if (TIFFGetField(m_tif_ctx, TIFFTAG_RESOLUTIONUNIT, | |
224 &pAttribute->m_wDPIUnit)) { | |
225 pAttribute->m_wDPIUnit -= 1; | |
226 } | |
227 Tiff_Exif_GetInfo<uint16_t>(m_tif_ctx, TIFFTAG_ORIENTATION, pAttribute); | |
228 if (Tiff_Exif_GetInfo<FX_FLOAT>(m_tif_ctx, TIFFTAG_XRESOLUTION, | |
229 pAttribute)) { | |
230 void* val = pAttribute->m_Exif[TIFFTAG_XRESOLUTION]; | |
231 FX_FLOAT fDpi = val ? *reinterpret_cast<FX_FLOAT*>(val) : 0; | |
232 pAttribute->m_nXDPI = (int32_t)(fDpi + 0.5f); | |
233 } | |
234 if (Tiff_Exif_GetInfo<FX_FLOAT>(m_tif_ctx, TIFFTAG_YRESOLUTION, | |
235 pAttribute)) { | |
236 void* val = pAttribute->m_Exif[TIFFTAG_YRESOLUTION]; | |
237 FX_FLOAT fDpi = val ? *reinterpret_cast<FX_FLOAT*>(val) : 0; | |
238 pAttribute->m_nYDPI = (int32_t)(fDpi + 0.5f); | |
239 } | |
240 Tiff_Exif_GetStringInfo(m_tif_ctx, TIFFTAG_IMAGEDESCRIPTION, pAttribute); | |
241 Tiff_Exif_GetStringInfo(m_tif_ctx, TIFFTAG_MAKE, pAttribute); | |
242 Tiff_Exif_GetStringInfo(m_tif_ctx, TIFFTAG_MODEL, pAttribute); | |
243 } | |
244 *bpc = tif_bpc; | |
245 if (tif_rps > *height) { | |
246 tif_rps = *height; | |
247 TIFFSetField(m_tif_ctx, TIFFTAG_ROWSPERSTRIP, tif_rps); | |
248 } | |
249 return TRUE; | |
250 } | |
251 | |
334 FX_BOOL CCodec_TiffContext::isSupport(CFX_DIBitmap* pDIBitmap) { | 252 FX_BOOL CCodec_TiffContext::isSupport(CFX_DIBitmap* pDIBitmap) { |
335 if (TIFFIsTiled(tif_ctx)) { | 253 if (TIFFIsTiled(m_tif_ctx)) |
336 return FALSE; | 254 return FALSE; |
337 } | 255 |
338 uint16_t photometric; | 256 uint16_t photometric; |
339 if (!TIFFGetField(tif_ctx, TIFFTAG_PHOTOMETRIC, &photometric)) { | 257 if (!TIFFGetField(m_tif_ctx, TIFFTAG_PHOTOMETRIC, &photometric)) { |
340 return FALSE; | 258 return FALSE; |
341 } | 259 } |
342 switch (pDIBitmap->GetBPP()) { | 260 switch (pDIBitmap->GetBPP()) { |
343 case 1: | 261 case 1: |
344 case 8: | 262 case 8: |
345 if (photometric != PHOTOMETRIC_PALETTE) { | 263 if (photometric != PHOTOMETRIC_PALETTE) { |
346 return FALSE; | 264 return FALSE; |
347 } | 265 } |
348 break; | 266 break; |
349 case 24: | 267 case 24: |
350 if (photometric != PHOTOMETRIC_RGB) { | 268 if (photometric != PHOTOMETRIC_RGB) { |
351 return FALSE; | 269 return FALSE; |
352 } | 270 } |
353 break; | 271 break; |
354 default: | 272 default: |
355 return FALSE; | 273 return FALSE; |
356 } | 274 } |
357 uint16_t planarconfig; | 275 uint16_t planarconfig; |
358 if (!TIFFGetFieldDefaulted(tif_ctx, TIFFTAG_PLANARCONFIG, &planarconfig)) { | 276 if (!TIFFGetFieldDefaulted(m_tif_ctx, TIFFTAG_PLANARCONFIG, &planarconfig)) |
359 return FALSE; | 277 return FALSE; |
360 } | 278 |
361 if (planarconfig == PLANARCONFIG_SEPARATE) { | 279 return planarconfig != PLANARCONFIG_SEPARATE; |
362 return FALSE; | |
363 } | |
364 return TRUE; | |
365 } | 280 } |
281 | |
366 void CCodec_TiffContext::SetPalette(CFX_DIBitmap* pDIBitmap, uint16_t bps) { | 282 void CCodec_TiffContext::SetPalette(CFX_DIBitmap* pDIBitmap, uint16_t bps) { |
367 uint16_t *red_orig, *green_orig, *blue_orig; | 283 uint16_t *red_orig, *green_orig, *blue_orig; |
368 TIFFGetField(tif_ctx, TIFFTAG_COLORMAP, &red_orig, &green_orig, &blue_orig); | 284 TIFFGetField(m_tif_ctx, TIFFTAG_COLORMAP, &red_orig, &green_orig, &blue_orig); |
369 for (int32_t i = (1L << bps) - 1; i >= 0; i--) { | 285 for (int32_t i = (1L << bps) - 1; i >= 0; i--) { |
370 #define CVT(x) ((uint16_t)((x) >> 8)) | 286 #define CVT(x) ((uint16_t)((x) >> 8)) |
371 red_orig[i] = CVT(red_orig[i]); | 287 red_orig[i] = CVT(red_orig[i]); |
372 green_orig[i] = CVT(green_orig[i]); | 288 green_orig[i] = CVT(green_orig[i]); |
373 blue_orig[i] = CVT(blue_orig[i]); | 289 blue_orig[i] = CVT(blue_orig[i]); |
374 #undef CVT | 290 #undef CVT |
375 } | 291 } |
376 int32_t len = 1 << bps; | 292 int32_t len = 1 << bps; |
377 for (int32_t index = 0; index < len; index++) { | 293 for (int32_t index = 0; index < len; index++) { |
378 uint32_t r = red_orig[index] & 0xFF; | 294 uint32_t r = red_orig[index] & 0xFF; |
379 uint32_t g = green_orig[index] & 0xFF; | 295 uint32_t g = green_orig[index] & 0xFF; |
380 uint32_t b = blue_orig[index] & 0xFF; | 296 uint32_t b = blue_orig[index] & 0xFF; |
381 uint32_t color = (uint32_t)b | ((uint32_t)g << 8) | ((uint32_t)r << 16) | | 297 uint32_t color = (uint32_t)b | ((uint32_t)g << 8) | ((uint32_t)r << 16) | |
382 (((uint32)0xffL) << 24); | 298 (((uint32)0xffL) << 24); |
383 pDIBitmap->SetPaletteEntry(index, color); | 299 pDIBitmap->SetPaletteEntry(index, color); |
384 } | 300 } |
385 } | 301 } |
302 | |
386 FX_BOOL CCodec_TiffContext::Decode1bppRGB(CFX_DIBitmap* pDIBitmap, | 303 FX_BOOL CCodec_TiffContext::Decode1bppRGB(CFX_DIBitmap* pDIBitmap, |
387 int32_t height, | 304 int32_t height, |
388 int32_t width, | 305 int32_t width, |
389 uint16_t bps, | 306 uint16_t bps, |
390 uint16_t spp) { | 307 uint16_t spp) { |
391 if (pDIBitmap->GetBPP() != 1 || spp != 1 || bps != 1 || | 308 if (pDIBitmap->GetBPP() != 1 || spp != 1 || bps != 1 || |
392 !isSupport(pDIBitmap)) { | 309 !isSupport(pDIBitmap)) { |
393 return FALSE; | 310 return FALSE; |
394 } | 311 } |
395 SetPalette(pDIBitmap, bps); | 312 SetPalette(pDIBitmap, bps); |
396 int32_t size = (int32_t)TIFFScanlineSize(tif_ctx); | 313 int32_t size = (int32_t)TIFFScanlineSize(m_tif_ctx); |
397 uint8_t* buf = (uint8_t*)_TIFFmalloc(size); | 314 uint8_t* buf = (uint8_t*)_TIFFmalloc(size); |
398 if (!buf) { | 315 if (!buf) { |
399 TIFFError(TIFFFileName(tif_ctx), "No space for scanline buffer"); | 316 TIFFError(TIFFFileName(m_tif_ctx), "No space for scanline buffer"); |
400 return FALSE; | 317 return FALSE; |
401 } | 318 } |
402 uint8_t* bitMapbuffer = (uint8_t*)pDIBitmap->GetBuffer(); | 319 uint8_t* bitMapbuffer = (uint8_t*)pDIBitmap->GetBuffer(); |
403 uint32_t pitch = pDIBitmap->GetPitch(); | 320 uint32_t pitch = pDIBitmap->GetPitch(); |
404 for (int32_t row = 0; row < height; row++) { | 321 for (int32_t row = 0; row < height; row++) { |
405 TIFFReadScanline(tif_ctx, buf, row, 0); | 322 TIFFReadScanline(m_tif_ctx, buf, row, 0); |
406 for (int32_t j = 0; j < size; j++) { | 323 for (int32_t j = 0; j < size; j++) { |
407 bitMapbuffer[row * pitch + j] = buf[j]; | 324 bitMapbuffer[row * pitch + j] = buf[j]; |
408 } | 325 } |
409 } | 326 } |
410 _TIFFfree(buf); | 327 _TIFFfree(buf); |
411 return TRUE; | 328 return TRUE; |
412 } | 329 } |
330 | |
413 FX_BOOL CCodec_TiffContext::Decode8bppRGB(CFX_DIBitmap* pDIBitmap, | 331 FX_BOOL CCodec_TiffContext::Decode8bppRGB(CFX_DIBitmap* pDIBitmap, |
414 int32_t height, | 332 int32_t height, |
415 int32_t width, | 333 int32_t width, |
416 uint16_t bps, | 334 uint16_t bps, |
417 uint16_t spp) { | 335 uint16_t spp) { |
418 if (pDIBitmap->GetBPP() != 8 || spp != 1 || (bps != 4 && bps != 8) || | 336 if (pDIBitmap->GetBPP() != 8 || spp != 1 || (bps != 4 && bps != 8) || |
419 !isSupport(pDIBitmap)) { | 337 !isSupport(pDIBitmap)) { |
420 return FALSE; | 338 return FALSE; |
421 } | 339 } |
422 SetPalette(pDIBitmap, bps); | 340 SetPalette(pDIBitmap, bps); |
423 int32_t size = (int32_t)TIFFScanlineSize(tif_ctx); | 341 int32_t size = (int32_t)TIFFScanlineSize(m_tif_ctx); |
424 uint8_t* buf = (uint8_t*)_TIFFmalloc(size); | 342 uint8_t* buf = (uint8_t*)_TIFFmalloc(size); |
425 if (!buf) { | 343 if (!buf) { |
426 TIFFError(TIFFFileName(tif_ctx), "No space for scanline buffer"); | 344 TIFFError(TIFFFileName(m_tif_ctx), "No space for scanline buffer"); |
427 return FALSE; | 345 return FALSE; |
428 } | 346 } |
429 uint8_t* bitMapbuffer = (uint8_t*)pDIBitmap->GetBuffer(); | 347 uint8_t* bitMapbuffer = (uint8_t*)pDIBitmap->GetBuffer(); |
430 uint32_t pitch = pDIBitmap->GetPitch(); | 348 uint32_t pitch = pDIBitmap->GetPitch(); |
431 for (int32_t row = 0; row < height; row++) { | 349 for (int32_t row = 0; row < height; row++) { |
432 TIFFReadScanline(tif_ctx, buf, row, 0); | 350 TIFFReadScanline(m_tif_ctx, buf, row, 0); |
433 for (int32_t j = 0; j < size; j++) { | 351 for (int32_t j = 0; j < size; j++) { |
434 switch (bps) { | 352 switch (bps) { |
435 case 4: | 353 case 4: |
436 bitMapbuffer[row * pitch + 2 * j + 0] = (buf[j] & 0xF0) >> 4; | 354 bitMapbuffer[row * pitch + 2 * j + 0] = (buf[j] & 0xF0) >> 4; |
437 bitMapbuffer[row * pitch + 2 * j + 1] = (buf[j] & 0x0F) >> 0; | 355 bitMapbuffer[row * pitch + 2 * j + 1] = (buf[j] & 0x0F) >> 0; |
438 break; | 356 break; |
439 case 8: | 357 case 8: |
440 bitMapbuffer[row * pitch + j] = buf[j]; | 358 bitMapbuffer[row * pitch + j] = buf[j]; |
441 break; | 359 break; |
442 } | 360 } |
443 } | 361 } |
444 } | 362 } |
445 _TIFFfree(buf); | 363 _TIFFfree(buf); |
446 return TRUE; | 364 return TRUE; |
447 } | 365 } |
366 | |
448 FX_BOOL CCodec_TiffContext::Decode24bppRGB(CFX_DIBitmap* pDIBitmap, | 367 FX_BOOL CCodec_TiffContext::Decode24bppRGB(CFX_DIBitmap* pDIBitmap, |
449 int32_t height, | 368 int32_t height, |
450 int32_t width, | 369 int32_t width, |
451 uint16_t bps, | 370 uint16_t bps, |
452 uint16_t spp) { | 371 uint16_t spp) { |
453 if (pDIBitmap->GetBPP() != 24 || !isSupport(pDIBitmap)) { | 372 if (pDIBitmap->GetBPP() != 24 || !isSupport(pDIBitmap)) { |
454 return FALSE; | 373 return FALSE; |
455 } | 374 } |
456 int32_t size = (int32_t)TIFFScanlineSize(tif_ctx); | 375 int32_t size = (int32_t)TIFFScanlineSize(m_tif_ctx); |
457 uint8_t* buf = (uint8_t*)_TIFFmalloc(size); | 376 uint8_t* buf = (uint8_t*)_TIFFmalloc(size); |
458 if (!buf) { | 377 if (!buf) { |
459 TIFFError(TIFFFileName(tif_ctx), "No space for scanline buffer"); | 378 TIFFError(TIFFFileName(m_tif_ctx), "No space for scanline buffer"); |
460 return FALSE; | 379 return FALSE; |
461 } | 380 } |
462 uint8_t* bitMapbuffer = (uint8_t*)pDIBitmap->GetBuffer(); | 381 uint8_t* bitMapbuffer = (uint8_t*)pDIBitmap->GetBuffer(); |
463 uint32_t pitch = pDIBitmap->GetPitch(); | 382 uint32_t pitch = pDIBitmap->GetPitch(); |
464 for (int32_t row = 0; row < height; row++) { | 383 for (int32_t row = 0; row < height; row++) { |
465 TIFFReadScanline(tif_ctx, buf, row, 0); | 384 TIFFReadScanline(m_tif_ctx, buf, row, 0); |
466 for (int32_t j = 0; j < size - 2; j += 3) { | 385 for (int32_t j = 0; j < size - 2; j += 3) { |
467 bitMapbuffer[row * pitch + j + 0] = buf[j + 2]; | 386 bitMapbuffer[row * pitch + j + 0] = buf[j + 2]; |
468 bitMapbuffer[row * pitch + j + 1] = buf[j + 1]; | 387 bitMapbuffer[row * pitch + j + 1] = buf[j + 1]; |
469 bitMapbuffer[row * pitch + j + 2] = buf[j + 0]; | 388 bitMapbuffer[row * pitch + j + 2] = buf[j + 0]; |
470 } | 389 } |
471 } | 390 } |
472 _TIFFfree(buf); | 391 _TIFFfree(buf); |
473 return TRUE; | 392 return TRUE; |
474 } | 393 } |
394 | |
475 FX_BOOL CCodec_TiffContext::Decode(CFX_DIBitmap* pDIBitmap) { | 395 FX_BOOL CCodec_TiffContext::Decode(CFX_DIBitmap* pDIBitmap) { |
476 uint32_t img_wid = pDIBitmap->GetWidth(); | 396 uint32_t img_wid = pDIBitmap->GetWidth(); |
477 uint32_t img_hei = pDIBitmap->GetHeight(); | 397 uint32_t img_hei = pDIBitmap->GetHeight(); |
478 uint32_t width = 0; | 398 uint32_t width = 0; |
479 uint32_t height = 0; | 399 uint32_t height = 0; |
480 TIFFGetField(tif_ctx, TIFFTAG_IMAGEWIDTH, &width); | 400 TIFFGetField(m_tif_ctx, TIFFTAG_IMAGEWIDTH, &width); |
481 TIFFGetField(tif_ctx, TIFFTAG_IMAGELENGTH, &height); | 401 TIFFGetField(m_tif_ctx, TIFFTAG_IMAGELENGTH, &height); |
482 if (img_wid != width || img_hei != height) { | 402 if (img_wid != width || img_hei != height) { |
483 return FALSE; | 403 return FALSE; |
484 } | 404 } |
485 if (pDIBitmap->GetBPP() == 32) { | 405 if (pDIBitmap->GetBPP() == 32) { |
486 uint16_t rotation = ORIENTATION_TOPLEFT; | 406 uint16_t rotation = ORIENTATION_TOPLEFT; |
487 TIFFGetField(tif_ctx, TIFFTAG_ORIENTATION, &rotation); | 407 TIFFGetField(m_tif_ctx, TIFFTAG_ORIENTATION, &rotation); |
488 if (TIFFReadRGBAImageOriented(tif_ctx, img_wid, img_hei, | 408 if (TIFFReadRGBAImageOriented(m_tif_ctx, img_wid, img_hei, |
489 (uint32*)pDIBitmap->GetBuffer(), rotation, | 409 (uint32*)pDIBitmap->GetBuffer(), rotation, |
490 1)) { | 410 1)) { |
491 for (uint32_t row = 0; row < img_hei; row++) { | 411 for (uint32_t row = 0; row < img_hei; row++) { |
492 uint8_t* row_buf = (uint8_t*)pDIBitmap->GetScanline(row); | 412 uint8_t* row_buf = (uint8_t*)pDIBitmap->GetScanline(row); |
493 _TiffBGRA2RGBA(row_buf, img_wid, 4); | 413 TiffBGRA2RGBA(row_buf, img_wid, 4); |
494 } | 414 } |
495 return TRUE; | 415 return TRUE; |
496 } | 416 } |
497 } | 417 } |
498 uint16_t spp, bps; | 418 uint16_t spp; |
499 TIFFGetField(tif_ctx, TIFFTAG_SAMPLESPERPIXEL, &spp); | 419 uint16_t bps; |
500 TIFFGetField(tif_ctx, TIFFTAG_BITSPERSAMPLE, &bps); | 420 TIFFGetField(m_tif_ctx, TIFFTAG_SAMPLESPERPIXEL, &spp); |
421 TIFFGetField(m_tif_ctx, TIFFTAG_BITSPERSAMPLE, &bps); | |
501 uint32_t bpp = bps * spp; | 422 uint32_t bpp = bps * spp; |
502 if (bpp == 1) { | 423 if (bpp == 1) |
503 return Decode1bppRGB(pDIBitmap, height, width, bps, spp); | 424 return Decode1bppRGB(pDIBitmap, height, width, bps, spp); |
504 } else if (bpp <= 8) { | 425 if (bpp <= 8) |
505 return Decode8bppRGB(pDIBitmap, height, width, bps, spp); | 426 return Decode8bppRGB(pDIBitmap, height, width, bps, spp); |
506 } else if (bpp <= 24) { | 427 if (bpp <= 24) |
507 return Decode24bppRGB(pDIBitmap, height, width, bps, spp); | 428 return Decode24bppRGB(pDIBitmap, height, width, bps, spp); |
508 } | |
509 return FALSE; | 429 return FALSE; |
510 } | 430 } |
511 | 431 |
512 CCodec_TiffContext* CCodec_TiffModule::CreateDecoder(IFX_FileRead* file_ptr) { | 432 CCodec_TiffContext* CCodec_TiffModule::CreateDecoder(IFX_FileRead* file_ptr) { |
513 CCodec_TiffContext* pDecoder = new CCodec_TiffContext; | 433 CCodec_TiffContext* pDecoder = new CCodec_TiffContext; |
514 if (!pDecoder->InitDecoder(file_ptr)) { | 434 if (!pDecoder->InitDecoder(file_ptr)) { |
515 delete pDecoder; | 435 delete pDecoder; |
516 return nullptr; | 436 return nullptr; |
517 } | 437 } |
518 return pDecoder; | 438 return pDecoder; |
519 } | 439 } |
520 | 440 |
521 void CCodec_TiffModule::GetFrames(CCodec_TiffContext* ctx, int32_t& frames) { | |
522 ctx->GetFrames(frames); | |
523 } | |
524 | |
525 FX_BOOL CCodec_TiffModule::LoadFrameInfo(CCodec_TiffContext* ctx, | 441 FX_BOOL CCodec_TiffModule::LoadFrameInfo(CCodec_TiffContext* ctx, |
526 int32_t frame, | 442 int32_t frame, |
527 uint32_t& width, | 443 int32_t* width, |
528 uint32_t& height, | 444 int32_t* height, |
529 uint32_t& comps, | 445 int32_t* comps, |
530 uint32_t& bpc, | 446 int32_t* bpc, |
531 CFX_DIBAttribute* pAttribute) { | 447 CFX_DIBAttribute* pAttribute) { |
532 return ctx->LoadFrameInfo(frame, width, height, comps, bpc, pAttribute); | 448 return ctx->LoadFrameInfo(frame, width, height, comps, bpc, pAttribute); |
533 } | 449 } |
534 | 450 |
535 FX_BOOL CCodec_TiffModule::Decode(CCodec_TiffContext* ctx, | 451 FX_BOOL CCodec_TiffModule::Decode(CCodec_TiffContext* ctx, |
536 class CFX_DIBitmap* pDIBitmap) { | 452 class CFX_DIBitmap* pDIBitmap) { |
537 return ctx->Decode(pDIBitmap); | 453 return ctx->Decode(pDIBitmap); |
538 } | 454 } |
539 | 455 |
540 void CCodec_TiffModule::DestroyDecoder(CCodec_TiffContext* ctx) { | 456 void CCodec_TiffModule::DestroyDecoder(CCodec_TiffContext* ctx) { |
541 delete ctx; | 457 delete ctx; |
542 } | 458 } |
OLD | NEW |