sdext/source/pdfimport/xpdfwrapper/pdfioutdev_gpl.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include "pdfioutdev_gpl.hxx"
  21 #include "pnghelper.hxx"
  22
  23 #include <stdlib.h>
  24 #include <stdio.h>
  25 #include <assert.h>
  26 #include <math.h>
  27
  28 #include <memory>
  29 #include <vector>
  30
  31 // sigh, UTF8.h was removed in poppler-0.21.0 and put back in 0.21.1, then renamed to UnicodeMapFuncs.h in 0.62.0
  32 // FIXME: we can't use #if POPPLER_CHECK_VERSION(0, 21, 0) && !POPPLER_CHECK_VERSION(0, 21, 1)
  33 //        because the internal poppler does not provide poppler-version.h and the macro always returns 0
  34 #if POPPLER_CHECK_VERSION(0, 62, 0)
  35 #include <UnicodeMapFuncs.h>
  36 #elif POPPLER_CHECK_VERSION(0, 21, 1)
  37 #include <UTF8.h>
  38 #elif POPPLER_CHECK_VERSION(0, 21, 0)
  39 #include "UTF.h"
  40 #else
  41 #include "UTF8.h"
  42 #endif
  43
  44 #ifdef _WIN32
  45 # define snprintf _snprintf
  46
  47 #if defined __GNUC__
  48 #pragma GCC diagnostic warning "-Wformat"
  49 #pragma GCC diagnostic warning "-Wformat-extra-args"
  50 #endif
  51 #endif
  52
  53 /* SYNC STREAMS
  54    ============
  55
  56    We stream human-readable tokens to stdout, and binary data (fonts,
  57    bitmaps) to g_binary_out. Another process reads from those pipes, and
  58    there lies the rub: things can deadlock, if the two involved
  59    processes access the pipes in different order. At any point in
  60    time, both processes must access the same pipe. To ensure this,
  61    data must be flushed to the OS before writing to a different pipe,
  62    otherwise not-yet-written data will leave the reading process
  63    waiting on the wrong pipe.
  64  */
  65
  66 namespace pdfi
  67 {
  68
  69 /// cut off very small numbers & clamp value to zero
  70 static double normalize( double val )
  71 {
  72     return fabs(val) < 0.0000001 ? 0.0 : val;
  73 }
  74
  75 namespace
  76 {
  77
  78 /** Escapes line-ending characters (\n and \r) in input string.
  79   */
  80 std::vector<char> lcl_escapeLineFeeds(const char* const i_pStr)
  81 {
  82     size_t nLength(strlen(i_pStr));
  83     std::vector<char> aBuffer;
  84     aBuffer.reserve(2*nLength+1);
  85
  86     const char* pRead = i_pStr;
  87     while( nLength-- )
  88     {
  89         if( *pRead == '\r' )
  90         {
  91             aBuffer.push_back('\\');
  92             aBuffer.push_back('r');
  93         }
  94         else if( *pRead == '\n' )
  95         {
  96             aBuffer.push_back('\\');
  97             aBuffer.push_back('n');
  98         }
  99         else if( *pRead == '\\' )
 100         {
 101             aBuffer.push_back('\\');
 102             aBuffer.push_back('\\');
 103         }
 104         else
 105             aBuffer.push_back(*pRead);
 106         pRead++;
 107     }
 108     aBuffer.push_back(0);
 109
 110     return aBuffer;
 111 }
 112
 113 }
 114
 115 /// for the temp char buffer the header gets snprintfed in
 116 #define WRITE_BUFFER_SIZE 1024
 117
 118 /// for the initial std::vector capacity when copying stream from xpdf
 119 #define WRITE_BUFFER_INITIAL_CAPACITY (1024*100)
 120
 121 static void initBuf(OutputBuffer& io_rBuffer)
 122 {
 123     io_rBuffer.reserve(WRITE_BUFFER_INITIAL_CAPACITY);
 124 }
 125
 126 static void writeBinaryBuffer( const OutputBuffer& rBuffer )
 127 {
 128     // ---sync point--- see SYNC STREAMS above
 129     fflush(stdout);
 130
 131     // put buffer to stderr
 132     if( !rBuffer.empty() )
 133         if( fwrite(rBuffer.data(), sizeof(char),
 134                    rBuffer.size(), g_binary_out) != static_cast<size_t>(rBuffer.size()) )
 135             exit(1); // error
 136
 137     // ---sync point--- see SYNC STREAMS above
 138     fflush(g_binary_out);
 139 }
 140
 141 static bool ExtractJpegData(Stream* str, OutputBuffer& outBuf)
 142 {
 143     int bytesToMarker = 0;
 144     int bytesToLen = -1;
 145     bool collectBytes = false;
 146     int startOfScan = 0;
 147     int b1 = -1;
 148     for (; ; )
 149     {
 150         const int b2 = b1;
 151         b1 = str->getChar();
 152
 153         if (b1 == -1)
 154             return false;
 155
 156         if (collectBytes)
 157         {
 158             outBuf.push_back(static_cast<Output_t>(b1));
 159
 160             bytesToMarker--;
 161             bytesToLen--;
 162         }
 163
 164         if (bytesToMarker == 0)
 165         {
 166             if (startOfScan == 1)
 167             {
 168                 bytesToMarker = -1;
 169                 startOfScan = 2;
 170             }
 171             else if (b2 == 0xFF)
 172             {
 173                 if (b1 == 0xD8)
 174                 {
 175                     collectBytes = true;
 176                     bytesToMarker = 2;
 177
 178                     outBuf.push_back(Output_t(0xFF));
 179                     outBuf.push_back(Output_t(0xD8));
 180                 }
 181                 else
 182                 {
 183                     bytesToLen = 2;
 184                 }
 185                 if (b1 == 0xDA)
 186                 {
 187                     startOfScan = 1;
 188                 }
 189             }
 190             else if (collectBytes)
 191             {
 192                 return false;
 193             }
 194         }
 195
 196         if (bytesToLen == 0)
 197         {
 198             bytesToMarker = b2 * 256 + b1;
 199         }
 200
 201         if (startOfScan == 2)
 202             if ((b2 == 0xFF) && (b1 == 0xD9))
 203                 return true;
 204     }
 205 }
 206
 207 static void writeJpeg_( OutputBuffer& o_rOutputBuf, Stream* str )
 208 {
 209     // dump JPEG file as-is
 210 #if POPPLER_CHECK_VERSION(0, 17, 3)
 211     str = str->getNextStream();
 212 #else
 213     str = ((DCTStream *)str)->getRawStream();
 214 #endif
 215     str->reset();
 216
 217     o_rOutputBuf.clear();
 218     ExtractJpegData(str, o_rOutputBuf);
 219
 220     printf( " JPEG %d", static_cast<int>(o_rOutputBuf.size()) );
 221     printf("\n");
 222
 223     str->close();
 224 }
 225
 226 static void writePbm_(OutputBuffer& o_rOutputBuf, Stream* str, int width, int height, bool bInvert )
 227 {
 228     // write as PBM (char by char, to avoid stdlib lineend messing)
 229     o_rOutputBuf.clear();
 230     o_rOutputBuf.resize(WRITE_BUFFER_SIZE);
 231     o_rOutputBuf[0] = 'P';
 232     o_rOutputBuf[1] = '4';
 233     o_rOutputBuf[2] = 0x0A;
 234     char *pAsCharPtr = reinterpret_cast<char *>(&o_rOutputBuf[3]);
 235     int nOutLen = snprintf(pAsCharPtr, WRITE_BUFFER_SIZE-10, "%d %d", width, height);
 236     if( nOutLen < 0 )
 237         nOutLen = WRITE_BUFFER_SIZE-10;
 238     o_rOutputBuf[3+nOutLen]  =0x0A;
 239     o_rOutputBuf[3+nOutLen+1]=0;
 240
 241     const int header_size = 3+nOutLen+1;
 242     const int size = height * ((width + 7) / 8);
 243
 244     printf( " PBM %d", size + header_size );
 245     printf("\n");
 246
 247     // trim buffer to exact header length
 248     o_rOutputBuf.resize(header_size);
 249
 250     // initialize stream
 251     str->reset();
 252
 253     // copy the raw stream
 254     if( bInvert )
 255     {
 256         for( int i=0; i<size; ++i)
 257             o_rOutputBuf.push_back(static_cast<char>(str->getChar() ^ 0xff));
 258     }
 259     else
 260     {
 261         for( int i=0; i<size; ++i)
 262             o_rOutputBuf.push_back(static_cast<char>(str->getChar()));
 263     }
 264
 265     str->close();
 266 }
 267
 268 static void writePpm_( OutputBuffer&     o_rOutputBuf,
 269                 Stream*           str,
 270                 int               width,
 271                 int               height,
 272                 GfxImageColorMap* colorMap )
 273 {
 274     // write as PPM (char by char, to avoid stdlib lineend messing)
 275     o_rOutputBuf.clear();
 276     o_rOutputBuf.resize(WRITE_BUFFER_SIZE);
 277     o_rOutputBuf[0] = 'P';
 278     o_rOutputBuf[1] = '6';
 279     o_rOutputBuf[2] = '\n';
 280     char *pAsCharPtr = reinterpret_cast<char *>(&o_rOutputBuf[3]);
 281     int nOutLen = snprintf(pAsCharPtr, WRITE_BUFFER_SIZE-10, "%d %d", width, height);
 282     if( nOutLen < 0 )
 283         nOutLen = WRITE_BUFFER_SIZE-10;
 284     o_rOutputBuf[3+nOutLen]  ='\n';
 285     o_rOutputBuf[3+nOutLen+1]='2';
 286     o_rOutputBuf[3+nOutLen+2]='5';
 287     o_rOutputBuf[3+nOutLen+3]='5';
 288     o_rOutputBuf[3+nOutLen+4]='\n';
 289     o_rOutputBuf[3+nOutLen+5]=0;
 290
 291     const int header_size = 3+nOutLen+5;
 292     const int size = width*height*3 + header_size;
 293
 294     printf( " PPM %d", size );
 295     printf("\n");
 296
 297     // trim buffer to exact header size
 298     o_rOutputBuf.resize(header_size);
 299
 300     // initialize stream
 301     unsigned char *p;
 302     GfxRGB rgb;
 303     std::unique_ptr<ImageStream> imgStr(
 304         new ImageStream(str,
 305                         width,
 306                         colorMap->getNumPixelComps(),
 307                         colorMap->getBits()));
 308     imgStr->reset();
 309
 310     for( int y=0; y<height; ++y)
 311     {
 312         p = imgStr->getLine();
 313         for( int x=0; x<width; ++x)
 314         {
 315             colorMap->getRGB(p, &rgb);
 316             o_rOutputBuf.push_back(colToByte(rgb.r));
 317             o_rOutputBuf.push_back(colToByte(rgb.g));
 318             o_rOutputBuf.push_back(colToByte(rgb.b));
 319
 320             p +=colorMap->getNumPixelComps();
 321         }
 322     }
 323 }
 324
 325 // call this only for 1 bit image streams !
 326 static void writePng_( OutputBuffer&     o_rOutputBuf,
 327                 Stream*           str,
 328                 int               width,
 329                 int               height,
 330                 GfxRGB const &    zeroColor,
 331                 GfxRGB const &    oneColor,
 332                 bool              bIsMask )
 333 {
 334     o_rOutputBuf.clear();
 335
 336     // get png image
 337     PngHelper::createPng( o_rOutputBuf, str, width, height, zeroColor, oneColor, bIsMask );
 338
 339     printf( " PNG %d", static_cast<int>(o_rOutputBuf.size()) );
 340     printf("\n");
 341 }
 342
 343 static void writePng_( OutputBuffer& o_rOutputBuf,
 344                 Stream* str,
 345                 int width, int height, GfxImageColorMap* colorMap,
 346                 Stream* maskStr,
 347                 int maskWidth, int maskHeight, GfxImageColorMap* maskColorMap )
 348 {
 349     o_rOutputBuf.clear();
 350
 351     // get png image
 352     PngHelper::createPng( o_rOutputBuf, str, width, height, colorMap, maskStr, maskWidth, maskHeight, maskColorMap );
 353
 354     printf( " PNG %d", static_cast<int>(o_rOutputBuf.size()) );
 355     printf("\n");
 356 }
 357
 358 static void writePng_( OutputBuffer& o_rOutputBuf,
 359                 Stream* str,
 360                 int width, int height, GfxImageColorMap* colorMap,
 361                 Stream* maskStr,
 362                 int maskWidth, int maskHeight, bool maskInvert )
 363 {
 364     o_rOutputBuf.clear();
 365
 366     // get png image
 367     PngHelper::createPng( o_rOutputBuf, str, width, height, colorMap, maskStr, maskWidth, maskHeight, maskInvert );
 368
 369     printf( " PNG %d", static_cast<int>(o_rOutputBuf.size()) );
 370     printf("\n");
 371 }
 372
 373 // stolen from ImageOutputDev.cc
 374 static void writeMask_( OutputBuffer& o_rOutputBuf, Stream* str, int width, int height, bool bInvert )
 375 {
 376     if( str->getKind() == strDCT )
 377         writeJpeg_(o_rOutputBuf, str);
 378     else
 379         writePbm_(o_rOutputBuf, str, width, height, bInvert );
 380 }
 381
 382 static void writeImage_( OutputBuffer&     o_rOutputBuf,
 383                   Stream*           str,
 384                   int               width,
 385                   int               height,
 386                   GfxImageColorMap* colorMap )
 387 {
 388     // dump JPEG file
 389     if( str->getKind() == strDCT &&
 390         (colorMap->getNumPixelComps() == 1 ||
 391          colorMap->getNumPixelComps() == 3) )
 392     {
 393         writeJpeg_(o_rOutputBuf, str);
 394     }
 395     else if (colorMap->getNumPixelComps() == 1 &&
 396              colorMap->getBits() == 1)
 397     {
 398         // this is a two color bitmap, write a png
 399         // provide default colors
 400         GfxRGB zeroColor = { 0, 0, 0 },
 401                 oneColor = { byteToCol( 0xff ), byteToCol( 0xff ), byteToCol( 0xff ) };
 402         if( colorMap->getColorSpace()->getMode() == csIndexed || colorMap->getColorSpace()->getMode() == csDeviceGray )
 403         {
 404             unsigned char nIndex = 0;
 405             colorMap->getRGB( &nIndex, &zeroColor );
 406             nIndex = 1;
 407             colorMap->getRGB( &nIndex, &oneColor );
 408         }
 409         writePng_( o_rOutputBuf, str, width, height, zeroColor, oneColor, false);
 410     }
 411     else
 412         writePpm_( o_rOutputBuf, str, width, height, colorMap );
 413 }
 414
 415 // forwarders
 416
 417
 418 static void writeImageLF( OutputBuffer&     o_rOutputBuf,
 419                           Stream*           str,
 420                           int               width,
 421                           int               height,
 422                           GfxImageColorMap* colorMap ) { writeImage_(o_rOutputBuf,str,width,height,colorMap); }
 423 static void writeMaskLF( OutputBuffer&     o_rOutputBuf,
 424                          Stream*           str,
 425                          int               width,
 426                          int               height,
 427                          bool              bInvert ) { writeMask_(o_rOutputBuf,str,width,height,bInvert); }
 428
 429
 430 int PDFOutDev::parseFont( long long nNewId, GfxFont* gfxFont, const GfxState* state ) const
 431 {
 432     FontAttributes aNewFont;
 433     int nSize = 0;
 434
 435 #if POPPLER_CHECK_VERSION(20, 12, 0)
 436     std::string familyName = gfxFont->getNameWithoutSubsetTag();
 437 #else
 438 #if POPPLER_CHECK_VERSION(0, 71, 0) // GooString::toStr()
 439     std::string familyName = gfxFont->getName()->toStr();
 440 #else
 441     const GooString* gooString = gfxFont->getName();
 442     std::string familyName = std::string(gooString->getCString(), gooString->getLength());
 443 #endif
 444     if (familyName.length() > 7 && familyName.at(6) == '+')
 445     {
 446         familyName = familyName.substr(7);
 447     }
 448 #endif
 449     if( familyName != "" )
 450     {
 451         aNewFont.familyName.clear();
 452 #if POPPLER_CHECK_VERSION(0, 83, 0) // GooString::append(const std::string&)
 453         aNewFont.familyName.append( familyName );
 454 #else
 455         aNewFont.familyName.append( familyName.c_str() );
 456 #endif
 457     }
 458     else
 459     {
 460         aNewFont.familyName.clear();
 461         aNewFont.familyName.append( "Arial" );
 462     }
 463
 464     aNewFont.maFontWeight  = gfxFont->getWeight();
 465     aNewFont.isItalic      = gfxFont->isItalic();
 466 #if POPPLER_CHECK_VERSION(0, 83, 0) // const added to getTransformedFontSize
 467     aNewFont.size          = state->getTransformedFontSize();
 468 #else
 469     aNewFont.size          = const_cast<GfxState*>(state)->getTransformedFontSize();
 470 #endif
 471     aNewFont.isUnderline   = false;
 472
 473     if( gfxFont->getType() == fontTrueType || gfxFont->getType() == fontType1 )
 474     {
 475         // TODO(P3): Unfortunately, need to read stream twice, since
 476         // we must write byte count to stdout before
 477 #if POPPLER_CHECK_VERSION(22, 6, 0)
 478         std::optional<std::vector<unsigned char>> pBuf = gfxFont->readEmbFontFile( m_pDoc->getXRef() );
 479         if ( pBuf )
 480         {
 481             aNewFont.isEmbedded = true;
 482             nSize = pBuf->size();
 483         }
 484 #else
 485         char* pBuf = gfxFont->readEmbFontFile( m_pDoc->getXRef(), &nSize );
 486         if( pBuf )
 487         {
 488             aNewFont.isEmbedded = true;
 489             gfree(pBuf);
 490         }
 491 #endif
 492     }
 493
 494     m_aFontMap[ nNewId ] = aNewFont;
 495     return nSize;
 496 }
 497
 498 void PDFOutDev::writeFontFile( GfxFont* gfxFont ) const
 499 {
 500     if( gfxFont->getType() != fontTrueType && gfxFont->getType() != fontType1 )
 501         return;
 502
 503     int nSize = 0;
 504 #if POPPLER_CHECK_VERSION(22, 6, 0)
 505     std::optional<std::vector<unsigned char>> pBuf = gfxFont->readEmbFontFile( m_pDoc->getXRef() );
 506     if ( pBuf )
 507         nSize = pBuf->size();
 508     if ( nSize == 0 )
 509         return;
 510 #else
 511     char* pBuf = gfxFont->readEmbFontFile( m_pDoc->getXRef(), &nSize );
 512     if( !pBuf )
 513         return;
 514 #endif
 515
 516     // ---sync point--- see SYNC STREAMS above
 517     fflush(stdout);
 518
 519 #if POPPLER_CHECK_VERSION(22, 6, 0)
 520     if( fwrite(pBuf->data(), sizeof(*pBuf->data()), nSize, g_binary_out) != static_cast<size_t>(nSize) )
 521     {
 522         exit(1); // error
 523     }
 524     // ---sync point--- see SYNC STREAMS above
 525     fflush(g_binary_out);
 526 #else
 527     if( fwrite(pBuf, sizeof(char), nSize, g_binary_out) != static_cast<size_t>(nSize) )
 528     {
 529         gfree(pBuf);
 530         exit(1); // error
 531     }
 532     // ---sync point--- see SYNC STREAMS above
 533     fflush(g_binary_out);
 534     gfree(pBuf);
 535 #endif
 536 }
 537
 538 #if POPPLER_CHECK_VERSION(0, 83, 0)
 539 void PDFOutDev::printPath( const GfxPath* pPath )
 540 #else
 541 void PDFOutDev::printPath( GfxPath* pPath )
 542 #endif
 543 {
 544     int nSubPaths = pPath ? pPath->getNumSubpaths() : 0;
 545     for( int i=0; i<nSubPaths; i++ )
 546     {
 547 #if POPPLER_CHECK_VERSION(0, 83, 0)
 548         const
 549 #endif
 550         GfxSubpath* pSub  = pPath->getSubpath( i );
 551         const int nPoints = pSub->getNumPoints();
 552
 553         printf( " subpath %d", pSub->isClosed() );
 554
 555         for( int n=0; n<nPoints; ++n )
 556         {
 557             printf( " %f %f %d",
 558                     normalize(pSub->getX(n)),
 559                     normalize(pSub->getY(n)),
 560                     pSub->getCurve(n) );
 561         }
 562     }
 563 }
 564
 565 PDFOutDev::PDFOutDev( PDFDoc* pDoc ) :
 566     m_pDoc( pDoc ),
 567     m_pUtf8Map( new UnicodeMap("UTF-8", true, &mapUTF8) ),
 568     m_bSkipImages(false)
 569 {
 570 }
 571 PDFOutDev::~PDFOutDev()
 572 {
 573 }
 574
 575 void PDFOutDev::startPage(int /*pageNum*/, GfxState* state
 576 #if POPPLER_CHECK_VERSION(0, 23, 0) ||  POPPLER_CHECK_VERSION(0, 24, 0)
 577                           , XRef* /*xref*/
 578 #endif
 579 )
 580 {
 581     assert(state);
 582     printf("startPage %f %f\n",
 583            normalize(state->getPageWidth()),
 584            normalize(state->getPageHeight()));
 585 }
 586
 587 void PDFOutDev::endPage()
 588 {
 589     printf("endPage\n");
 590 }
 591
 592 #if POPPLER_CHECK_VERSION(0, 19, 0)
 593 void PDFOutDev::processLink(AnnotLink *link)
 594 #elif POPPLER_CHECK_VERSION(0, 17, 0)
 595 void PDFOutDev::processLink(AnnotLink *link, Catalog *)
 596 #else
 597 void PDFOutDev::processLink(Link* link, Catalog*)
 598 #endif
 599 {
 600     assert(link);
 601
 602     double x1,x2,y1,y2;
 603     link->getRect( &x1, &y1, &x2, &y2 );
 604
 605     LinkAction* pAction = link->getAction();
 606     if (!(pAction && pAction->getKind() == actionURI))
 607         return;
 608
 609 #if POPPLER_CHECK_VERSION(0, 86, 0)
 610     const char* pURI = static_cast<LinkURI*>(pAction)->getURI().c_str();
 611 #elif POPPLER_CHECK_VERSION(0, 72, 0)
 612     const char* pURI = static_cast<LinkURI*>(pAction)->getURI()->c_str();
 613 #else
 614     const char* pURI = static_cast<LinkURI*>(pAction)->getURI()->getCString();
 615 #endif
 616
 617     std::vector<char> aEsc( lcl_escapeLineFeeds(pURI) );
 618
 619     printf( "drawLink %f %f %f %f %s\n",
 620             normalize(x1),
 621             normalize(y1),
 622             normalize(x2),
 623             normalize(y2),
 624             aEsc.data() );
 625 }
 626
 627 void PDFOutDev::saveState(GfxState*)
 628 {
 629     printf( "saveState\n" );
 630 }
 631
 632 void PDFOutDev::restoreState(GfxState*)
 633 {
 634     printf( "restoreState\n" );
 635 }
 636
 637 #if POPPLER_CHECK_VERSION(0, 71, 0)
 638 void PDFOutDev::setDefaultCTM(const double *pMat)
 639 #else
 640 void PDFOutDev::setDefaultCTM(double *pMat)
 641 #endif
 642 {
 643     assert(pMat);
 644
 645     OutputDev::setDefaultCTM(pMat);
 646
 647     printf( "updateCtm %f %f %f %f %f %f\n",
 648             normalize(pMat[0]),
 649             normalize(pMat[1]),
 650             normalize(pMat[2]),
 651             normalize(pMat[3]),
 652             normalize(pMat[4]),
 653             normalize(pMat[5]) );
 654 }
 655
 656 void PDFOutDev::updateCTM(GfxState* state,
 657                           double, double,
 658                           double, double,
 659                           double, double)
 660 {
 661     assert(state);
 662
 663     const double* const pMat = state->getCTM();
 664     assert(pMat);
 665
 666     printf( "updateCtm %f %f %f %f %f %f\n",
 667             normalize(pMat[0]),
 668             normalize(pMat[1]),
 669             normalize(pMat[2]),
 670             normalize(pMat[3]),
 671             normalize(pMat[4]),
 672             normalize(pMat[5]) );
 673 }
 674
 675 void PDFOutDev::updateLineDash(GfxState *state)
 676 {
 677     if (m_bSkipImages)
 678         return;
 679     assert(state);
 680
 681     int arrayLen; double startOffset;
 682 #if POPPLER_CHECK_VERSION(22, 9, 0)
 683     const std::vector<double> &dash = state->getLineDash(&startOffset);
 684     const double* dashArray = dash.data();
 685     arrayLen = dash.size();
 686 #else
 687     double* dashArray;
 688     state->getLineDash(&dashArray, &arrayLen, &startOffset);
 689 #endif
 690
 691     printf( "updateLineDash" );
 692     if( arrayLen && dashArray )
 693     {
 694         printf( " %f %d", normalize(startOffset), arrayLen );
 695         for( int i=0; i<arrayLen; ++i )
 696             printf( " %f", normalize(*dashArray++) );
 697     }
 698     printf( "\n" );
 699 }
 700
 701 void PDFOutDev::updateFlatness(GfxState *state)
 702 {
 703     if (m_bSkipImages)
 704         return;
 705     assert(state);
 706     printf( "updateFlatness %d\n", state->getFlatness() );
 707 }
 708
 709 void PDFOutDev::updateLineJoin(GfxState *state)
 710 {
 711     if (m_bSkipImages)
 712         return;
 713     assert(state);
 714     printf( "updateLineJoin %d\n", state->getLineJoin() );
 715 }
 716
 717 void PDFOutDev::updateLineCap(GfxState *state)
 718 {
 719     if (m_bSkipImages)
 720         return;
 721     assert(state);
 722     printf( "updateLineCap %d\n", state->getLineCap() );
 723 }
 724
 725 void PDFOutDev::updateMiterLimit(GfxState *state)
 726 {
 727     if (m_bSkipImages)
 728         return;
 729     assert(state);
 730     printf( "updateMiterLimit %f\n", normalize(state->getMiterLimit()) );
 731 }
 732
 733 void PDFOutDev::updateLineWidth(GfxState *state)
 734 {
 735     if (m_bSkipImages)
 736         return;
 737     assert(state);
 738     printf( "updateLineWidth %f\n", normalize(state->getLineWidth()) );
 739 }
 740
 741 void PDFOutDev::updateFillColor(GfxState *state)
 742 {
 743     if (m_bSkipImages)
 744         return;
 745     assert(state);
 746
 747     GfxRGB aRGB;
 748     state->getFillRGB( &aRGB );
 749
 750     printf( "updateFillColor %f %f %f %f\n",
 751             normalize(colToDbl(aRGB.r)),
 752             normalize(colToDbl(aRGB.g)),
 753             normalize(colToDbl(aRGB.b)),
 754             normalize(state->getFillOpacity()) );
 755 }
 756
 757 void PDFOutDev::updateStrokeColor(GfxState *state)
 758 {
 759     if (m_bSkipImages)
 760         return;
 761     assert(state);
 762
 763     GfxRGB aRGB;
 764     state->getStrokeRGB( &aRGB );
 765
 766     printf( "updateStrokeColor %f %f %f %f\n",
 767             normalize(colToDbl(aRGB.r)),
 768             normalize(colToDbl(aRGB.g)),
 769             normalize(colToDbl(aRGB.b)),
 770             normalize(state->getFillOpacity()) );
 771 }
 772
 773 void PDFOutDev::updateFillOpacity(GfxState *state)
 774 {
 775     if (m_bSkipImages)
 776         return;
 777     updateFillColor(state);
 778 }
 779
 780 void PDFOutDev::updateStrokeOpacity(GfxState *state)
 781 {
 782     if (m_bSkipImages)
 783         return;
 784     updateStrokeColor(state);
 785 }
 786
 787 void PDFOutDev::updateBlendMode(GfxState*)
 788 {
 789 }
 790
 791 void PDFOutDev::updateFont(GfxState *state)
 792 {
 793     assert(state);
 794
 795 #if POPPLER_CHECK_VERSION(22, 6, 0)
 796     GfxFont *gfxFont = state->getFont().get();
 797 #else
 798     GfxFont *gfxFont = state->getFont();
 799 #endif
 800     if( !gfxFont )
 801         return;
 802
 803     FontAttributes aFont;
 804     int nEmbedSize=0;
 805
 806 #if POPPLER_CHECK_VERSION(0, 64, 0)
 807     const
 808 #endif
 809     Ref* pID = gfxFont->getID();
 810     // TODO(Q3): Portability problem
 811     long long fontID = static_cast<long long>(pID->gen) << 32 | static_cast<long long>(pID->num);
 812     std::unordered_map< long long, FontAttributes >::const_iterator it =
 813         m_aFontMap.find( fontID );
 814     if( it == m_aFontMap.end() )
 815     {
 816         nEmbedSize = parseFont( fontID, gfxFont, state );
 817         it = m_aFontMap.find( fontID );
 818     }
 819
 820     printf( "updateFont" );
 821     if( it != m_aFontMap.end() )
 822     {
 823         // conflating this with printf below crashes under Windoze
 824         printf( " %lld", fontID );
 825
 826         aFont = it->second;
 827
 828 #if POPPLER_CHECK_VERSION(0, 72, 0)
 829         std::vector<char> aEsc( lcl_escapeLineFeeds(aFont.familyName.c_str()) );
 830 #else
 831         std::vector<char> aEsc( lcl_escapeLineFeeds(aFont.familyName.getCString()) );
 832 #endif
 833         printf( " %d %d %d %d %f %d %s",
 834                 aFont.isEmbedded,
 835                 aFont.maFontWeight,
 836                 aFont.isItalic,
 837                 aFont.isUnderline,
 838                 normalize(state->getTransformedFontSize()),
 839                 nEmbedSize,
 840                 aEsc.data() );
 841     }
 842     printf( "\n" );
 843
 844     if (nEmbedSize)
 845     {
 846         writeFontFile(gfxFont);
 847     }
 848 }
 849
 850 void PDFOutDev::updateRender(GfxState *state)
 851 {
 852     assert(state);
 853
 854     printf( "setTextRenderMode %d\n", state->getRender() );
 855 }
 856
 857 void PDFOutDev::stroke(GfxState *state)
 858 {
 859     if (m_bSkipImages)
 860         return;
 861     assert(state);
 862
 863     printf( "strokePath" );
 864     printPath( state->getPath() );
 865     printf( "\n" );
 866 }
 867
 868 void PDFOutDev::fill(GfxState *state)
 869 {
 870     if (m_bSkipImages)
 871         return;
 872     assert(state);
 873
 874     printf( "fillPath" );
 875     printPath( state->getPath() );
 876     printf( "\n" );
 877 }
 878
 879 void PDFOutDev::eoFill(GfxState *state)
 880 {
 881     if (m_bSkipImages)
 882         return;
 883     assert(state);
 884
 885     printf( "eoFillPath" );
 886     printPath( state->getPath() );
 887     printf( "\n" );
 888 }
 889
 890 void PDFOutDev::clip(GfxState *state)
 891 {
 892     if (m_bSkipImages)
 893         return;
 894     assert(state);
 895
 896     printf( "clipPath" );
 897     printPath( state->getPath() );
 898     printf( "\n" );
 899 }
 900
 901 void PDFOutDev::eoClip(GfxState *state)
 902 {
 903     if (m_bSkipImages)
 904         return;
 905     assert(state);
 906
 907     printf( "eoClipPath" );
 908     printPath( state->getPath() );
 909     printf( "\n" );
 910 }
 911
 912 /** Output one glyph
 913
 914
 915     @param dx
 916     horizontal skip for character (already scaled with font size) +
 917     inter-char space: cursor is shifted by this amount for next char
 918
 919     @param dy
 920     vertical skip for character (zero for horizontal writing mode):
 921     cursor is shifted by this amount for next char
 922
 923     @param originX
 924     local offset of character (zero for horizontal writing mode). not
 925     taken into account for output pos updates. Used for vertical writing.
 926
 927     @param originY
 928     local offset of character (zero for horizontal writing mode). not
 929     taken into account for output pos updates. Used for vertical writing.
 930  */
 931
 932 #if POPPLER_CHECK_VERSION(0, 82, 0)
 933 void PDFOutDev::drawChar(GfxState *state, double x, double y,
 934                          double dx, double dy,
 935                          double originX, double originY,
 936                          CharCode, int /*nBytes*/, const Unicode *u, int uLen)
 937 {
 938 #else
 939 void PDFOutDev::drawChar(GfxState *state, double x, double y,
 940                          double dx, double dy,
 941                          double originX, double originY,
 942                          CharCode, int /*nBytes*/, Unicode *u, int uLen)
 943 {
 944 #endif
 945     assert(state);
 946
 947     if( u == nullptr )
 948         return;
 949
 950     // Fix for tdf#96080
 951     if (uLen == 4 && u[0] == '\t' && u[1] == '\r' && u[2] == ' ' && u[3] == 0xA0)
 952     {
 953         u += 2;
 954         uLen = 1;
 955     }
 956
 957     double csdx = 0.0;
 958     double csdy = 0.0;
 959     if (state->getFont()->getWMode())
 960     {
 961         csdy = state->getCharSpace();
 962         if (*u == ' ')
 963             csdy += state->getWordSpace();
 964     }
 965     else
 966     {
 967         csdx = state->getCharSpace();
 968         if (*u == ' ')
 969             csdx += state->getWordSpace();
 970         csdx *= state->getHorizScaling();
 971     }
 972
 973     double cstdx = 0.0;
 974     double cstdy = 0.0;
 975     state->textTransformDelta(csdx, csdy, &cstdx, &cstdy);
 976
 977     const double fontSize = state->getFontSize();
 978
 979     const double aPositionX(x-originX);
 980     const double aPositionY(y-originY);
 981
 982     const double* pTextMat=state->getTextMat();
 983     printf( "drawChar %f %f %f %f %f %f %f %f %f ",
 984             normalize(aPositionX),
 985             normalize(aPositionY),
 986             normalize(aPositionX + dx - cstdx),
 987             normalize(aPositionY + dy - cstdy),
 988             normalize(pTextMat[0]),
 989             normalize(pTextMat[2]),
 990             normalize(pTextMat[1]),
 991             normalize(pTextMat[3]),
 992             normalize(fontSize)
 993             );
 994
 995     // silence spurious warning
 996 #if POPPLER_CHECK_VERSION(0, 62, 0)
 997     (void)&mapUTF16;
 998 #else
 999     (void)&mapUCS2;
1000 #endif
1001
1002     char buf[9];
1003     for( int i=0; i<uLen; ++i )
1004     {
1005         buf[ m_pUtf8Map->mapUnicode(u[i], buf, sizeof(buf)-1) ] = 0;
1006         std::vector<char> aEsc( lcl_escapeLineFeeds(buf) );
1007         printf( "%s", aEsc.data() );
1008     }
1009
1010     printf( "\n" );
1011 }
1012
1013 #if POPPLER_CHECK_VERSION(0, 64, 0)
1014 void PDFOutDev::drawString(GfxState*, const GooString* /*s*/)
1015 #else
1016 void PDFOutDev::drawString(GfxState*, GooString* /*s*/)
1017 #endif
1018 {
1019     // TODO(F3): NYI
1020 }
1021
1022 void PDFOutDev::endTextObject(GfxState*)
1023 {
1024     printf( "endTextObject\n" );
1025 }
1026
1027 void PDFOutDev::drawImageMask(GfxState* pState, Object*, Stream* str,
1028                               int width, int height, poppler_bool invert,
1029                               poppler_bool /*interpolate*/,
1030                               poppler_bool /*inlineImg*/ )
1031 {
1032     if (m_bSkipImages)
1033         return;
1034     OutputBuffer aBuf; initBuf(aBuf);
1035
1036     printf( "drawMask %d %d %d", width, height, invert );
1037
1038     int bitsPerComponent = 1;
1039     StreamColorSpaceMode csMode = streamCSNone;
1040     str->getImageParams( &bitsPerComponent, &csMode );
1041     if( bitsPerComponent == 1 && (csMode == streamCSNone || csMode == streamCSDeviceGray) )
1042     {
1043         GfxRGB oneColor = { dblToCol( 1.0 ), dblToCol( 1.0 ), dblToCol( 1.0 ) };
1044         GfxRGB zeroColor = { dblToCol( 0.0 ), dblToCol( 0.0 ), dblToCol( 0.0 ) };
1045         pState->getFillColorSpace()->getRGB( pState->getFillColor(), &zeroColor );
1046         if( invert )
1047             writePng_( aBuf, str, width, height, oneColor, zeroColor, true );
1048         else
1049             writePng_( aBuf, str, width, height, zeroColor, oneColor, true );
1050     }
1051     else
1052         writeMaskLF(aBuf, str, width, height, invert);
1053     writeBinaryBuffer(aBuf);
1054 }
1055
1056 #if POPPLER_CHECK_VERSION(0, 82, 0)
1057 void PDFOutDev::drawImage(GfxState*, Object*, Stream* str,
1058                           int width, int height, GfxImageColorMap* colorMap,
1059                           poppler_bool /*interpolate*/,
1060                           const int* maskColors, poppler_bool /*inlineImg*/ )
1061 {
1062 #else
1063 void PDFOutDev::drawImage(GfxState*, Object*, Stream* str,
1064                           int width, int height, GfxImageColorMap* colorMap,
1065                           poppler_bool /*interpolate*/,
1066                           int* maskColors, poppler_bool /*inlineImg*/ )
1067 {
1068 #endif
1069     if (m_bSkipImages)
1070         return;
1071     OutputBuffer aBuf; initBuf(aBuf);
1072     OutputBuffer aMaskBuf;
1073
1074     printf( "drawImage %d %d", width, height );
1075
1076     if( maskColors )
1077     {
1078         // write mask colors. nBytes must be even - first half is
1079         // lower bound values, second half upper bound values
1080         if( colorMap->getColorSpace()->getMode() == csIndexed )
1081         {
1082             aMaskBuf.push_back( static_cast<char>(maskColors[0]) );
1083             aMaskBuf.push_back( static_cast<char>(maskColors[gfxColorMaxComps]) );
1084         }
1085         else
1086         {
1087             GfxRGB aMinRGB;
1088             colorMap->getColorSpace()->getRGB(
1089 #if POPPLER_CHECK_VERSION(0, 82, 0)
1090                 reinterpret_cast<const GfxColor*>(maskColors),
1091 #else
1092                 reinterpret_cast<GfxColor*>(maskColors),
1093 #endif
1094                 &aMinRGB );
1095
1096             GfxRGB aMaxRGB;
1097             colorMap->getColorSpace()->getRGB(
1098 #if POPPLER_CHECK_VERSION(0, 82, 0)
1099                 reinterpret_cast<const GfxColor*>(maskColors)+gfxColorMaxComps,
1100 #else
1101                 reinterpret_cast<GfxColor*>(maskColors)+gfxColorMaxComps,
1102 #endif
1103                 &aMaxRGB );
1104
1105             aMaskBuf.push_back( colToByte(aMinRGB.r) );
1106             aMaskBuf.push_back( colToByte(aMinRGB.g) );
1107             aMaskBuf.push_back( colToByte(aMinRGB.b) );
1108             aMaskBuf.push_back( colToByte(aMaxRGB.r) );
1109             aMaskBuf.push_back( colToByte(aMaxRGB.g) );
1110             aMaskBuf.push_back( colToByte(aMaxRGB.b) );
1111         }
1112     }
1113
1114     printf( " %d", static_cast<int>(aMaskBuf.size()) );
1115     writeImageLF( aBuf, str, width, height, colorMap );
1116     writeBinaryBuffer(aBuf);
1117     writeBinaryBuffer(aMaskBuf);
1118 }
1119
1120 void PDFOutDev::drawMaskedImage(GfxState*, Object*, Stream* str,
1121                                 int width, int height,
1122                                 GfxImageColorMap* colorMap,
1123                                 poppler_bool /*interpolate*/,
1124                                 Stream* maskStr,
1125                                 int maskWidth, int maskHeight,
1126                                 poppler_bool maskInvert, poppler_bool /*maskInterpolate*/
1127                                )
1128 {
1129     if (m_bSkipImages)
1130         return;
1131     OutputBuffer aBuf;     initBuf(aBuf);
1132     printf( "drawImage %d %d 0", width, height );
1133     writePng_( aBuf, str, width, height, colorMap, maskStr, maskWidth, maskHeight, maskInvert );
1134     writeBinaryBuffer( aBuf );
1135 }
1136
1137 void PDFOutDev::drawSoftMaskedImage(GfxState*, Object*, Stream* str,
1138                                     int width, int height,
1139                                     GfxImageColorMap* colorMap,
1140                                     poppler_bool /*interpolate*/,
1141                                     Stream* maskStr,
1142                                     int maskWidth, int maskHeight,
1143                                     GfxImageColorMap* maskColorMap
1144                                     , poppler_bool /*maskInterpolate*/
1145                                    )
1146 {
1147     if (m_bSkipImages)
1148         return;
1149     OutputBuffer aBuf;     initBuf(aBuf);
1150     printf( "drawImage %d %d 0", width, height );
1151     writePng_( aBuf, str, width, height, colorMap, maskStr, maskWidth, maskHeight, maskColorMap );
1152     writeBinaryBuffer( aBuf );
1153 }
1154
1155 void PDFOutDev::setPageNum( int nNumPages )
1156 {
1157     // TODO(F3): printf might format int locale-dependent!
1158     printf("setPageNum %d\n", nNumPages);
1159 }
1160
1161 void PDFOutDev::setSkipImages( bool bSkipImages )
1162 {
1163     m_bSkipImages = bSkipImages;
1164 }
1165
1166 }
1167
1168 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */