1 // Copyright 2014 PDFium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com 6 7 #include "../../../include/fpdfapi/fpdf_module.h" 8 #include "../../../include/fpdfapi/fpdf_page.h" 9 #include "../../../include/fxcodec/fx_codec.h" 10 #include "../../../include/fpdfapi/fpdf_render.h" 11 #include "../fpdf_page/pageint.h" 12 #include "../fpdf_render/render_int.h" 13 CPDF_Dictionary* CPDF_Image::InitJPEG(FX_LPBYTE pData, FX_DWORD size) 14 { 15 FX_INT32 width, height, color_trans, num_comps, bits; 16 if (!CPDF_ModuleMgr::Get()->GetJpegModule()-> 17 LoadInfo(pData, size, width, height, num_comps, bits, color_trans)) { 18 return NULL; 19 } 20 CPDF_Dictionary* pDict = new CPDF_Dictionary; 21 pDict->SetAtName("Type", "XObject"); 22 pDict->SetAtName("Subtype", "Image"); 23 pDict->SetAtInteger("Width", width); 24 pDict->SetAtInteger("Height", height); 25 FX_LPCSTR csname = NULL; 26 if (num_comps == 1) { 27 csname = "DeviceGray"; 28 } else if (num_comps == 3) { 29 csname = "DeviceRGB"; 30 } else if (num_comps == 4) { 31 csname = "DeviceCMYK"; 32 CPDF_Array* pDecode = CPDF_Array::Create(); 33 for (int n = 0; n < 4; n ++) { 34 pDecode->AddInteger(1); 35 pDecode->AddInteger(0); 36 } 37 pDict->SetAt(FX_BSTRC("Decode"), pDecode); 38 } 39 pDict->SetAtName("ColorSpace", csname); 40 pDict->SetAtInteger("BitsPerComponent", bits); 41 pDict->SetAtName("Filter", "DCTDecode"); 42 if (!color_trans) { 43 CPDF_Dictionary* pParms = new CPDF_Dictionary; 44 pDict->SetAt("DecodeParms", pParms); 45 pParms->SetAtInteger("ColorTransform", 0); 46 } 47 m_bIsMask = FALSE; 48 m_Width = width; 49 m_Height = height; 50 if (m_pStream == NULL) { 51 m_pStream = new CPDF_Stream(NULL, 0, NULL); 52 } 53 return pDict; 54 } 55 void CPDF_Image::SetJpegImage(FX_LPBYTE pData, FX_DWORD size) 56 { 57 CPDF_Dictionary *pDict = InitJPEG(pData, size); 58 if (!pDict) { 59 return; 60 } 61 m_pStream->InitStream(pData, size, pDict); 62 } 63 void CPDF_Image::SetJpegImage(IFX_FileRead *pFile) 64 { 65 FX_DWORD size = (FX_DWORD)pFile->GetSize(); 66 if (!size) { 67 return; 68 } 69 FX_DWORD dwEstimateSize = size; 70 if (dwEstimateSize > 8192) { 71 dwEstimateSize = 8192; 72 } 73 FX_LPBYTE pData = FX_Alloc(FX_BYTE, dwEstimateSize); 74 pFile->ReadBlock(pData, 0, dwEstimateSize); 75 CPDF_Dictionary *pDict = InitJPEG(pData, dwEstimateSize); 76 FX_Free(pData); 77 if (!pDict && size > dwEstimateSize) { 78 pData = FX_Alloc(FX_BYTE, size); 79 pFile->ReadBlock(pData, 0, size); 80 pDict = InitJPEG(pData, size); 81 FX_Free(pData); 82 } 83 if (!pDict) { 84 return; 85 } 86 m_pStream->InitStream(pFile, pDict); 87 } 88 void _DCTEncodeBitmap(CPDF_Dictionary *pBitmapDict, const CFX_DIBitmap* pBitmap, int quality, FX_LPBYTE &buf, FX_STRSIZE &size) 89 { 90 } 91 void _JBIG2EncodeBitmap(CPDF_Dictionary *pBitmapDict, const CFX_DIBitmap *pBitmap, CPDF_Document *pDoc, FX_LPBYTE &buf, FX_STRSIZE &size, FX_BOOL bLossLess) 92 { 93 } 94 void CPDF_Image::SetImage(const CFX_DIBitmap* pBitmap, FX_INT32 iCompress, IFX_FileWrite *pFileWrite, IFX_FileRead *pFileRead, const CFX_DIBitmap* pMask, const CPDF_ImageSetParam* pParam) 95 { 96 FX_INT32 BitmapWidth = pBitmap->GetWidth(); 97 FX_INT32 BitmapHeight = pBitmap->GetHeight(); 98 if (BitmapWidth < 1 || BitmapHeight < 1) { 99 return; 100 } 101 FX_LPBYTE src_buf = pBitmap->GetBuffer(); 102 FX_INT32 src_pitch = pBitmap->GetPitch(); 103 FX_INT32 bpp = pBitmap->GetBPP(); 104 FX_BOOL bUseMatte = pParam && pParam->pMatteColor && (pBitmap->GetFormat() == FXDIB_Argb); 105 CPDF_Dictionary* pDict = new CPDF_Dictionary; 106 pDict->SetAtName(FX_BSTRC("Type"), FX_BSTRC("XObject")); 107 pDict->SetAtName(FX_BSTRC("Subtype"), FX_BSTRC("Image")); 108 pDict->SetAtInteger(FX_BSTRC("Width"), BitmapWidth); 109 pDict->SetAtInteger(FX_BSTRC("Height"), BitmapHeight); 110 FX_LPBYTE dest_buf = NULL; 111 FX_STRSIZE dest_pitch = 0, dest_size = 0, opType = -1; 112 if (bpp == 1) { 113 FX_INT32 reset_a = 0, reset_r = 0, reset_g = 0, reset_b = 0; 114 FX_INT32 set_a = 0, set_r = 0, set_g = 0, set_b = 0; 115 if (!pBitmap->IsAlphaMask()) { 116 ArgbDecode(pBitmap->GetPaletteArgb(0), reset_a, reset_r, reset_g, reset_b); 117 ArgbDecode(pBitmap->GetPaletteArgb(1), set_a, set_r, set_g, set_b); 118 } 119 if (set_a == 0 || reset_a == 0) { 120 pDict->SetAt(FX_BSTRC("ImageMask"), new CPDF_Boolean(TRUE)); 121 if (reset_a == 0) { 122 CPDF_Array* pArray = new CPDF_Array; 123 pArray->AddInteger(1); 124 pArray->AddInteger(0); 125 pDict->SetAt(FX_BSTRC("Decode"), pArray); 126 } 127 } else { 128 CPDF_Array* pCS = new CPDF_Array; 129 pCS->AddName(FX_BSTRC("Indexed")); 130 pCS->AddName(FX_BSTRC("DeviceRGB")); 131 pCS->AddInteger(1); 132 CFX_ByteString ct; 133 FX_LPSTR pBuf = ct.GetBuffer(6); 134 pBuf[0] = (FX_CHAR)reset_r; 135 pBuf[1] = (FX_CHAR)reset_g; 136 pBuf[2] = (FX_CHAR)reset_b; 137 pBuf[3] = (FX_CHAR)set_r; 138 pBuf[4] = (FX_CHAR)set_g; 139 pBuf[5] = (FX_CHAR)set_b; 140 ct.ReleaseBuffer(6); 141 pCS->Add(CPDF_String::Create(ct, TRUE)); 142 pDict->SetAt(FX_BSTRC("ColorSpace"), pCS); 143 } 144 pDict->SetAtInteger(FX_BSTRC("BitsPerComponent"), 1); 145 dest_pitch = (BitmapWidth + 7) / 8; 146 if ((iCompress & 0x03) == PDF_IMAGE_NO_COMPRESS) { 147 opType = 1; 148 } else { 149 opType = 0; 150 } 151 } else if (bpp == 8) { 152 FX_INT32 iPalette = pBitmap->GetPaletteSize(); 153 if (iPalette > 0) { 154 CPDF_Array* pCS = new CPDF_Array; 155 m_pDocument->AddIndirectObject(pCS); 156 pCS->AddName(FX_BSTRC("Indexed")); 157 pCS->AddName(FX_BSTRC("DeviceRGB")); 158 pCS->AddInteger(iPalette - 1); 159 FX_LPBYTE pColorTable = FX_Alloc2D(FX_BYTE, iPalette, 3); 160 FX_LPBYTE ptr = pColorTable; 161 for (FX_INT32 i = 0; i < iPalette; i ++) { 162 FX_DWORD argb = pBitmap->GetPaletteArgb(i); 163 ptr[0] = (FX_BYTE)(argb >> 16); 164 ptr[1] = (FX_BYTE)(argb >> 8); 165 ptr[2] = (FX_BYTE)argb; 166 ptr += 3; 167 } 168 CPDF_Stream *pCTS = CPDF_Stream::Create(pColorTable, iPalette * 3, CPDF_Dictionary::Create()); 169 m_pDocument->AddIndirectObject(pCTS); 170 pCS->AddReference(m_pDocument, pCTS); 171 pDict->SetAtReference(FX_BSTRC("ColorSpace"), m_pDocument, pCS); 172 } else { 173 pDict->SetAtName(FX_BSTRC("ColorSpace"), FX_BSTRC("DeviceGray")); 174 } 175 pDict->SetAtInteger(FX_BSTRC("BitsPerComponent"), 8); 176 if ((iCompress & 0x03) == PDF_IMAGE_NO_COMPRESS) { 177 dest_pitch = BitmapWidth; 178 opType = 1; 179 } else { 180 opType = 0; 181 } 182 } else { 183 pDict->SetAtName(FX_BSTRC("ColorSpace"), FX_BSTRC("DeviceRGB")); 184 pDict->SetAtInteger(FX_BSTRC("BitsPerComponent"), 8); 185 if ((iCompress & 0x03) == PDF_IMAGE_NO_COMPRESS) { 186 dest_pitch = BitmapWidth * 3; 187 opType = 2; 188 } else { 189 opType = 0; 190 } 191 } 192 const CFX_DIBitmap* pMaskBitmap = NULL; 193 FX_BOOL bDeleteMask = FALSE; 194 if (pBitmap->HasAlpha()) { 195 pMaskBitmap = pBitmap->GetAlphaMask(); 196 bDeleteMask = TRUE; 197 } 198 if (!pMaskBitmap && pMask) { 199 FXDIB_Format maskFormat = pMask->GetFormat(); 200 if (maskFormat == FXDIB_1bppMask || maskFormat == FXDIB_8bppMask) { 201 pMaskBitmap = pMask; 202 } 203 } 204 if (pMaskBitmap) { 205 FX_INT32 maskWidth = pMaskBitmap->GetWidth(); 206 FX_INT32 maskHeight = pMaskBitmap->GetHeight(); 207 FX_LPBYTE mask_buf = NULL; 208 FX_STRSIZE mask_size; 209 CPDF_Dictionary* pMaskDict = new CPDF_Dictionary; 210 pMaskDict->SetAtName(FX_BSTRC("Type"), FX_BSTRC("XObject")); 211 pMaskDict->SetAtName(FX_BSTRC("Subtype"), FX_BSTRC("Image")); 212 pMaskDict->SetAtInteger(FX_BSTRC("Width"), maskWidth); 213 pMaskDict->SetAtInteger(FX_BSTRC("Height"), maskHeight); 214 pMaskDict->SetAtName(FX_BSTRC("ColorSpace"), FX_BSTRC("DeviceGray")); 215 pMaskDict->SetAtInteger(FX_BSTRC("BitsPerComponent"), 8); 216 if (pMaskBitmap->GetBPP() == 8 && (iCompress & PDF_IMAGE_MASK_LOSSY_COMPRESS) != 0) { 217 _DCTEncodeBitmap(pMaskDict, pMaskBitmap, pParam ? pParam->nQuality : 75, mask_buf, mask_size); 218 } else if (pMaskBitmap->GetFormat() == FXDIB_1bppMask) { 219 _JBIG2EncodeBitmap(pMaskDict, pMaskBitmap, m_pDocument, mask_buf, mask_size, TRUE); 220 } else { 221 mask_buf = FX_Alloc2D(FX_BYTE, maskHeight, maskWidth); 222 mask_size = maskHeight * maskWidth; // Safe since checked alloc returned. 223 for (FX_INT32 a = 0; a < maskHeight; a ++) { 224 FXSYS_memcpy32(mask_buf + a * maskWidth, pMaskBitmap->GetScanline(a), maskWidth); 225 } 226 } 227 pMaskDict->SetAtInteger(FX_BSTRC("Length"), mask_size); 228 if (bUseMatte) { 229 int a, r, g, b; 230 ArgbDecode(*(pParam->pMatteColor), a, r, g, b); 231 CPDF_Array* pMatte = new CPDF_Array; 232 pMatte->AddInteger(r); 233 pMatte->AddInteger(g); 234 pMatte->AddInteger(b); 235 pMaskDict->SetAt(FX_BSTRC("Matte"), pMatte); 236 } 237 CPDF_Stream* pMaskStream = new CPDF_Stream(mask_buf, mask_size, pMaskDict); 238 m_pDocument->AddIndirectObject(pMaskStream); 239 pDict->SetAtReference(FX_BSTRC("SMask"), m_pDocument, pMaskStream); 240 if (bDeleteMask) { 241 delete pMaskBitmap; 242 } 243 } 244 FX_BOOL bStream = pFileWrite != NULL && pFileRead != NULL; 245 if (opType == 0) { 246 if (iCompress & PDF_IMAGE_LOSSLESS_COMPRESS) { 247 if (pBitmap->GetBPP() == 1) { 248 _JBIG2EncodeBitmap(pDict, pBitmap, m_pDocument, dest_buf, dest_size, TRUE); 249 } 250 } else { 251 if (pBitmap->GetBPP() == 1) { 252 _JBIG2EncodeBitmap(pDict, pBitmap, m_pDocument, dest_buf, dest_size, FALSE); 253 } else if (pBitmap->GetBPP() >= 8 && pBitmap->GetPalette() != NULL) { 254 CFX_DIBitmap *pNewBitmap = new CFX_DIBitmap(); 255 pNewBitmap->Copy(pBitmap); 256 pNewBitmap->ConvertFormat(FXDIB_Rgb); 257 SetImage(pNewBitmap, iCompress, pFileWrite, pFileRead); 258 if (pDict) { 259 pDict->Release(); 260 pDict = NULL; 261 } 262 if (dest_buf) { 263 FX_Free(dest_buf); 264 dest_buf = NULL; 265 } 266 dest_size = 0; 267 delete pNewBitmap; 268 return; 269 } else { 270 if (bUseMatte) { 271 CFX_DIBitmap *pNewBitmap = new CFX_DIBitmap(); 272 pNewBitmap->Create(BitmapWidth, BitmapHeight, FXDIB_Argb); 273 FX_LPBYTE dst_buf = pNewBitmap->GetBuffer(); 274 FX_INT32 src_offset = 0; 275 for (FX_INT32 row = 0; row < BitmapHeight; row ++) { 276 src_offset = row * src_pitch; 277 for (FX_INT32 column = 0; column < BitmapWidth; column ++) { 278 FX_FLOAT alpha = src_buf[src_offset + 3] / 255.0f; 279 dst_buf[src_offset] = (FX_BYTE)(src_buf[src_offset] * alpha); 280 dst_buf[src_offset + 1] = (FX_BYTE)(src_buf[src_offset + 1] * alpha); 281 dst_buf[src_offset + 2] = (FX_BYTE)(src_buf[src_offset + 2] * alpha); 282 dst_buf[src_offset + 3] = (FX_BYTE)(src_buf[src_offset + 3]); 283 src_offset += 4; 284 } 285 } 286 _DCTEncodeBitmap(pDict, pNewBitmap, pParam ? pParam->nQuality : 75, dest_buf, dest_size); 287 delete pNewBitmap; 288 } else { 289 _DCTEncodeBitmap(pDict, pBitmap, pParam ? pParam->nQuality : 75, dest_buf, dest_size); 290 } 291 } 292 } 293 if (bStream) { 294 pFileWrite->WriteBlock(dest_buf, dest_size); 295 FX_Free(dest_buf); 296 dest_buf = NULL; 297 } 298 } else if (opType == 1) { 299 if (!bStream) { 300 dest_buf = FX_Alloc2D(FX_BYTE, dest_pitch, BitmapHeight); 301 dest_size = dest_pitch * BitmapHeight; // Safe since checked alloc returned. 302 } 303 FX_LPBYTE pDest = dest_buf; 304 for (FX_INT32 i = 0; i < BitmapHeight; i ++) { 305 if (!bStream) { 306 FXSYS_memcpy32(pDest, src_buf, dest_pitch); 307 pDest += dest_pitch; 308 } else { 309 pFileWrite->WriteBlock(src_buf, dest_pitch); 310 } 311 src_buf += src_pitch; 312 } 313 } else if (opType == 2) { 314 if (!bStream) { 315 dest_buf = FX_Alloc2D(FX_BYTE, dest_pitch, BitmapHeight); 316 dest_size = dest_pitch * BitmapHeight; // Safe since checked alloc returned. 317 } else { 318 dest_buf = FX_Alloc(FX_BYTE, dest_pitch); 319 } 320 FX_LPBYTE pDest = dest_buf; 321 FX_INT32 src_offset = 0; 322 FX_INT32 dest_offset = 0; 323 for (FX_INT32 row = 0; row < BitmapHeight; row ++) { 324 src_offset = row * src_pitch; 325 for (FX_INT32 column = 0; column < BitmapWidth; column ++) { 326 FX_FLOAT alpha = bUseMatte ? src_buf[src_offset + 3] / 255.0f : 1; 327 pDest[dest_offset] = (FX_BYTE)(src_buf[src_offset + 2] * alpha); 328 pDest[dest_offset + 1] = (FX_BYTE)(src_buf[src_offset + 1] * alpha); 329 pDest[dest_offset + 2] = (FX_BYTE)(src_buf[src_offset] * alpha); 330 dest_offset += 3; 331 src_offset += bpp == 24 ? 3 : 4; 332 } 333 if (bStream) { 334 pFileWrite->WriteBlock(pDest, dest_pitch); 335 pDest = dest_buf; 336 } else { 337 pDest += dest_pitch; 338 } 339 dest_offset = 0; 340 } 341 if (bStream) { 342 FX_Free(dest_buf); 343 dest_buf = NULL; 344 } 345 } 346 if (m_pStream == NULL) { 347 m_pStream = new CPDF_Stream(NULL, 0, NULL); 348 } 349 if (!bStream) { 350 m_pStream->InitStream(dest_buf, dest_size, pDict); 351 } else { 352 pFileWrite->Flush(); 353 m_pStream->InitStream(pFileRead, pDict); 354 } 355 m_bIsMask = pBitmap->IsAlphaMask(); 356 m_Width = BitmapWidth; 357 m_Height = BitmapHeight; 358 if (dest_buf) { 359 FX_Free(dest_buf); 360 } 361 } 362 void CPDF_Image::ResetCache(CPDF_Page* pPage, const CFX_DIBitmap* pBitmap) 363 { 364 pPage->GetRenderCache()->ResetBitmap(m_pStream, pBitmap); 365 } 366
