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 "../../../include/fxcrt/fx_ext.h" | 7 #include "../../../include/fxcrt/fx_ext.h" |
8 #include "../../../include/fpdfapi/fpdf_serial.h" | 8 #include "../../../include/fpdfapi/fpdf_serial.h" |
9 #include "editint.h" | 9 #include "editint.h" |
10 | 10 |
11 #define PDF_OBJECTSTREAM_MAXLENGTH (256 * 1024) | 11 #define PDF_OBJECTSTREAM_MAXLENGTH (256 * 1024) |
12 #define PDF_XREFSTREAM_MAXSIZE 10000 | 12 #define PDF_XREFSTREAM_MAXSIZE 10000 |
13 extern void FlateEncode(const uint8_t* src_buf, FX_DWORD src_data, uint8_t*& des
t_buf, FX_DWORD& dest_size); | 13 extern void FlateEncode(const uint8_t* src_buf, FX_DWORD src_data, uint8_t*& des
t_buf, FX_DWORD& dest_size); |
14 extern void FlateEncode(const uint8_t* src_buf, FX_DWORD src_size, int predictor
, int Colors, int BitsPerComponent, int Columns, | 14 extern void FlateEncode(const uint8_t* src_buf, FX_DWORD src_size, int predictor
, int Colors, int BitsPerComponent, int Columns, |
15 uint8_t*& dest_buf, FX_DWORD& dest_size); | 15 uint8_t*& dest_buf, FX_DWORD& dest_size); |
16 extern FX_BOOL IsSignatureDict(const CPDF_Dictionary* pDict); | 16 extern bool IsSignatureDict(const CPDF_Dictionary* pDict); |
17 int32_t PDF_CreatorAppendObject(const CPDF_Object* pObj, CFX_FileBufferArchive *
pFile, FX_FILESIZE& offset) | 17 int32_t PDF_CreatorAppendObject(const CPDF_Object* pObj, CFX_FileBufferArchive *
pFile, FX_FILESIZE& offset) |
18 { | 18 { |
19 int32_t len = 0; | 19 int32_t len = 0; |
20 if (pObj == NULL) { | 20 if (pObj == NULL) { |
21 if (pFile->AppendString(FX_BSTRC(" null")) < 0) { | 21 if (pFile->AppendString(FX_BSTRC(" null")) < 0) { |
22 return -1; | 22 return -1; |
23 } | 23 } |
24 offset += 5; | 24 offset += 5; |
25 return 1; | 25 return 1; |
26 } | 26 } |
27 switch (pObj->GetType()) { | 27 switch (pObj->GetType()) { |
28 case PDFOBJ_NULL: | 28 case PDFOBJ_NULL: |
29 if (pFile->AppendString(FX_BSTRC(" null")) < 0) { | 29 if (pFile->AppendString(FX_BSTRC(" null")) < 0) { |
30 return -1; | 30 return -1; |
31 } | 31 } |
32 offset += 5; | 32 offset += 5; |
33 break; | 33 break; |
34 case PDFOBJ_BOOLEAN: | 34 case PDFOBJ_BOOLEAN: |
35 case PDFOBJ_NUMBER: | 35 case PDFOBJ_NUMBER: |
36 if (pFile->AppendString(FX_BSTRC(" ")) < 0) { | 36 if (pFile->AppendString(FX_BSTRC(" ")) < 0) { |
37 return -1; | 37 return -1; |
38 } | 38 } |
39 if ((len = pFile->AppendString(pObj->GetString())) < 0) { | 39 if ((len = pFile->AppendString(pObj->GetString())) < 0) { |
40 return -1; | 40 return -1; |
41 } | 41 } |
42 offset += len + 1; | 42 offset += len + 1; |
43 break; | 43 break; |
44 case PDFOBJ_STRING: { | 44 case PDFOBJ_STRING: { |
45 CFX_ByteString str = pObj->GetString(); | 45 CFX_ByteString str = pObj->GetString(); |
46 FX_BOOL bHex = ((CPDF_String*)pObj)->IsHex(); | 46 bool bHex = ((CPDF_String*)pObj)->IsHex(); |
47 if ((len = pFile->AppendString(PDF_EncodeString(str, bHex))) < 0
) { | 47 if ((len = pFile->AppendString(PDF_EncodeString(str, bHex))) < 0
) { |
48 return -1; | 48 return -1; |
49 } | 49 } |
50 offset += len; | 50 offset += len; |
51 break; | 51 break; |
52 } | 52 } |
53 case PDFOBJ_NAME: { | 53 case PDFOBJ_NAME: { |
54 if (pFile->AppendString(FX_BSTRC("/")) < 0) { | 54 if (pFile->AppendString(FX_BSTRC("/")) < 0) { |
55 return -1; | 55 return -1; |
56 } | 56 } |
(...skipping 92 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
149 case PDFOBJ_STREAM: { | 149 case PDFOBJ_STREAM: { |
150 CPDF_Stream* p = (CPDF_Stream*)pObj; | 150 CPDF_Stream* p = (CPDF_Stream*)pObj; |
151 if (PDF_CreatorAppendObject(p->GetDict(), pFile, offset) < 0) { | 151 if (PDF_CreatorAppendObject(p->GetDict(), pFile, offset) < 0) { |
152 return -1; | 152 return -1; |
153 } | 153 } |
154 if (pFile->AppendString(FX_BSTRC("stream\r\n")) < 0) { | 154 if (pFile->AppendString(FX_BSTRC("stream\r\n")) < 0) { |
155 return -1; | 155 return -1; |
156 } | 156 } |
157 offset += 8; | 157 offset += 8; |
158 CPDF_StreamAcc acc; | 158 CPDF_StreamAcc acc; |
159 acc.LoadAllData(p, TRUE); | 159 acc.LoadAllData(p, true); |
160 if (pFile->AppendBlock(acc.GetData(), acc.GetSize()) < 0) { | 160 if (pFile->AppendBlock(acc.GetData(), acc.GetSize()) < 0) { |
161 return -1; | 161 return -1; |
162 } | 162 } |
163 offset += acc.GetSize(); | 163 offset += acc.GetSize(); |
164 if ((len = pFile->AppendString(FX_BSTRC("\r\nendstream"))) < 0)
{ | 164 if ((len = pFile->AppendString(FX_BSTRC("\r\nendstream"))) < 0)
{ |
165 return -1; | 165 return -1; |
166 } | 166 } |
167 offset += len; | 167 offset += len; |
168 break; | 168 break; |
169 } | 169 } |
170 default: | 170 default: |
171 ASSERT(FALSE); | 171 ASSERT(false); |
172 break; | 172 break; |
173 } | 173 } |
174 return 1; | 174 return 1; |
175 } | 175 } |
176 int32_t PDF_CreatorWriteTrailer(CPDF_Document* pDocument, CFX_FileBufferArchive*
pFile, CPDF_Array* pIDArray, FX_BOOL bCompress) | 176 int32_t PDF_CreatorWriteTrailer(CPDF_Document* pDocument, CFX_FileBufferArchive*
pFile, CPDF_Array* pIDArray, bool bCompress) |
177 { | 177 { |
178 FX_FILESIZE offset = 0; | 178 FX_FILESIZE offset = 0; |
179 int32_t len = 0; | 179 int32_t len = 0; |
180 FXSYS_assert(pDocument && pFile); | 180 FXSYS_assert(pDocument && pFile); |
181 CPDF_Parser *pParser = (CPDF_Parser*)pDocument->GetParser(); | 181 CPDF_Parser *pParser = (CPDF_Parser*)pDocument->GetParser(); |
182 if (pParser) { | 182 if (pParser) { |
183 CPDF_Dictionary* p = pParser->GetTrailer(); | 183 CPDF_Dictionary* p = pParser->GetTrailer(); |
184 FX_POSITION pos = p->GetStartPos(); | 184 FX_POSITION pos = p->GetStartPos(); |
185 while (pos) { | 185 while (pos) { |
186 CFX_ByteString key; | 186 CFX_ByteString key; |
(...skipping 91 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
278 } | 278 } |
279 if ((len = pFile->AppendDWord(dwObjNum)) < 0) { | 279 if ((len = pFile->AppendDWord(dwObjNum)) < 0) { |
280 return -1; | 280 return -1; |
281 } | 281 } |
282 if (pFile->AppendString(FX_BSTRC(" 0 R ")) < 0) { | 282 if (pFile->AppendString(FX_BSTRC(" 0 R ")) < 0) { |
283 return -1; | 283 return -1; |
284 } | 284 } |
285 offset += len + 6; | 285 offset += len + 6; |
286 return offset; | 286 return offset; |
287 } | 287 } |
288 FX_BOOL PDF_GenerateFileID(FX_DWORD dwSeed1, FX_DWORD dwSeed2, FX_DWORD* pBuffer
) | 288 bool PDF_GenerateFileID(FX_DWORD dwSeed1, FX_DWORD dwSeed2, FX_DWORD* pBuffer) |
289 { | 289 { |
290 if (!pBuffer) { | 290 if (!pBuffer) { |
291 return FALSE; | 291 return false; |
292 } | 292 } |
293 void* pContext = FX_Random_MT_Start(dwSeed1); | 293 void* pContext = FX_Random_MT_Start(dwSeed1); |
294 int32_t i = 0; | 294 int32_t i = 0; |
295 for (i = 0; i < 2; i++) { | 295 for (i = 0; i < 2; i++) { |
296 *pBuffer++ = FX_Random_MT_Generate(pContext); | 296 *pBuffer++ = FX_Random_MT_Generate(pContext); |
297 } | 297 } |
298 FX_Random_MT_Close(pContext); | 298 FX_Random_MT_Close(pContext); |
299 pContext = FX_Random_MT_Start(dwSeed2); | 299 pContext = FX_Random_MT_Start(dwSeed2); |
300 for (i = 0; i < 2; i++) { | 300 for (i = 0; i < 2; i++) { |
301 *pBuffer++ = FX_Random_MT_Generate(pContext); | 301 *pBuffer++ = FX_Random_MT_Generate(pContext); |
302 } | 302 } |
303 FX_Random_MT_Close(pContext); | 303 FX_Random_MT_Close(pContext); |
304 return TRUE; | 304 return true; |
305 } | 305 } |
306 class CPDF_FlateEncoder | 306 class CPDF_FlateEncoder |
307 { | 307 { |
308 public: | 308 public: |
309 CPDF_FlateEncoder(); | 309 CPDF_FlateEncoder(); |
310 ~CPDF_FlateEncoder(); | 310 ~CPDF_FlateEncoder(); |
311 FX_BOOL» » Initialize(CPDF_Stream* pStream, FX_BOOL bFlateEncode); | 311 bool» » Initialize(CPDF_Stream* pStream, bool bFlateEncode); |
312 FX_BOOL» » Initialize(const uint8_t* pBuffer, FX_DWORD size, FX_BOO
L bFlateEncode, FX_BOOL bXRefStream = FALSE); | 312 bool» » Initialize(const uint8_t* pBuffer, FX_DWORD size, bool b
FlateEncode, bool bXRefStream = false); |
313 void CloneDict(); | 313 void CloneDict(); |
314 uint8_t* m_pData; | 314 uint8_t* m_pData; |
315 FX_DWORD m_dwSize; | 315 FX_DWORD m_dwSize; |
316 CPDF_Dictionary* m_pDict; | 316 CPDF_Dictionary* m_pDict; |
317 FX_BOOL» » » » m_bCloned; | 317 bool» » » » m_bCloned; |
318 FX_BOOL» » » » m_bNewData; | 318 bool» » » » m_bNewData; |
319 CPDF_StreamAcc m_Acc; | 319 CPDF_StreamAcc m_Acc; |
320 }; | 320 }; |
321 CPDF_FlateEncoder::CPDF_FlateEncoder() | 321 CPDF_FlateEncoder::CPDF_FlateEncoder() |
322 { | 322 { |
323 m_pData = NULL; | 323 m_pData = NULL; |
324 m_dwSize = 0; | 324 m_dwSize = 0; |
325 m_pDict = NULL; | 325 m_pDict = NULL; |
326 m_bCloned = FALSE; | 326 m_bCloned = false; |
327 m_bNewData = FALSE; | 327 m_bNewData = false; |
328 } | 328 } |
329 void CPDF_FlateEncoder::CloneDict() | 329 void CPDF_FlateEncoder::CloneDict() |
330 { | 330 { |
331 if (!m_bCloned) { | 331 if (!m_bCloned) { |
332 m_pDict = (CPDF_Dictionary*)m_pDict->Clone(); | 332 m_pDict = (CPDF_Dictionary*)m_pDict->Clone(); |
333 m_bCloned = TRUE; | 333 m_bCloned = true; |
334 } | 334 } |
335 } | 335 } |
336 FX_BOOL CPDF_FlateEncoder::Initialize(CPDF_Stream* pStream, FX_BOOL bFlateEncode
) | 336 bool CPDF_FlateEncoder::Initialize(CPDF_Stream* pStream, bool bFlateEncode) |
337 { | 337 { |
338 m_Acc.LoadAllData(pStream, TRUE); | 338 m_Acc.LoadAllData(pStream, true); |
339 if ((pStream && pStream->GetDict() && pStream->GetDict()->KeyExist("Filter")
) || !bFlateEncode) { | 339 if ((pStream && pStream->GetDict() && pStream->GetDict()->KeyExist("Filter")
) || !bFlateEncode) { |
340 if (pStream->GetDict()->KeyExist("Filter") && !bFlateEncode) { | 340 if (pStream->GetDict()->KeyExist("Filter") && !bFlateEncode) { |
341 CPDF_StreamAcc destAcc; | 341 CPDF_StreamAcc destAcc; |
342 destAcc.LoadAllData(pStream); | 342 destAcc.LoadAllData(pStream); |
343 m_dwSize = destAcc.GetSize(); | 343 m_dwSize = destAcc.GetSize(); |
344 m_pData = (uint8_t*)destAcc.DetachData(); | 344 m_pData = (uint8_t*)destAcc.DetachData(); |
345 m_pDict = (CPDF_Dictionary*)pStream->GetDict()->Clone(); | 345 m_pDict = (CPDF_Dictionary*)pStream->GetDict()->Clone(); |
346 m_pDict->RemoveAt(FX_BSTRC("Filter")); | 346 m_pDict->RemoveAt(FX_BSTRC("Filter")); |
347 m_bNewData = TRUE; | 347 m_bNewData = true; |
348 m_bCloned = TRUE; | 348 m_bCloned = true; |
349 } else { | 349 } else { |
350 m_pData = (uint8_t*)m_Acc.GetData(); | 350 m_pData = (uint8_t*)m_Acc.GetData(); |
351 m_dwSize = m_Acc.GetSize(); | 351 m_dwSize = m_Acc.GetSize(); |
352 m_pDict = pStream->GetDict(); | 352 m_pDict = pStream->GetDict(); |
353 } | 353 } |
354 return TRUE; | 354 return true; |
355 } | 355 } |
356 m_pData = NULL; | 356 m_pData = NULL; |
357 m_dwSize = 0; | 357 m_dwSize = 0; |
358 m_bNewData = TRUE; | 358 m_bNewData = true; |
359 m_bCloned = TRUE; | 359 m_bCloned = true; |
360 ::FlateEncode(m_Acc.GetData(), m_Acc.GetSize(), m_pData, m_dwSize); | 360 ::FlateEncode(m_Acc.GetData(), m_Acc.GetSize(), m_pData, m_dwSize); |
361 m_pDict = (CPDF_Dictionary*)pStream->GetDict()->Clone(); | 361 m_pDict = (CPDF_Dictionary*)pStream->GetDict()->Clone(); |
362 m_pDict->SetAtInteger("Length", m_dwSize); | 362 m_pDict->SetAtInteger("Length", m_dwSize); |
363 m_pDict->SetAtName("Filter", "FlateDecode"); | 363 m_pDict->SetAtName("Filter", "FlateDecode"); |
364 m_pDict->RemoveAt("DecodeParms"); | 364 m_pDict->RemoveAt("DecodeParms"); |
365 return TRUE; | 365 return true; |
366 } | 366 } |
367 FX_BOOL CPDF_FlateEncoder::Initialize(const uint8_t* pBuffer, FX_DWORD size, FX_
BOOL bFlateEncode, FX_BOOL bXRefStream) | 367 bool CPDF_FlateEncoder::Initialize(const uint8_t* pBuffer, FX_DWORD size, bool b
FlateEncode, bool bXRefStream) |
368 { | 368 { |
369 if (!bFlateEncode) { | 369 if (!bFlateEncode) { |
370 m_pData = (uint8_t*)pBuffer; | 370 m_pData = (uint8_t*)pBuffer; |
371 m_dwSize = size; | 371 m_dwSize = size; |
372 return TRUE; | 372 return true; |
373 } | 373 } |
374 m_bNewData = TRUE; | 374 m_bNewData = true; |
375 if (bXRefStream) { | 375 if (bXRefStream) { |
376 ::FlateEncode(pBuffer, size, 12, 1, 8, 7, m_pData, m_dwSize); | 376 ::FlateEncode(pBuffer, size, 12, 1, 8, 7, m_pData, m_dwSize); |
377 } else { | 377 } else { |
378 ::FlateEncode(pBuffer, size, m_pData, m_dwSize); | 378 ::FlateEncode(pBuffer, size, m_pData, m_dwSize); |
379 } | 379 } |
380 return TRUE; | 380 return true; |
381 } | 381 } |
382 CPDF_FlateEncoder::~CPDF_FlateEncoder() | 382 CPDF_FlateEncoder::~CPDF_FlateEncoder() |
383 { | 383 { |
384 if (m_bCloned && m_pDict) { | 384 if (m_bCloned && m_pDict) { |
385 m_pDict->Release(); | 385 m_pDict->Release(); |
386 } | 386 } |
387 if (m_bNewData && m_pData) { | 387 if (m_bNewData && m_pData) { |
388 FX_Free(m_pData); | 388 FX_Free(m_pData); |
389 } | 389 } |
390 } | 390 } |
391 class CPDF_Encryptor | 391 class CPDF_Encryptor |
392 { | 392 { |
393 public: | 393 public: |
394 CPDF_Encryptor(); | 394 CPDF_Encryptor(); |
395 ~CPDF_Encryptor(); | 395 ~CPDF_Encryptor(); |
396 FX_BOOL» » Initialize(CPDF_CryptoHandler* pHandler, int objnum, uin
t8_t* src_data, FX_DWORD src_size); | 396 bool» » Initialize(CPDF_CryptoHandler* pHandler, int objnum, uin
t8_t* src_data, FX_DWORD src_size); |
397 uint8_t* m_pData; | 397 uint8_t* m_pData; |
398 FX_DWORD m_dwSize; | 398 FX_DWORD m_dwSize; |
399 FX_BOOL» » » » m_bNewBuf; | 399 bool» » » » m_bNewBuf; |
400 }; | 400 }; |
401 CPDF_Encryptor::CPDF_Encryptor() | 401 CPDF_Encryptor::CPDF_Encryptor() |
402 { | 402 { |
403 m_pData = NULL; | 403 m_pData = NULL; |
404 m_dwSize = 0; | 404 m_dwSize = 0; |
405 m_bNewBuf = FALSE; | 405 m_bNewBuf = false; |
406 } | 406 } |
407 FX_BOOL CPDF_Encryptor::Initialize(CPDF_CryptoHandler* pHandler, int objnum, uin
t8_t* src_data, FX_DWORD src_size) | 407 bool CPDF_Encryptor::Initialize(CPDF_CryptoHandler* pHandler, int objnum, uint8_
t* src_data, FX_DWORD src_size) |
408 { | 408 { |
409 if (src_size == 0) { | 409 if (src_size == 0) { |
410 return TRUE; | 410 return true; |
411 } | 411 } |
412 if (pHandler == NULL) { | 412 if (pHandler == NULL) { |
413 m_pData = (uint8_t*)src_data; | 413 m_pData = (uint8_t*)src_data; |
414 m_dwSize = src_size; | 414 m_dwSize = src_size; |
415 m_bNewBuf = FALSE; | 415 m_bNewBuf = false; |
416 return TRUE; | 416 return true; |
417 } | 417 } |
418 m_dwSize = pHandler->EncryptGetSize(objnum, 0, src_data, src_size); | 418 m_dwSize = pHandler->EncryptGetSize(objnum, 0, src_data, src_size); |
419 m_pData = FX_Alloc(uint8_t, m_dwSize); | 419 m_pData = FX_Alloc(uint8_t, m_dwSize); |
420 pHandler->EncryptContent(objnum, 0, src_data, src_size, m_pData, m_dwSize); | 420 pHandler->EncryptContent(objnum, 0, src_data, src_size, m_pData, m_dwSize); |
421 m_bNewBuf = TRUE; | 421 m_bNewBuf = true; |
422 return TRUE; | 422 return true; |
423 } | 423 } |
424 CPDF_Encryptor::~CPDF_Encryptor() | 424 CPDF_Encryptor::~CPDF_Encryptor() |
425 { | 425 { |
426 if (m_bNewBuf) { | 426 if (m_bNewBuf) { |
427 FX_Free(m_pData); | 427 FX_Free(m_pData); |
428 } | 428 } |
429 } | 429 } |
430 CPDF_ObjectStream::CPDF_ObjectStream() | 430 CPDF_ObjectStream::CPDF_ObjectStream() |
431 : m_dwObjNum(0) | 431 : m_dwObjNum(0) |
432 , m_index(0) | 432 , m_index(0) |
433 { | 433 { |
434 } | 434 } |
435 FX_BOOL CPDF_ObjectStream::Start() | 435 bool CPDF_ObjectStream::Start() |
436 { | 436 { |
437 m_ObjNumArray.RemoveAll(); | 437 m_ObjNumArray.RemoveAll(); |
438 m_OffsetArray.RemoveAll(); | 438 m_OffsetArray.RemoveAll(); |
439 m_Buffer.Clear(); | 439 m_Buffer.Clear(); |
440 m_dwObjNum = 0; | 440 m_dwObjNum = 0; |
441 m_index = 0; | 441 m_index = 0; |
442 return TRUE; | 442 return true; |
443 } | 443 } |
444 int32_t CPDF_ObjectStream::CompressIndirectObject(FX_DWORD dwObjNum, const CPDF_
Object *pObj) | 444 int32_t CPDF_ObjectStream::CompressIndirectObject(FX_DWORD dwObjNum, const CPDF_
Object *pObj) |
445 { | 445 { |
446 m_ObjNumArray.Add(dwObjNum); | 446 m_ObjNumArray.Add(dwObjNum); |
447 m_OffsetArray.Add(m_Buffer.GetLength()); | 447 m_OffsetArray.Add(m_Buffer.GetLength()); |
448 m_Buffer << pObj; | 448 m_Buffer << pObj; |
449 return 1; | 449 return 1; |
450 } | 450 } |
451 int32_t CPDF_ObjectStream::CompressIndirectObject(FX_DWORD dwObjNum, const uint8
_t* pBuffer, FX_DWORD dwSize) | 451 int32_t CPDF_ObjectStream::CompressIndirectObject(FX_DWORD dwObjNum, const uint8
_t* pBuffer, FX_DWORD dwSize) |
452 { | 452 { |
(...skipping 87 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
540 } | 540 } |
541 offset += len; | 541 offset += len; |
542 return ObjOffset; | 542 return ObjOffset; |
543 } | 543 } |
544 CPDF_XRefStream::CPDF_XRefStream() | 544 CPDF_XRefStream::CPDF_XRefStream() |
545 : m_PrevOffset(0) | 545 : m_PrevOffset(0) |
546 , m_dwTempObjNum(0) | 546 , m_dwTempObjNum(0) |
547 , m_iSeg(0) | 547 , m_iSeg(0) |
548 { | 548 { |
549 } | 549 } |
550 FX_BOOL CPDF_XRefStream::Start() | 550 bool CPDF_XRefStream::Start() |
551 { | 551 { |
552 m_IndexArray.RemoveAll(); | 552 m_IndexArray.RemoveAll(); |
553 m_Buffer.Clear(); | 553 m_Buffer.Clear(); |
554 m_iSeg = 0; | 554 m_iSeg = 0; |
555 return TRUE; | 555 return true; |
556 } | 556 } |
557 int32_t CPDF_XRefStream::CompressIndirectObject(FX_DWORD dwObjNum, const CPDF_Ob
ject *pObj, CPDF_Creator *pCreator) | 557 int32_t CPDF_XRefStream::CompressIndirectObject(FX_DWORD dwObjNum, const CPDF_Ob
ject *pObj, CPDF_Creator *pCreator) |
558 { | 558 { |
559 if (!pCreator) { | 559 if (!pCreator) { |
560 return 0; | 560 return 0; |
561 } | 561 } |
562 m_ObjStream.CompressIndirectObject(dwObjNum, pObj); | 562 m_ObjStream.CompressIndirectObject(dwObjNum, pObj); |
563 if (m_ObjStream.m_ObjNumArray.GetSize() < pCreator->m_ObjectStreamSize && | 563 if (m_ObjStream.m_ObjNumArray.GetSize() < pCreator->m_ObjectStreamSize && |
564 m_ObjStream.m_Buffer.GetLength() < PDF_OBJECTSTREAM_MAXLENGTH) { | 564 m_ObjStream.m_Buffer.GetLength() < PDF_OBJECTSTREAM_MAXLENGTH) { |
565 return 1; | 565 return 1; |
566 } | 566 } |
567 return EndObjectStream(pCreator); | 567 return EndObjectStream(pCreator); |
568 } | 568 } |
569 int32_t CPDF_XRefStream::CompressIndirectObject(FX_DWORD dwObjNum, const uint8_t
* pBuffer, FX_DWORD dwSize, CPDF_Creator *pCreator) | 569 int32_t CPDF_XRefStream::CompressIndirectObject(FX_DWORD dwObjNum, const uint8_t
* pBuffer, FX_DWORD dwSize, CPDF_Creator *pCreator) |
570 { | 570 { |
571 if (!pCreator) { | 571 if (!pCreator) { |
572 return 0; | 572 return 0; |
573 } | 573 } |
574 m_ObjStream.CompressIndirectObject(dwObjNum, pBuffer, dwSize); | 574 m_ObjStream.CompressIndirectObject(dwObjNum, pBuffer, dwSize); |
575 if (m_ObjStream.m_ObjNumArray.GetSize() < pCreator->m_ObjectStreamSize && | 575 if (m_ObjStream.m_ObjNumArray.GetSize() < pCreator->m_ObjectStreamSize && |
576 m_ObjStream.m_Buffer.GetLength() < PDF_OBJECTSTREAM_MAXLENGTH) { | 576 m_ObjStream.m_Buffer.GetLength() < PDF_OBJECTSTREAM_MAXLENGTH) { |
577 return 1; | 577 return 1; |
578 } | 578 } |
579 return EndObjectStream(pCreator); | 579 return EndObjectStream(pCreator); |
580 } | 580 } |
581 static void _AppendIndex0(CFX_ByteTextBuf& buffer, FX_BOOL bFirstObject = TRUE) | 581 static void _AppendIndex0(CFX_ByteTextBuf& buffer, bool bFirstObject = true) |
582 { | 582 { |
583 buffer.AppendByte(0); | 583 buffer.AppendByte(0); |
584 buffer.AppendByte(0); | 584 buffer.AppendByte(0); |
585 buffer.AppendByte(0); | 585 buffer.AppendByte(0); |
586 buffer.AppendByte(0); | 586 buffer.AppendByte(0); |
587 buffer.AppendByte(0); | 587 buffer.AppendByte(0); |
588 if (bFirstObject) { | 588 if (bFirstObject) { |
589 buffer.AppendByte(0xFF); | 589 buffer.AppendByte(0xFF); |
590 buffer.AppendByte(0xFF); | 590 buffer.AppendByte(0xFF); |
591 } else { | 591 } else { |
(...skipping 14 matching lines...) Expand all Loading... |
606 static void _AppendIndex2(CFX_ByteTextBuf& buffer, FX_DWORD objnum, int32_t inde
x) | 606 static void _AppendIndex2(CFX_ByteTextBuf& buffer, FX_DWORD objnum, int32_t inde
x) |
607 { | 607 { |
608 buffer.AppendByte(2); | 608 buffer.AppendByte(2); |
609 buffer.AppendByte(FX_GETBYTEOFFSET24(objnum)); | 609 buffer.AppendByte(FX_GETBYTEOFFSET24(objnum)); |
610 buffer.AppendByte(FX_GETBYTEOFFSET16(objnum)); | 610 buffer.AppendByte(FX_GETBYTEOFFSET16(objnum)); |
611 buffer.AppendByte(FX_GETBYTEOFFSET8(objnum)); | 611 buffer.AppendByte(FX_GETBYTEOFFSET8(objnum)); |
612 buffer.AppendByte(FX_GETBYTEOFFSET0(objnum)); | 612 buffer.AppendByte(FX_GETBYTEOFFSET0(objnum)); |
613 buffer.AppendByte(FX_GETBYTEOFFSET8(index)); | 613 buffer.AppendByte(FX_GETBYTEOFFSET8(index)); |
614 buffer.AppendByte(FX_GETBYTEOFFSET0(index)); | 614 buffer.AppendByte(FX_GETBYTEOFFSET0(index)); |
615 } | 615 } |
616 int32_t CPDF_XRefStream::EndObjectStream(CPDF_Creator *pCreator, FX_BOOL bEOF) | 616 int32_t CPDF_XRefStream::EndObjectStream(CPDF_Creator *pCreator, bool bEOF) |
617 { | 617 { |
618 FX_FILESIZE objOffset = 0; | 618 FX_FILESIZE objOffset = 0; |
619 if (bEOF) { | 619 if (bEOF) { |
620 objOffset = m_ObjStream.End(pCreator); | 620 objOffset = m_ObjStream.End(pCreator); |
621 if (objOffset < 0) { | 621 if (objOffset < 0) { |
622 return -1; | 622 return -1; |
623 } | 623 } |
624 } | 624 } |
625 FX_DWORD &dwObjStmNum = m_ObjStream.m_dwObjNum; | 625 FX_DWORD &dwObjStmNum = m_ObjStream.m_dwObjNum; |
626 if (!dwObjStmNum) { | 626 if (!dwObjStmNum) { |
(...skipping 10 matching lines...) Expand all Loading... |
637 int index = 0; | 637 int index = 0; |
638 for (; m_dwTempObjNum < end_num; m_dwTempObjNum++) { | 638 for (; m_dwTempObjNum < end_num; m_dwTempObjNum++) { |
639 FX_FILESIZE* offset = pCreator->m_ObjectOffset.GetPtrAt(m_dwTempObjN
um); | 639 FX_FILESIZE* offset = pCreator->m_ObjectOffset.GetPtrAt(m_dwTempObjN
um); |
640 if (offset) { | 640 if (offset) { |
641 if (index >= iSize || m_dwTempObjNum != m_ObjStream.m_ObjNumArra
y[index]) { | 641 if (index >= iSize || m_dwTempObjNum != m_ObjStream.m_ObjNumArra
y[index]) { |
642 _AppendIndex1(m_Buffer, *offset); | 642 _AppendIndex1(m_Buffer, *offset); |
643 } else { | 643 } else { |
644 _AppendIndex2(m_Buffer, dwObjStmNum, index++); | 644 _AppendIndex2(m_Buffer, dwObjStmNum, index++); |
645 } | 645 } |
646 } else { | 646 } else { |
647 _AppendIndex0(m_Buffer, FALSE); | 647 _AppendIndex0(m_Buffer, false); |
648 } | 648 } |
649 } | 649 } |
650 if (iSize > 0 && bEOF) { | 650 if (iSize > 0 && bEOF) { |
651 pCreator->m_ObjectOffset.Add(dwObjStmNum, 1); | 651 pCreator->m_ObjectOffset.Add(dwObjStmNum, 1); |
652 pCreator->m_ObjectSize.Add(dwObjStmNum, 1); | 652 pCreator->m_ObjectSize.Add(dwObjStmNum, 1); |
653 pCreator->m_ObjectOffset[dwObjStmNum] = objOffset; | 653 pCreator->m_ObjectOffset[dwObjStmNum] = objOffset; |
654 } | 654 } |
655 m_iSeg = iSeg; | 655 m_iSeg = iSeg; |
656 if (bEOF) { | 656 if (bEOF) { |
657 m_ObjStream.Start(); | 657 m_ObjStream.Start(); |
(...skipping 17 matching lines...) Expand all Loading... |
675 m_IndexArray.Add(dwObjStmNum); | 675 m_IndexArray.Add(dwObjStmNum); |
676 m_IndexArray.Add(1); | 676 m_IndexArray.Add(1); |
677 iSeg += 1; | 677 iSeg += 1; |
678 } | 678 } |
679 m_iSeg = iSeg; | 679 m_iSeg = iSeg; |
680 if (bEOF) { | 680 if (bEOF) { |
681 m_ObjStream.Start(); | 681 m_ObjStream.Start(); |
682 } | 682 } |
683 return 1; | 683 return 1; |
684 } | 684 } |
685 FX_BOOL CPDF_XRefStream::GenerateXRefStream(CPDF_Creator* pCreator, FX_BOOL bEOF
) | 685 bool CPDF_XRefStream::GenerateXRefStream(CPDF_Creator* pCreator, bool bEOF) |
686 { | 686 { |
687 FX_FILESIZE offset_tmp = pCreator->m_Offset; | 687 FX_FILESIZE offset_tmp = pCreator->m_Offset; |
688 FX_DWORD objnum = ++pCreator->m_dwLastObjNum; | 688 FX_DWORD objnum = ++pCreator->m_dwLastObjNum; |
689 CFX_FileBufferArchive *pFile = &pCreator->m_File; | 689 CFX_FileBufferArchive *pFile = &pCreator->m_File; |
690 FX_BOOL bIncremental = (pCreator->m_dwFlags & FPDFCREATE_INCREMENTAL) != 0; | 690 bool bIncremental = (pCreator->m_dwFlags & FPDFCREATE_INCREMENTAL) != 0; |
691 if (bIncremental) { | 691 if (bIncremental) { |
692 AddObjectNumberToIndexArray(objnum); | 692 AddObjectNumberToIndexArray(objnum); |
693 } else { | 693 } else { |
694 for (; m_dwTempObjNum < pCreator->m_dwLastObjNum; m_dwTempObjNum++) { | 694 for (; m_dwTempObjNum < pCreator->m_dwLastObjNum; m_dwTempObjNum++) { |
695 FX_FILESIZE* offset = pCreator->m_ObjectOffset.GetPtrAt(m_dwTempObjN
um); | 695 FX_FILESIZE* offset = pCreator->m_ObjectOffset.GetPtrAt(m_dwTempObjN
um); |
696 if (offset) { | 696 if (offset) { |
697 _AppendIndex1(m_Buffer, *offset); | 697 _AppendIndex1(m_Buffer, *offset); |
698 } else { | 698 } else { |
699 _AppendIndex0(m_Buffer, FALSE); | 699 _AppendIndex0(m_Buffer, false); |
700 } | 700 } |
701 } | 701 } |
702 } | 702 } |
703 _AppendIndex1(m_Buffer, offset_tmp); | 703 _AppendIndex1(m_Buffer, offset_tmp); |
704 FX_FILESIZE &offset = pCreator->m_Offset; | 704 FX_FILESIZE &offset = pCreator->m_Offset; |
705 int32_t len = pFile->AppendDWord(objnum); | 705 int32_t len = pFile->AppendDWord(objnum); |
706 if (len < 0) { | 706 if (len < 0) { |
707 return FALSE; | 707 return false; |
708 } | 708 } |
709 offset += len; | 709 offset += len; |
710 if ((len = pFile->AppendString(FX_BSTRC(" 0 obj\r\n<</Type /XRef/W[1 4 2]/In
dex["))) < 0) { | 710 if ((len = pFile->AppendString(FX_BSTRC(" 0 obj\r\n<</Type /XRef/W[1 4 2]/In
dex["))) < 0) { |
711 return FALSE; | 711 return false; |
712 } | 712 } |
713 offset += len; | 713 offset += len; |
714 if (!bIncremental) { | 714 if (!bIncremental) { |
715 if ((len = pFile->AppendDWord(0)) < 0) { | 715 if ((len = pFile->AppendDWord(0)) < 0) { |
716 return FALSE; | 716 return false; |
717 } | 717 } |
718 if ((len = pFile->AppendString(FX_BSTRC(" "))) < 0) { | 718 if ((len = pFile->AppendString(FX_BSTRC(" "))) < 0) { |
719 return FALSE; | 719 return false; |
720 } | 720 } |
721 offset += len + 1; | 721 offset += len + 1; |
722 if ((len = pFile->AppendDWord(objnum + 1)) < 0) { | 722 if ((len = pFile->AppendDWord(objnum + 1)) < 0) { |
723 return FALSE; | 723 return false; |
724 } | 724 } |
725 offset += len; | 725 offset += len; |
726 } else { | 726 } else { |
727 int32_t iSeg = m_IndexArray.GetSize() / 2; | 727 int32_t iSeg = m_IndexArray.GetSize() / 2; |
728 for (int32_t i = 0; i < iSeg; i++) { | 728 for (int32_t i = 0; i < iSeg; i++) { |
729 if ((len = pFile->AppendDWord(m_IndexArray.ElementAt(i * 2))) < 0) { | 729 if ((len = pFile->AppendDWord(m_IndexArray.ElementAt(i * 2))) < 0) { |
730 return FALSE; | 730 return false; |
731 } | 731 } |
732 if (pFile->AppendString(FX_BSTRC(" ")) < 0) { | 732 if (pFile->AppendString(FX_BSTRC(" ")) < 0) { |
733 return FALSE; | 733 return false; |
734 } | 734 } |
735 offset += len + 1; | 735 offset += len + 1; |
736 if ((len = pFile->AppendDWord(m_IndexArray.ElementAt(i * 2 + 1))) <
0) { | 736 if ((len = pFile->AppendDWord(m_IndexArray.ElementAt(i * 2 + 1))) <
0) { |
737 return FALSE; | 737 return false; |
738 } | 738 } |
739 if (pFile->AppendString(FX_BSTRC(" ")) < 0) { | 739 if (pFile->AppendString(FX_BSTRC(" ")) < 0) { |
740 return FALSE; | 740 return false; |
741 } | 741 } |
742 offset += len + 1; | 742 offset += len + 1; |
743 } | 743 } |
744 } | 744 } |
745 if (pFile->AppendString(FX_BSTRC("]/Size ")) < 0) { | 745 if (pFile->AppendString(FX_BSTRC("]/Size ")) < 0) { |
746 return FALSE; | 746 return false; |
747 } | 747 } |
748 if ((len = pFile->AppendDWord(objnum + 1)) < 0) { | 748 if ((len = pFile->AppendDWord(objnum + 1)) < 0) { |
749 return FALSE; | 749 return false; |
750 } | 750 } |
751 offset += len + 7; | 751 offset += len + 7; |
752 if (m_PrevOffset > 0) { | 752 if (m_PrevOffset > 0) { |
753 if (pFile->AppendString(FX_BSTRC("/Prev ")) < 0) { | 753 if (pFile->AppendString(FX_BSTRC("/Prev ")) < 0) { |
754 return -1; | 754 return -1; |
755 } | 755 } |
756 FX_CHAR offset_buf[20]; | 756 FX_CHAR offset_buf[20]; |
757 FXSYS_memset(offset_buf, 0, sizeof(offset_buf)); | 757 FXSYS_memset(offset_buf, 0, sizeof(offset_buf)); |
758 FXSYS_i64toa(m_PrevOffset, offset_buf, 10); | 758 FXSYS_i64toa(m_PrevOffset, offset_buf, 10); |
759 int32_t len = (int32_t)FXSYS_strlen(offset_buf); | 759 int32_t len = (int32_t)FXSYS_strlen(offset_buf); |
760 if (pFile->AppendBlock(offset_buf, len) < 0) { | 760 if (pFile->AppendBlock(offset_buf, len) < 0) { |
761 return -1; | 761 return -1; |
762 } | 762 } |
763 offset += len + 6; | 763 offset += len + 6; |
764 } | 764 } |
765 FX_BOOL bPredictor = TRUE; | 765 bool bPredictor = true; |
766 CPDF_FlateEncoder encoder; | 766 CPDF_FlateEncoder encoder; |
767 encoder.Initialize(m_Buffer.GetBuffer(), m_Buffer.GetLength(), pCreator->m_b
Compress, bPredictor); | 767 encoder.Initialize(m_Buffer.GetBuffer(), m_Buffer.GetLength(), pCreator->m_b
Compress, bPredictor); |
768 if (pCreator->m_bCompress) { | 768 if (pCreator->m_bCompress) { |
769 if (pFile->AppendString(FX_BSTRC("/Filter /FlateDecode")) < 0) { | 769 if (pFile->AppendString(FX_BSTRC("/Filter /FlateDecode")) < 0) { |
770 return FALSE; | 770 return false; |
771 } | 771 } |
772 offset += 20; | 772 offset += 20; |
773 if (bPredictor) { | 773 if (bPredictor) { |
774 if ((len = pFile->AppendString(FX_BSTRC("/DecodeParms<</Columns 7/Pr
edictor 12>>"))) < 0) { | 774 if ((len = pFile->AppendString(FX_BSTRC("/DecodeParms<</Columns 7/Pr
edictor 12>>"))) < 0) { |
775 return FALSE; | 775 return false; |
776 } | 776 } |
777 offset += len; | 777 offset += len; |
778 } | 778 } |
779 } | 779 } |
780 if (pFile->AppendString(FX_BSTRC("/Length ")) < 0) { | 780 if (pFile->AppendString(FX_BSTRC("/Length ")) < 0) { |
781 return FALSE; | 781 return false; |
782 } | 782 } |
783 if ((len = pFile->AppendDWord(encoder.m_dwSize)) < 0) { | 783 if ((len = pFile->AppendDWord(encoder.m_dwSize)) < 0) { |
784 return FALSE; | 784 return false; |
785 } | 785 } |
786 offset += len + 8; | 786 offset += len + 8; |
787 if (bEOF) { | 787 if (bEOF) { |
788 if ((len = PDF_CreatorWriteTrailer(pCreator->m_pDocument, pFile, pCreato
r->m_pIDArray, pCreator->m_bCompress)) < 0) { | 788 if ((len = PDF_CreatorWriteTrailer(pCreator->m_pDocument, pFile, pCreato
r->m_pIDArray, pCreator->m_bCompress)) < 0) { |
789 return -1; | 789 return -1; |
790 } | 790 } |
791 offset += len; | 791 offset += len; |
792 if (pCreator->m_pEncryptDict) { | 792 if (pCreator->m_pEncryptDict) { |
793 FX_DWORD dwEncryptObjNum = pCreator->m_pEncryptDict->GetObjNum(); | 793 FX_DWORD dwEncryptObjNum = pCreator->m_pEncryptDict->GetObjNum(); |
794 if (dwEncryptObjNum == 0) { | 794 if (dwEncryptObjNum == 0) { |
795 dwEncryptObjNum = pCreator->m_dwEnryptObjNum; | 795 dwEncryptObjNum = pCreator->m_dwEnryptObjNum; |
796 } | 796 } |
797 if ((len = PDF_CreatorWriteEncrypt(pCreator->m_pEncryptDict, dwEncry
ptObjNum, pFile)) < 0) { | 797 if ((len = PDF_CreatorWriteEncrypt(pCreator->m_pEncryptDict, dwEncry
ptObjNum, pFile)) < 0) { |
798 return -1; | 798 return -1; |
799 } | 799 } |
800 offset += len; | 800 offset += len; |
801 } | 801 } |
802 } | 802 } |
803 if ((len = pFile->AppendString(FX_BSTRC(">>stream\r\n"))) < 0) { | 803 if ((len = pFile->AppendString(FX_BSTRC(">>stream\r\n"))) < 0) { |
804 return FALSE; | 804 return false; |
805 } | 805 } |
806 offset += len; | 806 offset += len; |
807 if (pFile->AppendBlock(encoder.m_pData, encoder.m_dwSize) < 0) { | 807 if (pFile->AppendBlock(encoder.m_pData, encoder.m_dwSize) < 0) { |
808 return FALSE; | 808 return false; |
809 } | 809 } |
810 if ((len = pFile->AppendString(FX_BSTRC("\r\nendstream\r\nendobj\r\n"))) < 0
) { | 810 if ((len = pFile->AppendString(FX_BSTRC("\r\nendstream\r\nendobj\r\n"))) < 0
) { |
811 return FALSE; | 811 return false; |
812 } | 812 } |
813 offset += encoder.m_dwSize + len; | 813 offset += encoder.m_dwSize + len; |
814 m_PrevOffset = offset_tmp; | 814 m_PrevOffset = offset_tmp; |
815 return TRUE; | 815 return true; |
816 } | 816 } |
817 FX_BOOL CPDF_XRefStream::End(CPDF_Creator *pCreator, FX_BOOL bEOF ) | 817 bool CPDF_XRefStream::End(CPDF_Creator *pCreator, bool bEOF ) |
818 { | 818 { |
819 if (EndObjectStream(pCreator, bEOF) < 0) { | 819 if (EndObjectStream(pCreator, bEOF) < 0) { |
820 return FALSE; | 820 return false; |
821 } | 821 } |
822 return GenerateXRefStream(pCreator, bEOF); | 822 return GenerateXRefStream(pCreator, bEOF); |
823 } | 823 } |
824 FX_BOOL CPDF_XRefStream::EndXRefStream(CPDF_Creator* pCreator) | 824 bool CPDF_XRefStream::EndXRefStream(CPDF_Creator* pCreator) |
825 { | 825 { |
826 if (!(pCreator->m_dwFlags & FPDFCREATE_INCREMENTAL)) { | 826 if (!(pCreator->m_dwFlags & FPDFCREATE_INCREMENTAL)) { |
827 _AppendIndex0(m_Buffer); | 827 _AppendIndex0(m_Buffer); |
828 for (FX_DWORD i = 1; i < pCreator->m_dwLastObjNum + 1; i++) { | 828 for (FX_DWORD i = 1; i < pCreator->m_dwLastObjNum + 1; i++) { |
829 FX_FILESIZE* offset = pCreator->m_ObjectOffset.GetPtrAt(i); | 829 FX_FILESIZE* offset = pCreator->m_ObjectOffset.GetPtrAt(i); |
830 if (offset) { | 830 if (offset) { |
831 _AppendIndex1(m_Buffer, *offset); | 831 _AppendIndex1(m_Buffer, *offset); |
832 } else { | 832 } else { |
833 _AppendIndex0(m_Buffer, FALSE); | 833 _AppendIndex0(m_Buffer, false); |
834 } | 834 } |
835 } | 835 } |
836 } else { | 836 } else { |
837 int32_t iSeg = m_IndexArray.GetSize() / 2; | 837 int32_t iSeg = m_IndexArray.GetSize() / 2; |
838 for (int i = 0; i < iSeg; i++) { | 838 for (int i = 0; i < iSeg; i++) { |
839 FX_DWORD start = m_IndexArray.ElementAt(i * 2); | 839 FX_DWORD start = m_IndexArray.ElementAt(i * 2); |
840 FX_DWORD end = m_IndexArray.ElementAt(i * 2 + 1) + start; | 840 FX_DWORD end = m_IndexArray.ElementAt(i * 2 + 1) + start; |
841 for (FX_DWORD j = start; j < end; j++) { | 841 for (FX_DWORD j = start; j < end; j++) { |
842 _AppendIndex1(m_Buffer, pCreator->m_ObjectOffset[j]); | 842 _AppendIndex1(m_Buffer, pCreator->m_ObjectOffset[j]); |
843 } | 843 } |
844 } | 844 } |
845 } | 845 } |
846 return GenerateXRefStream(pCreator, FALSE); | 846 return GenerateXRefStream(pCreator, false); |
847 } | 847 } |
848 FX_BOOL CPDF_XRefStream::AddObjectNumberToIndexArray(FX_DWORD objnum) | 848 bool CPDF_XRefStream::AddObjectNumberToIndexArray(FX_DWORD objnum) |
849 { | 849 { |
850 int32_t iSize = m_IndexArray.GetSize(); | 850 int32_t iSize = m_IndexArray.GetSize(); |
851 if (iSize == 0) { | 851 if (iSize == 0) { |
852 m_IndexArray.Add(objnum); | 852 m_IndexArray.Add(objnum); |
853 m_IndexArray.Add(1); | 853 m_IndexArray.Add(1); |
854 } else { | 854 } else { |
855 FXSYS_assert(iSize > 1); | 855 FXSYS_assert(iSize > 1); |
856 FX_DWORD startobjnum = m_IndexArray.ElementAt(iSize - 2); | 856 FX_DWORD startobjnum = m_IndexArray.ElementAt(iSize - 2); |
857 int32_t iCount = m_IndexArray.ElementAt(iSize - 1); | 857 int32_t iCount = m_IndexArray.ElementAt(iSize - 1); |
858 if (objnum == startobjnum + iCount) { | 858 if (objnum == startobjnum + iCount) { |
859 m_IndexArray[iSize - 1] = iCount + 1; | 859 m_IndexArray[iSize - 1] = iCount + 1; |
860 } else { | 860 } else { |
861 m_IndexArray.Add(objnum); | 861 m_IndexArray.Add(objnum); |
862 m_IndexArray.Add(1); | 862 m_IndexArray.Add(1); |
863 } | 863 } |
864 } | 864 } |
865 return TRUE; | 865 return true; |
866 } | 866 } |
867 CPDF_Creator::CPDF_Creator(CPDF_Document* pDoc) | 867 CPDF_Creator::CPDF_Creator(CPDF_Document* pDoc) |
868 { | 868 { |
869 m_pDocument = pDoc; | 869 m_pDocument = pDoc; |
870 m_pParser = (CPDF_Parser*)pDoc->m_pParser; | 870 m_pParser = (CPDF_Parser*)pDoc->m_pParser; |
871 m_bCompress = TRUE; | 871 m_bCompress = true; |
872 if (m_pParser) { | 872 if (m_pParser) { |
873 m_pEncryptDict = m_pParser->GetEncryptDict(); | 873 m_pEncryptDict = m_pParser->GetEncryptDict(); |
874 m_pCryptoHandler = m_pParser->GetCryptoHandler(); | 874 m_pCryptoHandler = m_pParser->GetCryptoHandler(); |
875 } else { | 875 } else { |
876 m_pEncryptDict = NULL; | 876 m_pEncryptDict = NULL; |
877 m_pCryptoHandler = NULL; | 877 m_pCryptoHandler = NULL; |
878 } | 878 } |
879 m_bSecurityChanged = FALSE; | 879 m_bSecurityChanged = false; |
880 m_bStandardSecurity = FALSE; | 880 m_bStandardSecurity = false; |
881 m_pMetadata = NULL; | 881 m_pMetadata = NULL; |
882 m_bEncryptCloned = FALSE; | 882 m_bEncryptCloned = false; |
883 m_bEncryptMetadata = FALSE; | 883 m_bEncryptMetadata = false; |
884 m_Offset = 0; | 884 m_Offset = 0; |
885 m_iStage = -1; | 885 m_iStage = -1; |
886 m_dwFlags = 0; | 886 m_dwFlags = 0; |
887 m_Pos = NULL; | 887 m_Pos = NULL; |
888 m_XrefStart = 0; | 888 m_XrefStart = 0; |
889 m_pXRefStream = NULL; | 889 m_pXRefStream = NULL; |
890 m_ObjectStreamSize = 200; | 890 m_ObjectStreamSize = 200; |
891 m_dwLastObjNum = m_pDocument->GetLastObjNum(); | 891 m_dwLastObjNum = m_pDocument->GetLastObjNum(); |
892 m_pIDArray = NULL; | 892 m_pIDArray = NULL; |
893 m_FileVersion = 0; | 893 m_FileVersion = 0; |
894 m_dwEnryptObjNum = 0; | 894 m_dwEnryptObjNum = 0; |
895 m_bNewCrypto = FALSE; | 895 m_bNewCrypto = false; |
896 } | 896 } |
897 CPDF_Creator::~CPDF_Creator() | 897 CPDF_Creator::~CPDF_Creator() |
898 { | 898 { |
899 ResetStandardSecurity(); | 899 ResetStandardSecurity(); |
900 if (m_bEncryptCloned && m_pEncryptDict) { | 900 if (m_bEncryptCloned && m_pEncryptDict) { |
901 m_pEncryptDict->Release(); | 901 m_pEncryptDict->Release(); |
902 m_pEncryptDict = NULL; | 902 m_pEncryptDict = NULL; |
903 } | 903 } |
904 Clear(); | 904 Clear(); |
905 } | 905 } |
906 static FX_BOOL _IsXRefNeedEnd(CPDF_XRefStream* pXRef, FX_DWORD flag) | 906 static bool _IsXRefNeedEnd(CPDF_XRefStream* pXRef, FX_DWORD flag) |
907 { | 907 { |
908 if (!(flag & FPDFCREATE_INCREMENTAL)) { | 908 if (!(flag & FPDFCREATE_INCREMENTAL)) { |
909 return FALSE; | 909 return false; |
910 } | 910 } |
911 int32_t iSize = pXRef->m_IndexArray.GetSize() / 2; | 911 int32_t iSize = pXRef->m_IndexArray.GetSize() / 2; |
912 int32_t iCount = 0; | 912 int32_t iCount = 0; |
913 for (int32_t i = 0; i < iSize; i++) { | 913 for (int32_t i = 0; i < iSize; i++) { |
914 iCount += pXRef->m_IndexArray.ElementAt(i * 2 + 1); | 914 iCount += pXRef->m_IndexArray.ElementAt(i * 2 + 1); |
915 } | 915 } |
916 return (iCount >= PDF_XREFSTREAM_MAXSIZE); | 916 return (iCount >= PDF_XREFSTREAM_MAXSIZE); |
917 } | 917 } |
918 int32_t CPDF_Creator::WriteIndirectObjectToStream(const CPDF_Object* pObj) | 918 int32_t CPDF_Creator::WriteIndirectObjectToStream(const CPDF_Object* pObj) |
919 { | 919 { |
(...skipping 74 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
994 return -1; | 994 return -1; |
995 } | 995 } |
996 if (!m_pXRefStream->Start()) { | 996 if (!m_pXRefStream->Start()) { |
997 return -1; | 997 return -1; |
998 } | 998 } |
999 return 0; | 999 return 0; |
1000 } | 1000 } |
1001 int32_t CPDF_Creator::WriteStream(const CPDF_Object* pStream, FX_DWORD objnum, C
PDF_CryptoHandler* pCrypto) | 1001 int32_t CPDF_Creator::WriteStream(const CPDF_Object* pStream, FX_DWORD objnum, C
PDF_CryptoHandler* pCrypto) |
1002 { | 1002 { |
1003 CPDF_FlateEncoder encoder; | 1003 CPDF_FlateEncoder encoder; |
1004 encoder.Initialize((CPDF_Stream*)pStream, pStream == m_pMetadata ? FALSE : m
_bCompress); | 1004 encoder.Initialize((CPDF_Stream*)pStream, pStream == m_pMetadata ? false : m
_bCompress); |
1005 CPDF_Encryptor encryptor; | 1005 CPDF_Encryptor encryptor; |
1006 if(!encryptor.Initialize(pCrypto, objnum, encoder.m_pData, encoder.m_dwSize)
) { | 1006 if(!encryptor.Initialize(pCrypto, objnum, encoder.m_pData, encoder.m_dwSize)
) { |
1007 return -1; | 1007 return -1; |
1008 } | 1008 } |
1009 if ((FX_DWORD)encoder.m_pDict->GetInteger(FX_BSTRC("Length")) != encryptor.m
_dwSize) { | 1009 if ((FX_DWORD)encoder.m_pDict->GetInteger(FX_BSTRC("Length")) != encryptor.m
_dwSize) { |
1010 encoder.CloneDict(); | 1010 encoder.CloneDict(); |
1011 encoder.m_pDict->SetAtInteger(FX_BSTRC("Length"), encryptor.m_dwSize); | 1011 encoder.m_pDict->SetAtInteger(FX_BSTRC("Length"), encryptor.m_dwSize); |
1012 } | 1012 } |
1013 if (WriteDirectObj(objnum, encoder.m_pDict) < 0) { | 1013 if (WriteDirectObj(objnum, encoder.m_pDict) < 0) { |
1014 return -1; | 1014 return -1; |
(...skipping 45 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1060 return 0; | 1060 return 0; |
1061 } | 1061 } |
1062 int32_t CPDF_Creator::WriteIndirectObj(const CPDF_Object* pObj) | 1062 int32_t CPDF_Creator::WriteIndirectObj(const CPDF_Object* pObj) |
1063 { | 1063 { |
1064 int32_t iRet = WriteIndirectObjectToStream(pObj); | 1064 int32_t iRet = WriteIndirectObjectToStream(pObj); |
1065 if (iRet < 1) { | 1065 if (iRet < 1) { |
1066 return iRet; | 1066 return iRet; |
1067 } | 1067 } |
1068 return WriteIndirectObj(pObj->GetObjNum(), pObj); | 1068 return WriteIndirectObj(pObj->GetObjNum(), pObj); |
1069 } | 1069 } |
1070 int32_t CPDF_Creator::WriteDirectObj(FX_DWORD objnum, const CPDF_Object* pObj, F
X_BOOL bEncrypt) | 1070 int32_t CPDF_Creator::WriteDirectObj(FX_DWORD objnum, const CPDF_Object* pObj, b
ool bEncrypt) |
1071 { | 1071 { |
1072 int32_t len = 0; | 1072 int32_t len = 0; |
1073 if (pObj == NULL) { | 1073 if (pObj == NULL) { |
1074 if (m_File.AppendString(FX_BSTRC(" null")) < 0) { | 1074 if (m_File.AppendString(FX_BSTRC(" null")) < 0) { |
1075 return -1; | 1075 return -1; |
1076 } | 1076 } |
1077 m_Offset += 5; | 1077 m_Offset += 5; |
1078 return 1; | 1078 return 1; |
1079 } | 1079 } |
1080 switch (pObj->GetType()) { | 1080 switch (pObj->GetType()) { |
1081 case PDFOBJ_NULL: | 1081 case PDFOBJ_NULL: |
1082 if (m_File.AppendString(FX_BSTRC(" null")) < 0) { | 1082 if (m_File.AppendString(FX_BSTRC(" null")) < 0) { |
1083 return -1; | 1083 return -1; |
1084 } | 1084 } |
1085 m_Offset += 5; | 1085 m_Offset += 5; |
1086 break; | 1086 break; |
1087 case PDFOBJ_BOOLEAN: | 1087 case PDFOBJ_BOOLEAN: |
1088 case PDFOBJ_NUMBER: | 1088 case PDFOBJ_NUMBER: |
1089 if (m_File.AppendString(FX_BSTRC(" ")) < 0) { | 1089 if (m_File.AppendString(FX_BSTRC(" ")) < 0) { |
1090 return -1; | 1090 return -1; |
1091 } | 1091 } |
1092 if ((len = m_File.AppendString(pObj->GetString())) < 0) { | 1092 if ((len = m_File.AppendString(pObj->GetString())) < 0) { |
1093 return -1; | 1093 return -1; |
1094 } | 1094 } |
1095 m_Offset += len + 1; | 1095 m_Offset += len + 1; |
1096 break; | 1096 break; |
1097 case PDFOBJ_STRING: { | 1097 case PDFOBJ_STRING: { |
1098 CFX_ByteString str = pObj->GetString(); | 1098 CFX_ByteString str = pObj->GetString(); |
1099 FX_BOOL bHex = ((CPDF_String*)pObj)->IsHex(); | 1099 bool bHex = ((CPDF_String*)pObj)->IsHex(); |
1100 if (m_pCryptoHandler == NULL || !bEncrypt) { | 1100 if (m_pCryptoHandler == NULL || !bEncrypt) { |
1101 CFX_ByteString content = PDF_EncodeString(str, bHex); | 1101 CFX_ByteString content = PDF_EncodeString(str, bHex); |
1102 if ((len = m_File.AppendString(content)) < 0) { | 1102 if ((len = m_File.AppendString(content)) < 0) { |
1103 return -1; | 1103 return -1; |
1104 } | 1104 } |
1105 m_Offset += len; | 1105 m_Offset += len; |
1106 break; | 1106 break; |
1107 } | 1107 } |
1108 CPDF_Encryptor encryptor; | 1108 CPDF_Encryptor encryptor; |
1109 encryptor.Initialize(m_pCryptoHandler, objnum, (uint8_t*)str.c_s
tr(), str.GetLength()); | 1109 encryptor.Initialize(m_pCryptoHandler, objnum, (uint8_t*)str.c_s
tr(), str.GetLength()); |
(...skipping 89 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1199 } | 1199 } |
1200 case PDFOBJ_DICTIONARY: { | 1200 case PDFOBJ_DICTIONARY: { |
1201 if (m_pCryptoHandler == NULL || pObj == m_pEncryptDict) { | 1201 if (m_pCryptoHandler == NULL || pObj == m_pEncryptDict) { |
1202 return PDF_CreatorAppendObject(pObj, &m_File, m_Offset); | 1202 return PDF_CreatorAppendObject(pObj, &m_File, m_Offset); |
1203 } | 1203 } |
1204 if (m_File.AppendString(FX_BSTRC("<<")) < 0) { | 1204 if (m_File.AppendString(FX_BSTRC("<<")) < 0) { |
1205 return -1; | 1205 return -1; |
1206 } | 1206 } |
1207 m_Offset += 2; | 1207 m_Offset += 2; |
1208 CPDF_Dictionary* p = (CPDF_Dictionary*)pObj; | 1208 CPDF_Dictionary* p = (CPDF_Dictionary*)pObj; |
1209 FX_BOOL bSignDict = IsSignatureDict(p); | 1209 bool bSignDict = IsSignatureDict(p); |
1210 FX_POSITION pos = p->GetStartPos(); | 1210 FX_POSITION pos = p->GetStartPos(); |
1211 while (pos) { | 1211 while (pos) { |
1212 FX_BOOL bSignValue = FALSE; | 1212 bool bSignValue = false; |
1213 CFX_ByteString key; | 1213 CFX_ByteString key; |
1214 CPDF_Object* pValue = p->GetNextElement(pos, key); | 1214 CPDF_Object* pValue = p->GetNextElement(pos, key); |
1215 if (m_File.AppendString(FX_BSTRC("/")) < 0) { | 1215 if (m_File.AppendString(FX_BSTRC("/")) < 0) { |
1216 return -1; | 1216 return -1; |
1217 } | 1217 } |
1218 if ((len = m_File.AppendString(PDF_NameEncode(key))) < 0) { | 1218 if ((len = m_File.AppendString(PDF_NameEncode(key))) < 0) { |
1219 return -1; | 1219 return -1; |
1220 } | 1220 } |
1221 m_Offset += len + 1; | 1221 m_Offset += len + 1; |
1222 if (bSignDict && key == FX_BSTRC("Contents")) { | 1222 if (bSignDict && key == FX_BSTRC("Contents")) { |
1223 bSignValue = TRUE; | 1223 bSignValue = true; |
1224 } | 1224 } |
1225 if (pValue->GetObjNum()) { | 1225 if (pValue->GetObjNum()) { |
1226 if (m_File.AppendString(FX_BSTRC(" ")) < 0) { | 1226 if (m_File.AppendString(FX_BSTRC(" ")) < 0) { |
1227 return -1; | 1227 return -1; |
1228 } | 1228 } |
1229 if ((len = m_File.AppendDWord(pValue->GetObjNum())) < 0)
{ | 1229 if ((len = m_File.AppendDWord(pValue->GetObjNum())) < 0)
{ |
1230 return -1; | 1230 return -1; |
1231 } | 1231 } |
1232 if (m_File.AppendString(FX_BSTRC(" 0 R ")) < 0) { | 1232 if (m_File.AppendString(FX_BSTRC(" 0 R ")) < 0) { |
1233 return -1; | 1233 return -1; |
(...skipping 14 matching lines...) Expand all Loading... |
1248 } | 1248 } |
1249 return 1; | 1249 return 1; |
1250 } | 1250 } |
1251 int32_t CPDF_Creator::WriteOldIndirectObject(FX_DWORD objnum) | 1251 int32_t CPDF_Creator::WriteOldIndirectObject(FX_DWORD objnum) |
1252 { | 1252 { |
1253 if(m_pParser->m_V5Type[objnum] == 0 || m_pParser->m_V5Type[objnum] == 255) { | 1253 if(m_pParser->m_V5Type[objnum] == 0 || m_pParser->m_V5Type[objnum] == 255) { |
1254 return 0; | 1254 return 0; |
1255 } | 1255 } |
1256 m_ObjectOffset[objnum] = m_Offset; | 1256 m_ObjectOffset[objnum] = m_Offset; |
1257 void* valuetemp = NULL; | 1257 void* valuetemp = NULL; |
1258 FX_BOOL bExistInMap = m_pDocument->m_IndirectObjs.Lookup((void*)(uintptr_t)o
bjnum, valuetemp); | 1258 bool bExistInMap = m_pDocument->m_IndirectObjs.Lookup((void*)(uintptr_t)objn
um, valuetemp); |
1259 FX_BOOL bObjStm = (m_pParser->m_V5Type[objnum] == 2) && m_pEncryptDict && !m
_pXRefStream; | 1259 bool bObjStm = (m_pParser->m_V5Type[objnum] == 2) && m_pEncryptDict && !m_pX
RefStream; |
1260 if(m_pParser->m_bVersionUpdated || m_bSecurityChanged || bExistInMap || bObj
Stm) { | 1260 if(m_pParser->m_bVersionUpdated || m_bSecurityChanged || bExistInMap || bObj
Stm) { |
1261 CPDF_Object* pObj = m_pDocument->GetIndirectObject(objnum); | 1261 CPDF_Object* pObj = m_pDocument->GetIndirectObject(objnum); |
1262 if (pObj == NULL) { | 1262 if (pObj == NULL) { |
1263 m_ObjectOffset[objnum] = 0; | 1263 m_ObjectOffset[objnum] = 0; |
1264 m_ObjectSize[objnum] = 0; | 1264 m_ObjectSize[objnum] = 0; |
1265 return 0; | 1265 return 0; |
1266 } | 1266 } |
1267 if (WriteIndirectObj(pObj)) { | 1267 if (WriteIndirectObj(pObj)) { |
1268 return -1; | 1268 return -1; |
1269 } | 1269 } |
(...skipping 57 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1327 return iRet; | 1327 return iRet; |
1328 } | 1328 } |
1329 m_ObjectSize[objnum] = (FX_DWORD)(m_Offset - m_ObjectOffset[objnum]); | 1329 m_ObjectSize[objnum] = (FX_DWORD)(m_Offset - m_ObjectOffset[objnum]); |
1330 if (pPause && pPause->NeedToPauseNow()) { | 1330 if (pPause && pPause->NeedToPauseNow()) { |
1331 m_Pos = (void*)(uintptr_t)(objnum + 1); | 1331 m_Pos = (void*)(uintptr_t)(objnum + 1); |
1332 return 1; | 1332 return 1; |
1333 } | 1333 } |
1334 } | 1334 } |
1335 return 0; | 1335 return 0; |
1336 } | 1336 } |
1337 int32_t CPDF_Creator::WriteNewObjs(FX_BOOL bIncremental, IFX_Pause *pPause) | 1337 int32_t CPDF_Creator::WriteNewObjs(bool bIncremental, IFX_Pause *pPause) |
1338 { | 1338 { |
1339 int32_t iCount = m_NewObjNumArray.GetSize(); | 1339 int32_t iCount = m_NewObjNumArray.GetSize(); |
1340 int32_t index = (int32_t)(uintptr_t)m_Pos; | 1340 int32_t index = (int32_t)(uintptr_t)m_Pos; |
1341 while (index < iCount) { | 1341 while (index < iCount) { |
1342 FX_DWORD objnum = m_NewObjNumArray.ElementAt(index); | 1342 FX_DWORD objnum = m_NewObjNumArray.ElementAt(index); |
1343 CPDF_Object *pObj = NULL; | 1343 CPDF_Object *pObj = NULL; |
1344 m_pDocument->m_IndirectObjs.Lookup((void*)(uintptr_t)objnum, (void*&)pOb
j); | 1344 m_pDocument->m_IndirectObjs.Lookup((void*)(uintptr_t)objnum, (void*&)pOb
j); |
1345 if (NULL == pObj) { | 1345 if (NULL == pObj) { |
1346 ++index; | 1346 ++index; |
1347 continue; | 1347 continue; |
(...skipping 30 matching lines...) Expand all Loading... |
1378 while (j <= dwEnd && m_pParser->m_V5Type[j] != 0 && m_pParser->m_V5Type[
j] != 255) { | 1378 while (j <= dwEnd && m_pParser->m_V5Type[j] != 0 && m_pParser->m_V5Type[
j] != 255) { |
1379 j++; | 1379 j++; |
1380 } | 1380 } |
1381 m_ObjectOffset.Add(dwStart, j - dwStart); | 1381 m_ObjectOffset.Add(dwStart, j - dwStart); |
1382 m_ObjectSize.Add(dwStart, j - dwStart); | 1382 m_ObjectSize.Add(dwStart, j - dwStart); |
1383 dwStart = j; | 1383 dwStart = j; |
1384 } | 1384 } |
1385 } | 1385 } |
1386 void CPDF_Creator::InitNewObjNumOffsets() | 1386 void CPDF_Creator::InitNewObjNumOffsets() |
1387 { | 1387 { |
1388 FX_BOOL bIncremental = (m_dwFlags & FPDFCREATE_INCREMENTAL) != 0; | 1388 bool bIncremental = (m_dwFlags & FPDFCREATE_INCREMENTAL) != 0; |
1389 FX_BOOL bNoOriginal = (m_dwFlags & FPDFCREATE_NO_ORIGINAL) != 0; | 1389 bool bNoOriginal = (m_dwFlags & FPDFCREATE_NO_ORIGINAL) != 0; |
1390 FX_DWORD nOldSize = m_pParser ? m_pParser->m_CrossRef.GetSize() : 0; | 1390 FX_DWORD nOldSize = m_pParser ? m_pParser->m_CrossRef.GetSize() : 0; |
1391 FX_POSITION pos = m_pDocument->m_IndirectObjs.GetStartPosition(); | 1391 FX_POSITION pos = m_pDocument->m_IndirectObjs.GetStartPosition(); |
1392 while (pos) { | 1392 while (pos) { |
1393 size_t key = 0; | 1393 size_t key = 0; |
1394 CPDF_Object* pObj; | 1394 CPDF_Object* pObj; |
1395 m_pDocument->m_IndirectObjs.GetNextAssoc(pos, (void*&)key, (void*&)pObj)
; | 1395 m_pDocument->m_IndirectObjs.GetNextAssoc(pos, (void*&)key, (void*&)pObj)
; |
1396 FX_DWORD objnum = (FX_DWORD)key; | 1396 FX_DWORD objnum = (FX_DWORD)key; |
1397 if (pObj->GetObjNum() == -1) { | 1397 if (pObj->GetObjNum() == -1) { |
1398 continue; | 1398 continue; |
1399 } | 1399 } |
1400 if (bIncremental) { | 1400 if (bIncremental) { |
1401 if (!pObj->IsModified()) { | 1401 if (!pObj->IsModified()) { |
1402 continue; | 1402 continue; |
1403 } | 1403 } |
1404 } else { | 1404 } else { |
1405 if (objnum < nOldSize && m_pParser->m_V5Type[objnum] != 0) { | 1405 if (objnum < nOldSize && m_pParser->m_V5Type[objnum] != 0) { |
1406 continue; | 1406 continue; |
1407 } | 1407 } |
1408 } | 1408 } |
1409 AppendNewObjNum(objnum); | 1409 AppendNewObjNum(objnum); |
1410 } | 1410 } |
1411 int32_t iCount = m_NewObjNumArray.GetSize(); | 1411 int32_t iCount = m_NewObjNumArray.GetSize(); |
1412 if (iCount == 0) { | 1412 if (iCount == 0) { |
1413 return; | 1413 return; |
1414 } | 1414 } |
1415 int32_t i = 0; | 1415 int32_t i = 0; |
1416 FX_DWORD dwStartObjNum = 0; | 1416 FX_DWORD dwStartObjNum = 0; |
1417 FX_BOOL bCrossRefValid = m_pParser && m_pParser->GetLastXRefOffset() > 0; | 1417 bool bCrossRefValid = m_pParser && m_pParser->GetLastXRefOffset() > 0; |
1418 while (i < iCount) { | 1418 while (i < iCount) { |
1419 dwStartObjNum = m_NewObjNumArray.ElementAt(i); | 1419 dwStartObjNum = m_NewObjNumArray.ElementAt(i); |
1420 if ((bIncremental && (bNoOriginal || bCrossRefValid)) || !m_ObjectOffset
.GetPtrAt(dwStartObjNum)) { | 1420 if ((bIncremental && (bNoOriginal || bCrossRefValid)) || !m_ObjectOffset
.GetPtrAt(dwStartObjNum)) { |
1421 break; | 1421 break; |
1422 } | 1422 } |
1423 i++; | 1423 i++; |
1424 } | 1424 } |
1425 if (i >= iCount) { | 1425 if (i >= iCount) { |
1426 return; | 1426 return; |
1427 } | 1427 } |
1428 FX_DWORD dwLastObjNum = dwStartObjNum; | 1428 FX_DWORD dwLastObjNum = dwStartObjNum; |
1429 i++; | 1429 i++; |
1430 FX_BOOL bNewStart = FALSE; | 1430 bool bNewStart = false; |
1431 for (; i < iCount; i++) { | 1431 for (; i < iCount; i++) { |
1432 FX_DWORD dwCurObjNum = m_NewObjNumArray.ElementAt(i); | 1432 FX_DWORD dwCurObjNum = m_NewObjNumArray.ElementAt(i); |
1433 FX_BOOL bExist = (dwCurObjNum < nOldSize && m_ObjectOffset.GetPtrAt(dwCu
rObjNum) != NULL); | 1433 bool bExist = (dwCurObjNum < nOldSize && m_ObjectOffset.GetPtrAt(dwCurOb
jNum) != NULL); |
1434 if (bExist || dwCurObjNum - dwLastObjNum > 1) { | 1434 if (bExist || dwCurObjNum - dwLastObjNum > 1) { |
1435 if (!bNewStart) { | 1435 if (!bNewStart) { |
1436 m_ObjectOffset.Add(dwStartObjNum, dwLastObjNum - dwStartObjNum +
1); | 1436 m_ObjectOffset.Add(dwStartObjNum, dwLastObjNum - dwStartObjNum +
1); |
1437 m_ObjectSize.Add(dwStartObjNum, dwLastObjNum - dwStartObjNum + 1
); | 1437 m_ObjectSize.Add(dwStartObjNum, dwLastObjNum - dwStartObjNum + 1
); |
1438 } | 1438 } |
1439 dwStartObjNum = dwCurObjNum; | 1439 dwStartObjNum = dwCurObjNum; |
1440 } | 1440 } |
1441 if (bNewStart) { | 1441 if (bNewStart) { |
1442 dwStartObjNum = dwCurObjNum; | 1442 dwStartObjNum = dwCurObjNum; |
1443 } | 1443 } |
(...skipping 95 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1539 src_size -= block_size; | 1539 src_size -= block_size; |
1540 if (pPause && pPause->NeedToPauseNow()) { | 1540 if (pPause && pPause->NeedToPauseNow()) { |
1541 m_Pos = (void*)(uintptr_t)src_size; | 1541 m_Pos = (void*)(uintptr_t)src_size; |
1542 return 1; | 1542 return 1; |
1543 } | 1543 } |
1544 } | 1544 } |
1545 } | 1545 } |
1546 if ((m_dwFlags & FPDFCREATE_NO_ORIGINAL) == 0 && m_pParser->GetLastXRefO
ffset() == 0) { | 1546 if ((m_dwFlags & FPDFCREATE_NO_ORIGINAL) == 0 && m_pParser->GetLastXRefO
ffset() == 0) { |
1547 InitOldObjNumOffsets(); | 1547 InitOldObjNumOffsets(); |
1548 FX_DWORD dwEnd = m_pParser->GetLastObjNum(); | 1548 FX_DWORD dwEnd = m_pParser->GetLastObjNum(); |
1549 FX_BOOL bObjStm = (m_dwFlags & FPDFCREATE_OBJECTSTREAM) != 0; | 1549 bool bObjStm = (m_dwFlags & FPDFCREATE_OBJECTSTREAM) != 0; |
1550 for (FX_DWORD objnum = 0; objnum <= dwEnd; objnum++) { | 1550 for (FX_DWORD objnum = 0; objnum <= dwEnd; objnum++) { |
1551 if (m_pParser->m_V5Type[objnum] == 0 || m_pParser->m_V5Type[objn
um] == 255) { | 1551 if (m_pParser->m_V5Type[objnum] == 0 || m_pParser->m_V5Type[objn
um] == 255) { |
1552 continue; | 1552 continue; |
1553 } | 1553 } |
1554 m_ObjectOffset[objnum] = m_pParser->m_CrossRef[objnum]; | 1554 m_ObjectOffset[objnum] = m_pParser->m_CrossRef[objnum]; |
1555 if (bObjStm) { | 1555 if (bObjStm) { |
1556 m_pXRefStream->AddObjectNumberToIndexArray(objnum); | 1556 m_pXRefStream->AddObjectNumberToIndexArray(objnum); |
1557 } | 1557 } |
1558 } | 1558 } |
1559 if (bObjStm) { | 1559 if (bObjStm) { |
(...skipping 55 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1615 } | 1615 } |
1616 return m_iStage; | 1616 return m_iStage; |
1617 } | 1617 } |
1618 int32_t CPDF_Creator::WriteDoc_Stage3(IFX_Pause *pPause) | 1618 int32_t CPDF_Creator::WriteDoc_Stage3(IFX_Pause *pPause) |
1619 { | 1619 { |
1620 FXSYS_assert(m_iStage >= 80 || m_iStage < 90); | 1620 FXSYS_assert(m_iStage >= 80 || m_iStage < 90); |
1621 FX_DWORD dwLastObjNum = m_dwLastObjNum; | 1621 FX_DWORD dwLastObjNum = m_dwLastObjNum; |
1622 if (m_iStage == 80) { | 1622 if (m_iStage == 80) { |
1623 m_XrefStart = m_Offset; | 1623 m_XrefStart = m_Offset; |
1624 if (m_dwFlags & FPDFCREATE_OBJECTSTREAM) { | 1624 if (m_dwFlags & FPDFCREATE_OBJECTSTREAM) { |
1625 m_pXRefStream->End(this, TRUE); | 1625 m_pXRefStream->End(this, true); |
1626 m_XrefStart = m_pXRefStream->m_PrevOffset; | 1626 m_XrefStart = m_pXRefStream->m_PrevOffset; |
1627 m_iStage = 90; | 1627 m_iStage = 90; |
1628 } else if ((m_dwFlags & FPDFCREATE_INCREMENTAL) == 0 || !m_pParser->IsXR
efStream()) { | 1628 } else if ((m_dwFlags & FPDFCREATE_INCREMENTAL) == 0 || !m_pParser->IsXR
efStream()) { |
1629 if ((m_dwFlags & FPDFCREATE_INCREMENTAL) == 0 || m_pParser->GetLastX
RefOffset() == 0) { | 1629 if ((m_dwFlags & FPDFCREATE_INCREMENTAL) == 0 || m_pParser->GetLastX
RefOffset() == 0) { |
1630 CFX_ByteString str; | 1630 CFX_ByteString str; |
1631 str = m_ObjectOffset.GetPtrAt(1) ? FX_BSTRC("xref\r\n") : FX_BST
RC("xref\r\n0 1\r\n0000000000 65536 f\r\n"); | 1631 str = m_ObjectOffset.GetPtrAt(1) ? FX_BSTRC("xref\r\n") : FX_BST
RC("xref\r\n0 1\r\n0000000000 65536 f\r\n"); |
1632 if (m_File.AppendString(str) < 0) { | 1632 if (m_File.AppendString(str) < 0) { |
1633 return -1; | 1633 return -1; |
1634 } | 1634 } |
1635 m_Pos = (void*)(uintptr_t)1; | 1635 m_Pos = (void*)(uintptr_t)1; |
(...skipping 122 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1758 } | 1758 } |
1759 if (pFile->AppendByte(0) < 0) { | 1759 if (pFile->AppendByte(0) < 0) { |
1760 return -1; | 1760 return -1; |
1761 } | 1761 } |
1762 return 0; | 1762 return 0; |
1763 } | 1763 } |
1764 int32_t CPDF_Creator::WriteDoc_Stage4(IFX_Pause *pPause) | 1764 int32_t CPDF_Creator::WriteDoc_Stage4(IFX_Pause *pPause) |
1765 { | 1765 { |
1766 FXSYS_assert(m_iStage >= 90); | 1766 FXSYS_assert(m_iStage >= 90); |
1767 if ((m_dwFlags & FPDFCREATE_OBJECTSTREAM) == 0) { | 1767 if ((m_dwFlags & FPDFCREATE_OBJECTSTREAM) == 0) { |
1768 FX_BOOL bXRefStream = (m_dwFlags & FPDFCREATE_INCREMENTAL) != 0 && m_pPa
rser->IsXRefStream(); | 1768 bool bXRefStream = (m_dwFlags & FPDFCREATE_INCREMENTAL) != 0 && m_pParse
r->IsXRefStream(); |
1769 if (!bXRefStream) { | 1769 if (!bXRefStream) { |
1770 if (m_File.AppendString(FX_BSTRC("trailer\r\n<<")) < 0) { | 1770 if (m_File.AppendString(FX_BSTRC("trailer\r\n<<")) < 0) { |
1771 return -1; | 1771 return -1; |
1772 } | 1772 } |
1773 } else { | 1773 } else { |
1774 if (m_File.AppendDWord(m_pDocument->m_LastObjNum + 1) < 0) { | 1774 if (m_File.AppendDWord(m_pDocument->m_LastObjNum + 1) < 0) { |
1775 return -1; | 1775 return -1; |
1776 } | 1776 } |
1777 if (m_File.AppendString(FX_BSTRC(" 0 obj <<")) < 0) { | 1777 if (m_File.AppendString(FX_BSTRC(" 0 obj <<")) < 0) { |
1778 return -1; | 1778 return -1; |
(...skipping 190 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1969 { | 1969 { |
1970 delete m_pXRefStream; | 1970 delete m_pXRefStream; |
1971 m_pXRefStream = NULL; | 1971 m_pXRefStream = NULL; |
1972 m_File.Clear(); | 1972 m_File.Clear(); |
1973 m_NewObjNumArray.RemoveAll(); | 1973 m_NewObjNumArray.RemoveAll(); |
1974 if (m_pIDArray) { | 1974 if (m_pIDArray) { |
1975 m_pIDArray->Release(); | 1975 m_pIDArray->Release(); |
1976 m_pIDArray = NULL; | 1976 m_pIDArray = NULL; |
1977 } | 1977 } |
1978 } | 1978 } |
1979 FX_BOOL CPDF_Creator::Create(const FX_CHAR* filename, FX_DWORD flags) | 1979 bool CPDF_Creator::Create(const FX_CHAR* filename, FX_DWORD flags) |
1980 { | 1980 { |
1981 if (!m_File.AttachFile(filename)) { | 1981 if (!m_File.AttachFile(filename)) { |
1982 return FALSE; | 1982 return false; |
1983 } | 1983 } |
1984 FX_BOOL bRet = Create(flags); | 1984 bool bRet = Create(flags); |
1985 if (!bRet || !(flags & FPDFCREATE_PROGRESSIVE)) { | 1985 if (!bRet || !(flags & FPDFCREATE_PROGRESSIVE)) { |
1986 Clear(); | 1986 Clear(); |
1987 } | 1987 } |
1988 return bRet; | 1988 return bRet; |
1989 } | 1989 } |
1990 FX_BOOL CPDF_Creator::Create(const FX_WCHAR* filename, FX_DWORD flags) | 1990 bool CPDF_Creator::Create(const FX_WCHAR* filename, FX_DWORD flags) |
1991 { | 1991 { |
1992 if (!m_File.AttachFile(filename)) { | 1992 if (!m_File.AttachFile(filename)) { |
1993 return FALSE; | 1993 return false; |
1994 } | 1994 } |
1995 FX_BOOL bRet = Create(flags); | 1995 bool bRet = Create(flags); |
1996 if (!bRet || !(flags & FPDFCREATE_PROGRESSIVE)) { | 1996 if (!bRet || !(flags & FPDFCREATE_PROGRESSIVE)) { |
1997 Clear(); | 1997 Clear(); |
1998 } | 1998 } |
1999 return bRet; | 1999 return bRet; |
2000 } | 2000 } |
2001 FX_BOOL CPDF_Creator::Create(IFX_StreamWrite* pFile, FX_DWORD flags) | 2001 bool CPDF_Creator::Create(IFX_StreamWrite* pFile, FX_DWORD flags) |
2002 { | 2002 { |
2003 if (!pFile) { | 2003 if (!pFile) { |
2004 return FALSE; | 2004 return false; |
2005 } | 2005 } |
2006 if (!m_File.AttachFile(pFile, FALSE)) { | 2006 if (!m_File.AttachFile(pFile, false)) { |
2007 return FALSE; | 2007 return false; |
2008 } | 2008 } |
2009 return Create(flags); | 2009 return Create(flags); |
2010 } | 2010 } |
2011 FX_BOOL CPDF_Creator::Create(FX_DWORD flags) | 2011 bool CPDF_Creator::Create(FX_DWORD flags) |
2012 { | 2012 { |
2013 m_dwFlags = flags; | 2013 m_dwFlags = flags; |
2014 m_iStage = 0; | 2014 m_iStage = 0; |
2015 m_Offset = 0; | 2015 m_Offset = 0; |
2016 m_dwLastObjNum = m_pDocument->GetLastObjNum(); | 2016 m_dwLastObjNum = m_pDocument->GetLastObjNum(); |
2017 m_ObjectOffset.Clear(); | 2017 m_ObjectOffset.Clear(); |
2018 m_ObjectSize.Clear(); | 2018 m_ObjectSize.Clear(); |
2019 m_NewObjNumArray.RemoveAll(); | 2019 m_NewObjNumArray.RemoveAll(); |
2020 InitID(); | 2020 InitID(); |
2021 if (flags & FPDFCREATE_PROGRESSIVE) { | 2021 if (flags & FPDFCREATE_PROGRESSIVE) { |
2022 return TRUE; | 2022 return true; |
2023 } | 2023 } |
2024 return Continue(NULL) > -1; | 2024 return Continue(NULL) > -1; |
2025 } | 2025 } |
2026 void CPDF_Creator::InitID(FX_BOOL bDefault ) | 2026 void CPDF_Creator::InitID(bool bDefault ) |
2027 { | 2027 { |
2028 CPDF_Array* pOldIDArray = m_pParser ? m_pParser->GetIDArray() : NULL; | 2028 CPDF_Array* pOldIDArray = m_pParser ? m_pParser->GetIDArray() : NULL; |
2029 FX_BOOL bNewId = !m_pIDArray; | 2029 bool bNewId = !m_pIDArray; |
2030 if (!m_pIDArray) { | 2030 if (!m_pIDArray) { |
2031 FX_DWORD* pBuffer = NULL; | 2031 FX_DWORD* pBuffer = NULL; |
2032 m_pIDArray = CPDF_Array::Create(); | 2032 m_pIDArray = CPDF_Array::Create(); |
2033 CPDF_Object* pID1 = pOldIDArray ? pOldIDArray->GetElement(0) : NULL; | 2033 CPDF_Object* pID1 = pOldIDArray ? pOldIDArray->GetElement(0) : NULL; |
2034 if (pID1) { | 2034 if (pID1) { |
2035 m_pIDArray->Add(pID1->Clone()); | 2035 m_pIDArray->Add(pID1->Clone()); |
2036 } else { | 2036 } else { |
2037 pBuffer = FX_Alloc(FX_DWORD, 4); | 2037 pBuffer = FX_Alloc(FX_DWORD, 4); |
2038 PDF_GenerateFileID((FX_DWORD)(uintptr_t)this, m_dwLastObjNum, pBuffe
r); | 2038 PDF_GenerateFileID((FX_DWORD)(uintptr_t)this, m_dwLastObjNum, pBuffe
r); |
2039 CFX_ByteStringC bsBuffer((const uint8_t*)pBuffer, 4 * sizeof(FX_DWOR
D)); | 2039 CFX_ByteStringC bsBuffer((const uint8_t*)pBuffer, 4 * sizeof(FX_DWOR
D)); |
2040 m_pIDArray->Add(CPDF_String::Create(bsBuffer, TRUE), m_pDocument); | 2040 m_pIDArray->Add(CPDF_String::Create(bsBuffer, true), m_pDocument); |
2041 } | 2041 } |
2042 if (pBuffer) { | 2042 if (pBuffer) { |
2043 FX_Free(pBuffer); | 2043 FX_Free(pBuffer); |
2044 } | 2044 } |
2045 } | 2045 } |
2046 if (!bDefault) { | 2046 if (!bDefault) { |
2047 return; | 2047 return; |
2048 } | 2048 } |
2049 if (pOldIDArray) { | 2049 if (pOldIDArray) { |
2050 CPDF_Object* pID2 = pOldIDArray->GetElement(1); | 2050 CPDF_Object* pID2 = pOldIDArray->GetElement(1); |
2051 if ((m_dwFlags & FPDFCREATE_INCREMENTAL) && m_pEncryptDict && pID2) { | 2051 if ((m_dwFlags & FPDFCREATE_INCREMENTAL) && m_pEncryptDict && pID2) { |
2052 m_pIDArray->Add(pID2->Clone()); | 2052 m_pIDArray->Add(pID2->Clone()); |
2053 return; | 2053 return; |
2054 } | 2054 } |
2055 FX_DWORD* pBuffer = FX_Alloc(FX_DWORD, 4); | 2055 FX_DWORD* pBuffer = FX_Alloc(FX_DWORD, 4); |
2056 PDF_GenerateFileID((FX_DWORD)(uintptr_t)this, m_dwLastObjNum, pBuffer); | 2056 PDF_GenerateFileID((FX_DWORD)(uintptr_t)this, m_dwLastObjNum, pBuffer); |
2057 CFX_ByteStringC bsBuffer((const uint8_t*)pBuffer, 4 * sizeof(FX_DWORD)); | 2057 CFX_ByteStringC bsBuffer((const uint8_t*)pBuffer, 4 * sizeof(FX_DWORD)); |
2058 m_pIDArray->Add(CPDF_String::Create(bsBuffer, TRUE), m_pDocument); | 2058 m_pIDArray->Add(CPDF_String::Create(bsBuffer, true), m_pDocument); |
2059 FX_Free(pBuffer); | 2059 FX_Free(pBuffer); |
2060 return; | 2060 return; |
2061 } | 2061 } |
2062 m_pIDArray->Add(m_pIDArray->GetElement(0)->Clone()); | 2062 m_pIDArray->Add(m_pIDArray->GetElement(0)->Clone()); |
2063 if (m_pEncryptDict && !pOldIDArray && m_pParser && bNewId) { | 2063 if (m_pEncryptDict && !pOldIDArray && m_pParser && bNewId) { |
2064 if (m_pEncryptDict->GetString(FX_BSTRC("Filter")) == FX_BSTRC("Standard"
)) { | 2064 if (m_pEncryptDict->GetString(FX_BSTRC("Filter")) == FX_BSTRC("Standard"
)) { |
2065 CPDF_StandardSecurityHandler handler; | 2065 CPDF_StandardSecurityHandler handler; |
2066 CFX_ByteString user_pass = m_pParser->GetPassword(); | 2066 CFX_ByteString user_pass = m_pParser->GetPassword(); |
2067 FX_DWORD flag = PDF_ENCRYPT_CONTENT; | 2067 FX_DWORD flag = PDF_ENCRYPT_CONTENT; |
2068 handler.OnCreate(m_pEncryptDict, m_pIDArray, (const uint8_t*)user_pa
ss, user_pass.GetLength(), flag); | 2068 handler.OnCreate(m_pEncryptDict, m_pIDArray, (const uint8_t*)user_pa
ss, user_pass.GetLength(), flag); |
2069 if (m_bNewCrypto) { | 2069 if (m_bNewCrypto) { |
2070 delete m_pCryptoHandler; | 2070 delete m_pCryptoHandler; |
2071 } | 2071 } |
2072 m_pCryptoHandler = new CPDF_StandardCryptoHandler; | 2072 m_pCryptoHandler = new CPDF_StandardCryptoHandler; |
2073 m_pCryptoHandler->Init(m_pEncryptDict, &handler); | 2073 m_pCryptoHandler->Init(m_pEncryptDict, &handler); |
2074 m_bNewCrypto = TRUE; | 2074 m_bNewCrypto = true; |
2075 m_bSecurityChanged = TRUE; | 2075 m_bSecurityChanged = true; |
2076 } | 2076 } |
2077 } | 2077 } |
2078 } | 2078 } |
2079 int32_t CPDF_Creator::Continue(IFX_Pause *pPause) | 2079 int32_t CPDF_Creator::Continue(IFX_Pause *pPause) |
2080 { | 2080 { |
2081 if (m_iStage < 0) { | 2081 if (m_iStage < 0) { |
2082 return m_iStage; | 2082 return m_iStage; |
2083 } | 2083 } |
2084 int32_t iRet = 0; | 2084 int32_t iRet = 0; |
2085 while (m_iStage < 100) { | 2085 while (m_iStage < 100) { |
(...skipping 10 matching lines...) Expand all Loading... |
2096 break; | 2096 break; |
2097 } | 2097 } |
2098 } | 2098 } |
2099 if (iRet < 1 || m_iStage == 100) { | 2099 if (iRet < 1 || m_iStage == 100) { |
2100 m_iStage = -1; | 2100 m_iStage = -1; |
2101 Clear(); | 2101 Clear(); |
2102 return iRet > 99 ? 0 : (iRet < 1 ? -1 : iRet); | 2102 return iRet > 99 ? 0 : (iRet < 1 ? -1 : iRet); |
2103 } | 2103 } |
2104 return m_iStage; | 2104 return m_iStage; |
2105 } | 2105 } |
2106 FX_BOOL CPDF_Creator::SetFileVersion(int32_t fileVersion ) | 2106 bool CPDF_Creator::SetFileVersion(int32_t fileVersion ) |
2107 { | 2107 { |
2108 if (fileVersion < 10 || fileVersion > 17) { | 2108 if (fileVersion < 10 || fileVersion > 17) { |
2109 return FALSE; | 2109 return false; |
2110 } | 2110 } |
2111 m_FileVersion = fileVersion; | 2111 m_FileVersion = fileVersion; |
2112 return TRUE; | 2112 return true; |
2113 } | 2113 } |
2114 void CPDF_Creator::RemoveSecurity() | 2114 void CPDF_Creator::RemoveSecurity() |
2115 { | 2115 { |
2116 ResetStandardSecurity(); | 2116 ResetStandardSecurity(); |
2117 m_bSecurityChanged = TRUE; | 2117 m_bSecurityChanged = true; |
2118 m_pEncryptDict = NULL; | 2118 m_pEncryptDict = NULL; |
2119 m_pCryptoHandler = NULL; | 2119 m_pCryptoHandler = NULL; |
2120 } | 2120 } |
2121 void CPDF_Creator::ResetStandardSecurity() | 2121 void CPDF_Creator::ResetStandardSecurity() |
2122 { | 2122 { |
2123 if (m_bStandardSecurity || m_bNewCrypto) { | 2123 if (m_bStandardSecurity || m_bNewCrypto) { |
2124 delete m_pCryptoHandler; | 2124 delete m_pCryptoHandler; |
2125 m_pCryptoHandler = NULL; | 2125 m_pCryptoHandler = NULL; |
2126 } | 2126 } |
2127 m_bNewCrypto = FALSE; | 2127 m_bNewCrypto = false; |
2128 if (!m_bStandardSecurity) { | 2128 if (!m_bStandardSecurity) { |
2129 return; | 2129 return; |
2130 } | 2130 } |
2131 if (m_pEncryptDict) { | 2131 if (m_pEncryptDict) { |
2132 m_pEncryptDict->Release(); | 2132 m_pEncryptDict->Release(); |
2133 m_pEncryptDict = NULL; | 2133 m_pEncryptDict = NULL; |
2134 } | 2134 } |
2135 m_bStandardSecurity = FALSE; | 2135 m_bStandardSecurity = false; |
2136 } | 2136 } |
OLD | NEW |