| OLD | NEW |
|---|
| (Empty) |
| 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 "core/include/fxcodec/fx_codec.h" | |
| 8 | |
| 9 #include <cmath> | |
| 10 #include <utility> | |
| 11 | |
| 12 #include "core/include/fxcrt/fx_ext.h" | |
| 13 #include "core/include/fxcrt/fx_safe_types.h" | |
| 14 #include "core/src/fxcodec/codec/codec_int.h" | |
| 15 #include "third_party/base/logging.h" | |
| 16 | |
| 17 CCodec_ModuleMgr::CCodec_ModuleMgr() | |
| 18 : m_pBasicModule(new CCodec_BasicModule), | |
| 19 m_pFaxModule(new CCodec_FaxModule), | |
| 20 m_pJpegModule(new CCodec_JpegModule), | |
| 21 m_pJpxModule(new CCodec_JpxModule), | |
| 22 m_pJbig2Module(new CCodec_Jbig2Module), | |
| 23 m_pIccModule(new CCodec_IccModule), | |
| 24 #ifdef PDF_ENABLE_XFA | |
| 25 m_pPngModule(new CCodec_PngModule), | |
| 26 m_pGifModule(new CCodec_GifModule), | |
| 27 m_pBmpModule(new CCodec_BmpModule), | |
| 28 m_pTiffModule(new CCodec_TiffModule), | |
| 29 #endif // PDF_ENABLE_XFA | |
| 30 m_pFlateModule(new CCodec_FlateModule) { | |
| 31 } | |
| 32 | |
| 33 CCodec_ScanlineDecoder::ImageDataCache::ImageDataCache(int width, | |
| 34 int height, | |
| 35 FX_DWORD pitch) | |
| 36 : m_Width(width), m_Height(height), m_Pitch(pitch), m_nCachedLines(0) {} | |
| 37 | |
| 38 CCodec_ScanlineDecoder::ImageDataCache::~ImageDataCache() { | |
| 39 } | |
| 40 | |
| 41 bool CCodec_ScanlineDecoder::ImageDataCache::AllocateCache() { | |
| 42 if (m_Pitch == 0 || m_Height < 0) | |
| 43 return false; | |
| 44 | |
| 45 FX_SAFE_SIZE_T size = m_Pitch; | |
| 46 size *= m_Height; | |
| 47 if (!size.IsValid()) | |
| 48 return false; | |
| 49 | |
| 50 m_Data.reset(FX_TryAlloc(uint8_t, size.ValueOrDie())); | |
| 51 return IsValid(); | |
| 52 } | |
| 53 | |
| 54 void CCodec_ScanlineDecoder::ImageDataCache::AppendLine(const uint8_t* line) { | |
| 55 // If the callers adds more lines than there is room, fail. | |
| 56 if (m_Pitch == 0 || m_nCachedLines >= m_Height) { | |
| 57 NOTREACHED(); | |
| 58 return; | |
| 59 } | |
| 60 | |
| 61 size_t offset = m_Pitch; | |
| 62 FXSYS_memcpy(m_Data.get() + offset * m_nCachedLines, line, m_Pitch); | |
| 63 ++m_nCachedLines; | |
| 64 } | |
| 65 | |
| 66 const uint8_t* CCodec_ScanlineDecoder::ImageDataCache::GetLine(int line) const { | |
| 67 if (m_Pitch == 0 || line < 0 || line >= m_nCachedLines) | |
| 68 return nullptr; | |
| 69 | |
| 70 size_t offset = m_Pitch; | |
| 71 return m_Data.get() + offset * line; | |
| 72 } | |
| 73 | |
| 74 CCodec_ScanlineDecoder::CCodec_ScanlineDecoder() | |
| 75 : m_NextLine(-1), m_pLastScanline(nullptr) { | |
| 76 } | |
| 77 | |
| 78 CCodec_ScanlineDecoder::~CCodec_ScanlineDecoder() { | |
| 79 } | |
| 80 | |
| 81 const uint8_t* CCodec_ScanlineDecoder::GetScanline(int line) { | |
| 82 if (m_pDataCache && line < m_pDataCache->NumLines()) | |
| 83 return m_pDataCache->GetLine(line); | |
| 84 | |
| 85 if (m_NextLine == line + 1) | |
| 86 return m_pLastScanline; | |
| 87 | |
| 88 if (m_NextLine < 0 || m_NextLine > line) { | |
| 89 if (!v_Rewind()) | |
| 90 return nullptr; | |
| 91 m_NextLine = 0; | |
| 92 } | |
| 93 while (m_NextLine < line) { | |
| 94 ReadNextLine(); | |
| 95 m_NextLine++; | |
| 96 } | |
| 97 m_pLastScanline = ReadNextLine(); | |
| 98 m_NextLine++; | |
| 99 return m_pLastScanline; | |
| 100 } | |
| 101 | |
| 102 FX_BOOL CCodec_ScanlineDecoder::SkipToScanline(int line, IFX_Pause* pPause) { | |
| 103 if (m_pDataCache && line < m_pDataCache->NumLines()) | |
| 104 return FALSE; | |
| 105 | |
| 106 if (m_NextLine == line || m_NextLine == line + 1) | |
| 107 return FALSE; | |
| 108 | |
| 109 if (m_NextLine < 0 || m_NextLine > line) { | |
| 110 v_Rewind(); | |
| 111 m_NextLine = 0; | |
| 112 } | |
| 113 m_pLastScanline = nullptr; | |
| 114 while (m_NextLine < line) { | |
| 115 m_pLastScanline = ReadNextLine(); | |
| 116 m_NextLine++; | |
| 117 if (pPause && pPause->NeedToPauseNow()) { | |
| 118 return TRUE; | |
| 119 } | |
| 120 } | |
| 121 return FALSE; | |
| 122 } | |
| 123 | |
| 124 uint8_t* CCodec_ScanlineDecoder::ReadNextLine() { | |
| 125 uint8_t* pLine = v_GetNextLine(); | |
| 126 if (!pLine) | |
| 127 return nullptr; | |
| 128 | |
| 129 if (m_pDataCache && m_NextLine == m_pDataCache->NumLines()) | |
| 130 m_pDataCache->AppendLine(pLine); | |
| 131 return pLine; | |
| 132 } | |
| 133 | |
| 134 void CCodec_ScanlineDecoder::DownScale(int dest_width, int dest_height) { | |
| 135 dest_width = std::abs(dest_width); | |
| 136 dest_height = std::abs(dest_height); | |
| 137 v_DownScale(dest_width, dest_height); | |
| 138 | |
| 139 if (m_pDataCache && | |
| 140 m_pDataCache->IsSameDimensions(m_OutputWidth, m_OutputHeight)) { | |
| 141 return; | |
| 142 } | |
| 143 | |
| 144 std::unique_ptr<ImageDataCache> cache( | |
| 145 new ImageDataCache(m_OutputWidth, m_OutputHeight, m_Pitch)); | |
| 146 if (!cache->AllocateCache()) | |
| 147 return; | |
| 148 | |
| 149 m_pDataCache = std::move(cache); | |
| 150 } | |
| 151 | |
| 152 FX_BOOL CCodec_BasicModule::RunLengthEncode(const uint8_t* src_buf, | |
| 153 FX_DWORD src_size, | |
| 154 uint8_t*& dest_buf, | |
| 155 FX_DWORD& dest_size) { | |
| 156 return FALSE; | |
| 157 } | |
| 158 | |
| 159 #define EXPONENT_DETECT(ptr) \ | |
| 160 for (;; ptr++) { \ | |
| 161 if (!std::isdigit(*ptr)) { \ | |
| 162 if (endptr) \ | |
| 163 *endptr = (char*)ptr; \ | |
| 164 break; \ | |
| 165 } else { \ | |
| 166 exp_ret *= 10; \ | |
| 167 exp_ret += FXSYS_toDecimalDigit(*ptr); \ | |
| 168 continue; \ | |
| 169 } \ | |
| 170 } | |
| 171 | |
| 172 extern "C" double FXstrtod(const char* nptr, char** endptr) { | |
| 173 double ret = 0.0; | |
| 174 const char* ptr = nptr; | |
| 175 const char* exp_ptr = NULL; | |
| 176 int e_number = 0, e_signal = 0, e_point = 0, is_negative = 0; | |
| 177 int exp_ret = 0, exp_sig = 1, fra_ret = 0, fra_count = 0, fra_base = 1; | |
| 178 if (!nptr) { | |
| 179 return 0.0; | |
| 180 } | |
| 181 for (;; ptr++) { | |
| 182 if (!e_number && !e_point && (*ptr == '\t' || *ptr == ' ')) | |
| 183 continue; | |
| 184 | |
| 185 if (std::isdigit(*ptr)) { | |
| 186 if (!e_number) | |
| 187 e_number = 1; | |
| 188 | |
| 189 if (!e_point) { | |
| 190 ret *= 10; | |
| 191 ret += FXSYS_toDecimalDigit(*ptr); | |
| 192 } else { | |
| 193 fra_count++; | |
| 194 fra_ret *= 10; | |
| 195 fra_ret += FXSYS_toDecimalDigit(*ptr); | |
| 196 } | |
| 197 continue; | |
| 198 } | |
| 199 if (!e_point && *ptr == '.') { | |
| 200 e_point = 1; | |
| 201 continue; | |
| 202 } | |
| 203 if (!e_number && !e_point && !e_signal) { | |
| 204 switch (*ptr) { | |
| 205 case '-': | |
| 206 is_negative = 1; | |
| 207 case '+': | |
| 208 e_signal = 1; | |
| 209 continue; | |
| 210 } | |
| 211 } | |
| 212 if (e_number && (*ptr == 'e' || *ptr == 'E')) { | |
| 213 exp_ptr = ptr++; | |
| 214 if (*ptr == '+' || *ptr == '-') { | |
| 215 exp_sig = (*ptr++ == '+') ? 1 : -1; | |
| 216 if (!std::isdigit(*ptr)) { | |
| 217 if (endptr) { | |
| 218 *endptr = (char*)exp_ptr; | |
| 219 } | |
| 220 break; | |
| 221 } | |
| 222 EXPONENT_DETECT(ptr); | |
| 223 } else if (std::isdigit(*ptr)) { | |
| 224 EXPONENT_DETECT(ptr); | |
| 225 } else { | |
| 226 if (endptr) { | |
| 227 *endptr = (char*)exp_ptr; | |
| 228 } | |
| 229 break; | |
| 230 } | |
| 231 break; | |
| 232 } | |
| 233 if (ptr != nptr && !e_number) { | |
| 234 if (endptr) { | |
| 235 *endptr = (char*)nptr; | |
| 236 } | |
| 237 break; | |
| 238 } | |
| 239 if (endptr) { | |
| 240 *endptr = (char*)ptr; | |
| 241 } | |
| 242 break; | |
| 243 } | |
| 244 while (fra_count--) { | |
| 245 fra_base *= 10; | |
| 246 } | |
| 247 ret += (double)fra_ret / (double)fra_base; | |
| 248 if (exp_sig == 1) { | |
| 249 while (exp_ret--) { | |
| 250 ret *= 10.0; | |
| 251 } | |
| 252 } else { | |
| 253 while (exp_ret--) { | |
| 254 ret /= 10.0; | |
| 255 } | |
| 256 } | |
| 257 return is_negative ? -ret : ret; | |
| 258 } | |
| 259 #undef EXPONENT_DETECT | |
| 260 | |
| 261 FX_BOOL CCodec_BasicModule::A85Encode(const uint8_t* src_buf, | |
| 262 FX_DWORD src_size, | |
| 263 uint8_t*& dest_buf, | |
| 264 FX_DWORD& dest_size) { | |
| 265 return FALSE; | |
| 266 } | |
| 267 | |
| 268 #ifdef PDF_ENABLE_XFA | |
| 269 CFX_DIBAttribute::CFX_DIBAttribute() | |
| 270 : m_nXDPI(-1), | |
| 271 m_nYDPI(-1), | |
| 272 m_fAspectRatio(-1.0f), | |
| 273 m_wDPIUnit(0), | |
| 274 m_nGifLeft(0), | |
| 275 m_nGifTop(0), | |
| 276 m_pGifLocalPalette(nullptr), | |
| 277 m_nGifLocalPalNum(0), | |
| 278 m_nBmpCompressType(0) { | |
| 279 FXSYS_memset(m_strTime, 0, sizeof(m_strTime)); | |
| 280 } | |
| 281 CFX_DIBAttribute::~CFX_DIBAttribute() { | |
| 282 for (const auto& pair : m_Exif) | |
| 283 FX_Free(pair.second); | |
| 284 } | |
| 285 #endif // PDF_ENABLE_XFA | |
| 286 | |
| 287 class CCodec_RLScanlineDecoder : public CCodec_ScanlineDecoder { | |
| 288 public: | |
| 289 CCodec_RLScanlineDecoder(); | |
| 290 ~CCodec_RLScanlineDecoder() override; | |
| 291 | |
| 292 FX_BOOL Create(const uint8_t* src_buf, | |
| 293 FX_DWORD src_size, | |
| 294 int width, | |
| 295 int height, | |
| 296 int nComps, | |
| 297 int bpc); | |
| 298 | |
| 299 // CCodec_ScanlineDecoder | |
| 300 void v_DownScale(int dest_width, int dest_height) override {} | |
| 301 FX_BOOL v_Rewind() override; | |
| 302 uint8_t* v_GetNextLine() override; | |
| 303 FX_DWORD GetSrcOffset() override { return m_SrcOffset; } | |
| 304 | |
| 305 protected: | |
| 306 FX_BOOL CheckDestSize(); | |
| 307 void GetNextOperator(); | |
| 308 void UpdateOperator(uint8_t used_bytes); | |
| 309 | |
| 310 uint8_t* m_pScanline; | |
| 311 const uint8_t* m_pSrcBuf; | |
| 312 FX_DWORD m_SrcSize; | |
| 313 FX_DWORD m_dwLineBytes; | |
| 314 FX_DWORD m_SrcOffset; | |
| 315 FX_BOOL m_bEOD; | |
| 316 uint8_t m_Operator; | |
| 317 }; | |
| 318 CCodec_RLScanlineDecoder::CCodec_RLScanlineDecoder() | |
| 319 : m_pScanline(NULL), | |
| 320 m_pSrcBuf(NULL), | |
| 321 m_SrcSize(0), | |
| 322 m_dwLineBytes(0), | |
| 323 m_SrcOffset(0), | |
| 324 m_bEOD(FALSE), | |
| 325 m_Operator(0) {} | |
| 326 CCodec_RLScanlineDecoder::~CCodec_RLScanlineDecoder() { | |
| 327 FX_Free(m_pScanline); | |
| 328 } | |
| 329 FX_BOOL CCodec_RLScanlineDecoder::CheckDestSize() { | |
| 330 FX_DWORD i = 0; | |
| 331 FX_DWORD old_size = 0; | |
| 332 FX_DWORD dest_size = 0; | |
| 333 while (i < m_SrcSize) { | |
| 334 if (m_pSrcBuf[i] < 128) { | |
| 335 old_size = dest_size; | |
| 336 dest_size += m_pSrcBuf[i] + 1; | |
| 337 if (dest_size < old_size) { | |
| 338 return FALSE; | |
| 339 } | |
| 340 i += m_pSrcBuf[i] + 2; | |
| 341 } else if (m_pSrcBuf[i] > 128) { | |
| 342 old_size = dest_size; | |
| 343 dest_size += 257 - m_pSrcBuf[i]; | |
| 344 if (dest_size < old_size) { | |
| 345 return FALSE; | |
| 346 } | |
| 347 i += 2; | |
| 348 } else { | |
| 349 break; | |
| 350 } | |
| 351 } | |
| 352 if (((FX_DWORD)m_OrigWidth * m_nComps * m_bpc * m_OrigHeight + 7) / 8 > | |
| 353 dest_size) { | |
| 354 return FALSE; | |
| 355 } | |
| 356 return TRUE; | |
| 357 } | |
| 358 FX_BOOL CCodec_RLScanlineDecoder::Create(const uint8_t* src_buf, | |
| 359 FX_DWORD src_size, | |
| 360 int width, | |
| 361 int height, | |
| 362 int nComps, | |
| 363 int bpc) { | |
| 364 m_pSrcBuf = src_buf; | |
| 365 m_SrcSize = src_size; | |
| 366 m_OutputWidth = m_OrigWidth = width; | |
| 367 m_OutputHeight = m_OrigHeight = height; | |
| 368 m_nComps = nComps; | |
| 369 m_bpc = bpc; | |
| 370 m_bColorTransformed = FALSE; | |
| 371 m_DownScale = 1; | |
| 372 // Aligning the pitch to 4 bytes requires an integer overflow check. | |
| 373 FX_SAFE_DWORD pitch = width; | |
| 374 pitch *= nComps; | |
| 375 pitch *= bpc; | |
| 376 pitch += 31; | |
| 377 pitch /= 32; | |
| 378 pitch *= 4; | |
| 379 if (!pitch.IsValid()) { | |
| 380 return FALSE; | |
| 381 } | |
| 382 m_Pitch = pitch.ValueOrDie(); | |
| 383 // Overflow should already have been checked before this is called. | |
| 384 m_dwLineBytes = (static_cast<FX_DWORD>(width) * nComps * bpc + 7) / 8; | |
| 385 m_pScanline = FX_Alloc(uint8_t, m_Pitch); | |
| 386 return CheckDestSize(); | |
| 387 } | |
| 388 FX_BOOL CCodec_RLScanlineDecoder::v_Rewind() { | |
| 389 FXSYS_memset(m_pScanline, 0, m_Pitch); | |
| 390 m_SrcOffset = 0; | |
| 391 m_bEOD = FALSE; | |
| 392 m_Operator = 0; | |
| 393 return TRUE; | |
| 394 } | |
| 395 uint8_t* CCodec_RLScanlineDecoder::v_GetNextLine() { | |
| 396 if (m_SrcOffset == 0) { | |
| 397 GetNextOperator(); | |
| 398 } else { | |
| 399 if (m_bEOD) { | |
| 400 return NULL; | |
| 401 } | |
| 402 } | |
| 403 FXSYS_memset(m_pScanline, 0, m_Pitch); | |
| 404 FX_DWORD col_pos = 0; | |
| 405 FX_BOOL eol = FALSE; | |
| 406 while (m_SrcOffset < m_SrcSize && !eol) { | |
| 407 if (m_Operator < 128) { | |
| 408 FX_DWORD copy_len = m_Operator + 1; | |
| 409 if (col_pos + copy_len >= m_dwLineBytes) { | |
| 410 copy_len = m_dwLineBytes - col_pos; | |
| 411 eol = TRUE; | |
| 412 } | |
| 413 if (copy_len >= m_SrcSize - m_SrcOffset) { | |
| 414 copy_len = m_SrcSize - m_SrcOffset; | |
| 415 m_bEOD = TRUE; | |
| 416 } | |
| 417 FXSYS_memcpy(m_pScanline + col_pos, m_pSrcBuf + m_SrcOffset, copy_len); | |
| 418 col_pos += copy_len; | |
| 419 UpdateOperator((uint8_t)copy_len); | |
| 420 } else if (m_Operator > 128) { | |
| 421 int fill = 0; | |
| 422 if (m_SrcOffset - 1 < m_SrcSize - 1) { | |
| 423 fill = m_pSrcBuf[m_SrcOffset]; | |
| 424 } | |
| 425 FX_DWORD duplicate_len = 257 - m_Operator; | |
| 426 if (col_pos + duplicate_len >= m_dwLineBytes) { | |
| 427 duplicate_len = m_dwLineBytes - col_pos; | |
| 428 eol = TRUE; | |
| 429 } | |
| 430 FXSYS_memset(m_pScanline + col_pos, fill, duplicate_len); | |
| 431 col_pos += duplicate_len; | |
| 432 UpdateOperator((uint8_t)duplicate_len); | |
| 433 } else { | |
| 434 m_bEOD = TRUE; | |
| 435 break; | |
| 436 } | |
| 437 } | |
| 438 return m_pScanline; | |
| 439 } | |
| 440 void CCodec_RLScanlineDecoder::GetNextOperator() { | |
| 441 if (m_SrcOffset >= m_SrcSize) { | |
| 442 m_Operator = 128; | |
| 443 return; | |
| 444 } | |
| 445 m_Operator = m_pSrcBuf[m_SrcOffset]; | |
| 446 m_SrcOffset++; | |
| 447 } | |
| 448 void CCodec_RLScanlineDecoder::UpdateOperator(uint8_t used_bytes) { | |
| 449 if (used_bytes == 0) { | |
| 450 return; | |
| 451 } | |
| 452 if (m_Operator < 128) { | |
| 453 FXSYS_assert((FX_DWORD)m_Operator + 1 >= used_bytes); | |
| 454 if (used_bytes == m_Operator + 1) { | |
| 455 m_SrcOffset += used_bytes; | |
| 456 GetNextOperator(); | |
| 457 return; | |
| 458 } | |
| 459 m_Operator -= used_bytes; | |
| 460 m_SrcOffset += used_bytes; | |
| 461 if (m_SrcOffset >= m_SrcSize) { | |
| 462 m_Operator = 128; | |
| 463 } | |
| 464 return; | |
| 465 } | |
| 466 uint8_t count = 257 - m_Operator; | |
| 467 FXSYS_assert((FX_DWORD)count >= used_bytes); | |
| 468 if (used_bytes == count) { | |
| 469 m_SrcOffset++; | |
| 470 GetNextOperator(); | |
| 471 return; | |
| 472 } | |
| 473 count -= used_bytes; | |
| 474 m_Operator = 257 - count; | |
| 475 } | |
| 476 ICodec_ScanlineDecoder* CCodec_BasicModule::CreateRunLengthDecoder( | |
| 477 const uint8_t* src_buf, | |
| 478 FX_DWORD src_size, | |
| 479 int width, | |
| 480 int height, | |
| 481 int nComps, | |
| 482 int bpc) { | |
| 483 CCodec_RLScanlineDecoder* pRLScanlineDecoder = new CCodec_RLScanlineDecoder; | |
| 484 if (!pRLScanlineDecoder->Create(src_buf, src_size, width, height, nComps, | |
| 485 bpc)) { | |
| 486 delete pRLScanlineDecoder; | |
| 487 return NULL; | |
| 488 } | |
| 489 return pRLScanlineDecoder; | |
| 490 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1800523005:
Move core/src/ up to core/. (Closed)
Base URL: https://pdfium.googlesource.com/pdfium.git@master