libreofficekit/qa/tilebench/tilebench.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
  10 #include <stdio.h>
  11 #include <string.h>
  12 #include <cmath>
  13
  14 #include <vector>
  15 #include <atomic>
  16 #include <iostream>
  17 #include <osl/time.h>
  18
  19 #include <LibreOfficeKit/LibreOfficeKitEnums.h>
  20 #include <LibreOfficeKit/LibreOfficeKitInit.h>
  21 #include <LibreOfficeKit/LibreOfficeKit.hxx>
  22
  23 #ifdef IOS
  24 #include <vcl/svapp.hxx>
  25 #endif
  26
  27 #include <boost/property_tree/json_parser.hpp>
  28
  29 using namespace lok;
  30
  31 static int help( const char *error = nullptr )
  32 {
  33     if (error)
  34         fprintf (stderr, "Error: %s\n\n", error);
  35     fprintf( stderr, "Usage: tilebench <absolute-path-to-libreoffice-install> [path to document] [--preinit] <options>\n");
  36     fprintf( stderr, "\trenders a selection of small tiles from the document, checksums them and times the process based on options:\n" );
  37     fprintf( stderr, "\t--tile\t[max parts|-1] [max tiles|-1]\n" );
  38     fprintf( stderr, "\t--dialog\t<.uno:Command>\n" );
  39     fprintf( stderr, "\t--join\trun tile joining tests\n" );
  40     return 1;
  41 }
  42
  43 static double getTimeNow()
  44 {
  45     TimeValue aValue;
  46     osl_getSystemTime(&aValue);
  47     return static_cast<double>(aValue.Seconds) +
  48            static_cast<double>(aValue.Nanosec) / (1000*1000*1000);
  49 }
  50
  51 static double origin;
  52
  53 namespace {
  54
  55 struct TimeRecord {
  56     const char *mpName;
  57     double mfTime;
  58
  59     TimeRecord() : mpName(nullptr), mfTime(getTimeNow()) { }
  60     explicit TimeRecord(const char *pName) :
  61         mpName(pName), mfTime(getTimeNow())
  62     {
  63         fprintf(stderr, "%3.3fs - %s\n", (mfTime - origin), mpName);
  64     }
  65 };
  66
  67 }
  68
  69 static std::vector< TimeRecord > aTimes;
  70
  71 /// Dump an array (or sub-array) of RGBA or BGRA to an RGB PPM file.
  72 static void dumpTile(const char *pNameStem,
  73                      const int nWidth, const int nHeight,
  74                      const int mode, const unsigned char* pBufferU,
  75                      const int nOffX = 0, const int nOffY = 0,
  76                      int nTotalWidth = -1)
  77 {
  78     if (nTotalWidth < 0)
  79         nTotalWidth = nWidth;
  80
  81     auto pBuffer = reinterpret_cast<const char *>(pBufferU);
  82     static int counter = 0;
  83     std::string aName = "/tmp/dump_tile";
  84     aName += pNameStem;
  85     aName += "_" + std::to_string(counter);
  86     aName += ".ppm";
  87 #ifndef IOS
  88     std::ofstream ofs(aName);
  89 #else
  90     NSArray *paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
  91     NSString *documentsDirectory = [paths objectAtIndex:0];
  92     NSString *path = [NSString stringWithFormat:@"%@/dump_tile_%d.ppm", documentsDirectory, counter];
  93     std::ofstream ofs([path UTF8String]);
  94     std::cerr << "---> Dumping tile\n";
  95 #endif
  96     counter++;
  97     ofs << "P6\n"
  98         << nWidth << " "
  99         << nHeight << "\n"
 100         << 255 << "\n" ;
 101
 102     const bool dumpText = false;
 103
 104     if (dumpText)
 105         fprintf(stderr, "Stream %s - %dx%d:\n", pNameStem, nWidth, nHeight);
 106
 107     for (int y = 0; y < nHeight; ++y)
 108     {
 109         const char* row = pBuffer + (y + nOffY) * nTotalWidth * 4 + nOffX * 4;
 110         for (int x = 0; x < nWidth; ++x)
 111         {
 112             const char* pixel = row + x * 4;
 113             if (mode == LOK_TILEMODE_RGBA)
 114             {
 115                 ofs.write(pixel, 3); // Skip alpha
 116             }
 117             else if (mode == LOK_TILEMODE_BGRA)
 118             {
 119                 const int alpha = *(pixel + 3);
 120                 char buf[3];
 121                 if (alpha == 0)
 122                 {
 123                     buf[0] = 0;
 124                     buf[1] = 0;
 125                     buf[2] = 0;
 126                 }
 127                 else
 128                 {
 129                     buf[0] = (*(pixel + 2) * 255 + alpha / 2) / alpha;
 130                     buf[1] = (*(pixel + 1) * 255 + alpha / 2) / alpha;
 131                     buf[2] = (*(pixel + 0) * 255 + alpha / 2) / alpha;
 132                 }
 133
 134                 ofs.write(buf, 3);
 135             }
 136             if (dumpText)
 137             {
 138                 int lowResI = (pixel[0] + pixel[1] + pixel[2])/(3*16);
 139                 fprintf(stderr,"%1x", lowResI);
 140             }
 141         }
 142         if (dumpText)
 143             fprintf(stderr,"\n");
 144     }
 145     ofs.close();
 146 }
 147
 148 static void testTile( Document *pDocument, int max_parts,
 149                       int max_tiles, bool dump )
 150 {
 151     const int mode = pDocument->getTileMode();
 152
 153     aTimes.emplace_back("getparts");
 154     const int nOriginalPart = (pDocument->getDocumentType() == LOK_DOCTYPE_TEXT ? 1 : pDocument->getPart());
 155     // Writer really has 1 part (the full doc).
 156     const int nTotalParts = (pDocument->getDocumentType() == LOK_DOCTYPE_TEXT ? 1 : pDocument->getParts());
 157     const int nParts = (max_parts < 0 ? nTotalParts : std::min(max_parts, nTotalParts));
 158     aTimes.emplace_back();
 159
 160     aTimes.emplace_back("get size of parts");
 161     long nWidth = 0;
 162     long nHeight = 0;
 163     for (int n = 0; n < nParts; ++n)
 164     {
 165         const int nPart = (nOriginalPart + n) % nTotalParts;
 166         char* pName = pDocument->getPartName(nPart);
 167         pDocument->setPart(nPart);
 168         pDocument->getDocumentSize(&nWidth, &nHeight);
 169         fprintf (stderr, "  '%s' -> %ld, %ld\n", pName, nWidth, nHeight);
 170         free (pName);
 171     }
 172     aTimes.emplace_back();
 173
 174     // Use realistic dimensions, similar to the Online client.
 175     long const nTilePixelWidth = 512;
 176     long const nTilePixelHeight = 512;
 177     long const nTileTwipWidth = 3840;
 178     long const nTileTwipHeight = 3840;
 179
 180     // Estimate the maximum tiles based on the number of parts requested, if Writer.
 181     if (pDocument->getDocumentType() == LOK_DOCTYPE_TEXT)
 182         max_tiles = static_cast<int>(ceil(max_parts * 16128. / nTilePixelHeight) * ceil(static_cast<double>(nWidth) / nTilePixelWidth));
 183     fprintf(stderr, "Parts to render: %d, Total Parts: %d, Max parts: %d, Max tiles: %d\n", nParts, nTotalParts, max_parts, max_tiles);
 184
 185     std::vector<unsigned char> vBuffer(nTilePixelWidth * nTilePixelHeight * 4);
 186     unsigned char* pPixels = vBuffer.data();
 187
 188     for (int n = 0; n < nParts; ++n)
 189     {
 190         const int nPart = (nOriginalPart + n) % nTotalParts;
 191         char* pName = pDocument->getPartName(nPart);
 192         pDocument->setPart(nPart);
 193         pDocument->getDocumentSize(&nWidth, &nHeight);
 194         fprintf (stderr, "render '%s' -> %ld, %ld\n", pName, nWidth, nHeight);
 195         free (pName);
 196
 197         if (dump || pDocument->getDocumentType() != LOK_DOCTYPE_TEXT)
 198         {
 199             // whole part; meaningful only for non-writer documents.
 200             aTimes.emplace_back("render whole part");
 201             pDocument->paintTile(pPixels, nTilePixelWidth, nTilePixelHeight,
 202                                  nWidth/2, 2000, 1000, 1000);
 203             aTimes.emplace_back();
 204             if (dump)
 205                 dumpTile("tile", nTilePixelWidth, nTilePixelHeight, mode, pPixels);
 206         }
 207
 208         { // 1:1
 209             aTimes.emplace_back("render sub-region at 1:1");
 210             // Estimate the maximum tiles based on the number of parts requested, if Writer.
 211             int nMaxTiles = max_tiles;
 212             int nTiles = 0;
 213             for (long nY = 0; nY < nHeight - 1; nY += nTilePixelHeight)
 214             {
 215                 for (long nX = 0; nX < nWidth - 1; nX += nTilePixelWidth)
 216                 {
 217                     if (nMaxTiles >= 0 && nTiles >= nMaxTiles)
 218                     {
 219                         nY = nHeight;
 220                         break;
 221                     }
 222                     pDocument->paintTile(pPixels, nTilePixelWidth, nTilePixelHeight,
 223                                          nX, nY, nTilePixelWidth, nTilePixelHeight);
 224                     nTiles++;
 225                     fprintf (stderr, "   rendered 1:1 tile %d at %ld, %ld\n",
 226                              nTiles, nX, nY);
 227                 }
 228             }
 229             aTimes.emplace_back();
 230         }
 231
 232         { // scaled
 233             aTimes.emplace_back("render sub-regions at scale");
 234             int nMaxTiles = max_tiles;
 235             if (pDocument->getDocumentType() == LOK_DOCTYPE_TEXT)
 236                 nMaxTiles = static_cast<int>(ceil(max_parts * 16128. / nTileTwipHeight) * ceil(static_cast<double>(nWidth) / nTileTwipWidth));
 237             int nTiles = 0;
 238             for (long nY = 0; nY < nHeight - 1; nY += nTileTwipHeight)
 239             {
 240                 for (long nX = 0; nX < nWidth - 1; nX += nTileTwipWidth)
 241                 {
 242                     if (nMaxTiles >= 0 && nTiles >= nMaxTiles)
 243                     {
 244                         nY = nHeight;
 245                         break;
 246                     }
 247                     pDocument->paintTile(pPixels, nTilePixelWidth, nTilePixelHeight,
 248                                          nX, nY, nTileTwipWidth, nTileTwipHeight);
 249                     nTiles++;
 250                     fprintf (stderr, "   rendered scaled tile %d at %ld, %ld\n",
 251                              nTiles, nX, nY);
 252                 }
 253             }
 254             aTimes.emplace_back();
 255         }
 256     }
 257 }
 258
 259 static uint32_t fade(uint32_t col)
 260 {
 261     uint8_t a = (col >> 24) & 0xff;
 262     uint8_t b = (col >> 16) & 0xff;
 263     uint8_t g = (col >>  8) & 0xff;
 264     uint8_t r = (col >>  0) & 0xff;
 265     uint8_t grey = (r+g+b)/6;
 266     return (a<<24) + (grey<<16) + (grey<<8) + grey;
 267 }
 268
 269 static bool sloppyEqual(uint32_t pixA, uint32_t pixB)
 270 {
 271     uint8_t a[4], b[4];
 272
 273     a[0] = (pixA >> 24) & 0xff;
 274     a[1] = (pixA >> 16) & 0xff;
 275     a[2] = (pixA >>  8) & 0xff;
 276     a[3] = (pixA >>  0) & 0xff;
 277
 278     b[0] = (pixB >> 24) & 0xff;
 279     b[1] = (pixB >> 16) & 0xff;
 280     b[2] = (pixB >>  8) & 0xff;
 281     b[3] = (pixB >>  0) & 0xff;
 282
 283     for (int i = 0; i < 4; ++i)
 284     {
 285         int delta = a[i];
 286         delta -= b[i];
 287         // tolerate small differences
 288         if (delta < -4 || delta > 4)
 289             return false;
 290     }
 291     return true;
 292 }
 293
 294 // Count and build a picture of any differences into rDiff
 295 static int diffTiles( const std::vector<unsigned char> &vBase,
 296                        long nBaseRowPixelWidth,
 297                        const std::vector<unsigned char> &vCompare,
 298                        long nCompareRowPixelWidth,
 299                        long nTilePixelHeight,
 300                        long nPosX, long nPosY,
 301                        std::vector<unsigned char> &rDiff )
 302 {
 303     int nDifferent = 0;
 304     const uint32_t *pBase = reinterpret_cast<const uint32_t *>(vBase.data());
 305     const uint32_t *pCompare = reinterpret_cast<const uint32_t *>(vCompare.data());
 306     uint32_t *pDiff = reinterpret_cast<uint32_t *>(rDiff.data());
 307     long left = 0, mid = nCompareRowPixelWidth, right = nCompareRowPixelWidth*2;
 308     for (long y = 0; y < nTilePixelHeight; ++y)
 309     {
 310         long nBaseOffset = nBaseRowPixelWidth * (y + nPosY) + nPosX * nCompareRowPixelWidth;
 311         long nCompareOffset = nCompareRowPixelWidth * y;
 312         long nDiffRowStart = nCompareOffset * 3;
 313         for (long x = 0; x < nCompareRowPixelWidth; ++x)
 314         {
 315             pDiff[nDiffRowStart + left  + x] = pBase[nBaseOffset + x];
 316             pDiff[nDiffRowStart + mid   + x] = pCompare[nCompareOffset + x];
 317             pDiff[nDiffRowStart + right + x] = fade(pBase[nBaseOffset + x]);
 318             if (!sloppyEqual(pBase[nBaseOffset + x], pCompare[nCompareOffset + x]))
 319             {
 320                 pDiff[nDiffRowStart + right + x] = 0xffff00ff;
 321                 if (!nDifferent)
 322                     fprintf (stderr, "First mismatching pixel at %ld (pixels) into row %ld\n", x, y);
 323                 nDifferent++;
 324             }
 325         }
 326     }
 327     return nDifferent;
 328 }
 329
 330 static std::vector<unsigned char> paintTile( Document *pDocument,
 331                                              long nX, long nY,
 332                                              long const nTilePixelWidth,
 333                                              long const nTilePixelHeight,
 334                                              long const nTileTwipWidth,
 335                                              long const nTileTwipHeight )
 336 {
 337 //    long e = 0; // tweak if we suspect an overlap / visibility issue.
 338 //    pDocument->setClientVisibleArea( nX - e, nY - e, nTileTwipWidth + e, nTileTwipHeight + e );
 339     std::vector<unsigned char> vData( nTilePixelWidth * nTilePixelHeight * 4 );
 340     pDocument->paintTile( vData.data(), nTilePixelWidth, nTilePixelHeight,
 341                           nX, nY, nTileTwipWidth, nTileTwipHeight );
 342     return vData;
 343 }
 344
 345 static int testJoinsAt( Document *pDocument, long nX, long nY,
 346                         long const nTilePixelSize,
 347                         long const nTileTwipSize )
 348 {
 349     const int mode = pDocument->getTileMode();
 350
 351     long const nTilePixelWidth = nTilePixelSize;
 352     long const nTilePixelHeight = nTilePixelSize;
 353     long const nTileTwipWidth = nTileTwipSize;
 354     long const nTileTwipHeight = nTileTwipSize;
 355
 356     long initPosX = nX * nTileTwipWidth, initPosY = nY * nTileTwipHeight;
 357
 358     // Calc has to do significant work on changing zoom ...
 359     pDocument->setClientZoom( nTilePixelWidth, nTilePixelHeight,
 360                               nTileTwipWidth, nTileTwipHeight );
 361
 362     // Unfortunately without getting this nothing renders ...
 363     std::stringstream aForceHeaders;
 364     aForceHeaders << ".uno:ViewRowColumnHeaders?x=" << initPosX << "&y=" << initPosY <<
 365         "&width=" << (nTileTwipWidth * 2) << "&height=" << (nTileTwipHeight * 2);
 366     std::string cmd = aForceHeaders.str();
 367     char* pJSON = pDocument->getCommandValues(cmd.c_str());
 368     fprintf(stderr, "command: '%s' values '%s'\n", cmd.c_str(), pJSON);
 369     free(pJSON);
 370
 371     // Get a base image 4x the size
 372     std::vector<unsigned char> vBase(
 373         paintTile(pDocument, initPosX, initPosY,
 374                   nTilePixelWidth * 2, nTilePixelHeight * 2,
 375                   nTileTwipWidth * 2, nTileTwipHeight * 2));
 376
 377     const struct {
 378         long X;
 379         long Y;
 380     } aCompare[] = {
 381         { 0, 0 },
 382         { 1, 0 },
 383         { 0, 1 },
 384         { 1, 1 }
 385     };
 386
 387     int nDifferences = 0;
 388     // Compare each of the 4x tiles with a sub-tile of the larger image
 389     for( auto &rPos : aCompare )
 390     {
 391         std::vector<unsigned char> vCompare(
 392             paintTile(pDocument,
 393                       initPosX + rPos.X * nTileTwipWidth,
 394                       initPosY + rPos.Y * nTileTwipHeight,
 395                       nTilePixelWidth, nTilePixelHeight,
 396                       nTileTwipWidth, nTileTwipHeight));
 397
 398         std::vector<unsigned char> vDiff( nTilePixelWidth * 3 * nTilePixelHeight * 4 );
 399         int nDiffs = diffTiles( vBase, nTilePixelWidth * 2,
 400                                 vCompare, nTilePixelWidth,
 401                                 nTilePixelHeight,
 402                                 rPos.X, rPos.Y * nTilePixelHeight,
 403                                 vDiff );
 404         if ( nDiffs > 0 )
 405         {
 406             fprintf( stderr, "  %d differences in sub-tile pixel mismatch at %ld, %ld at offset %ld, %ld (twips) size %ld\n",
 407                      nDiffs, rPos.X, rPos.Y, initPosX, initPosY,
 408                      nTileTwipWidth);
 409             dumpTile("_base", nTilePixelWidth * 2, nTilePixelHeight * 2,
 410                      mode, vBase.data());
 411 /*            dumpTile("_sub", nTilePixelWidth, nTilePixelHeight,
 412                      mode, vBase.data(),
 413                      rPos.X*nTilePixelWidth, rPos.Y*nTilePixelHeight,
 414                      nTilePixelWidth * 2);
 415             dumpTile("_compare", nTilePixelWidth, nTilePixelHeight,
 416             mode, vCompare.data());*/
 417             dumpTile("_diff", nTilePixelWidth * 3, nTilePixelHeight, mode, vDiff.data());
 418         }
 419         nDifferences += nDiffs;
 420     }
 421
 422     return nDifferences;
 423 }
 424
 425 // Check that our tiles join nicely ...
 426 static int testJoin( Document *pDocument)
 427 {
 428     // Ignore parts - just the first for now ...
 429     long nWidth = 0, nHeight = 0;
 430     pDocument->getDocumentSize(&nWidth, &nHeight);
 431     fprintf (stderr, "Width is %ld, %ld (twips)\n", nWidth, nHeight);
 432
 433     // Use realistic dimensions, similar to the Online client.
 434     long const nTilePixelSize = 256;
 435     long const nTileTwipSize = 3840;
 436     double fZooms[] = {
 437         0.5,
 438         0.6, 0.7, 0.85,
 439         1.0,
 440         1.2, 1.5, 1.75,
 441         2.0
 442     };
 443     long nFails = 0;
 444     std::stringstream results;
 445
 446     for( auto z : fZooms )
 447     {
 448         long nBad = 0;
 449         long nDifferences = 0;
 450         for( long y = 0; y < 8; ++y )
 451         {
 452             for( long x = 0; x < 8; ++x )
 453             {
 454                 int nDiffs = testJoinsAt( pDocument, x, y, nTilePixelSize, nTileTwipSize * z );
 455                 if (nDiffs)
 456                     nBad++;
 457                 nDifferences += nDiffs;
 458             }
 459         }
 460         if (nBad > 0)
 461             results << "\tZoom " << z << " bad tiles: " << nBad << " with " << nDifferences << " mismatching pixels\n";
 462         nFails += nBad;
 463     }
 464
 465     if (nFails > 0)
 466         fprintf( stderr, "Failed %ld joins\n", nFails );
 467     else
 468         fprintf( stderr, "All joins compared correctly\n" );
 469
 470     fprintf(stderr, "%s\n", results.str().c_str());
 471
 472     return nFails;
 473 }
 474
 475 static std::atomic<bool> bDialogRendered(false);
 476 static std::atomic<int> nDialogId(-1);
 477
 478 static void kitCallback(int nType, const char* pPayload, void* pData)
 479 {
 480     Document *pDocument = static_cast<Document *>(pData);
 481
 482     if (nType != LOK_CALLBACK_WINDOW)
 483         return;
 484
 485     std::stringstream aStream(pPayload);
 486     boost::property_tree::ptree aRoot;
 487     boost::property_tree::read_json(aStream, aRoot);
 488     nDialogId = aRoot.get<unsigned>("id");
 489     const std::string aAction = aRoot.get<std::string>("action");
 490
 491     if (aAction != "created")
 492         return;
 493
 494     const std::string aType = aRoot.get<std::string>("type");
 495     const std::string aSize = aRoot.get<std::string>("size");
 496     int nWidth = atoi(aSize.c_str());
 497     int nHeight = 400;
 498     const char *pComma = strstr(aSize.c_str(), ", ");
 499     if (pComma)
 500         nHeight = atoi(pComma + 2);
 501     std::cerr << "Size " << aSize << " is " << nWidth << ", " << nHeight << "\n";
 502
 503     if (aType != "dialog")
 504         return;
 505
 506     aTimes.emplace_back(); // complete wait for dialog
 507
 508     unsigned char *pBuffer = new unsigned char[nWidth * nHeight * 4];
 509
 510     aTimes.emplace_back("render dialog");
 511     pDocument->paintWindow(nDialogId, pBuffer, 0, 0, nWidth, nHeight);
 512     dumpTile("dialog", nWidth, nHeight, pDocument->getTileMode(), pBuffer);
 513     aTimes.emplace_back();
 514
 515     delete[] pBuffer;
 516
 517     bDialogRendered = true;
 518 }
 519
 520 static void testDialog( Document *pDocument, const char *uno_cmd )
 521 {
 522     int view = pDocument->createView();
 523     pDocument->setView(view);
 524     pDocument->registerCallback(kitCallback, pDocument);
 525
 526     aTimes.emplace_back("open dialog");
 527     pDocument->postUnoCommand(uno_cmd, nullptr, true);
 528     aTimes.emplace_back();
 529
 530     aTimes.emplace_back("wait for dialog");
 531     while (!bDialogRendered)
 532     {
 533         usleep (1000);
 534     }
 535
 536     aTimes.emplace_back("post close dialog");
 537     pDocument->postWindow(nDialogId, LOK_WINDOW_CLOSE);
 538     aTimes.emplace_back();
 539
 540     pDocument->destroyView(view);
 541 }
 542
 543 static void documentCallback(const int type, const char* p, void*)
 544 {
 545     std::cerr << "Document callback " << type << ": " << (p ? p : "(null)") << "\n";
 546 }
 547
 548 // Avoid excessive dbgutil churn.
 549 static void ignoreCallback(const int /*type*/, const char* /*p*/, void* /*data*/)
 550 {
 551 }
 552
 553 int main( int argc, char* argv[] )
 554 {
 555     int arg = 2;
 556     origin = getTimeNow();
 557
 558 #ifndef IOS
 559     // avoid X oddness etc.
 560     unsetenv("DISPLAY");
 561
 562     if( argc < 4 ||
 563         ( argc > 1 && ( !strcmp( argv[1], "--help" ) || !strcmp( argv[1], "-h" ) ) ) )
 564         return help();
 565
 566     if ( argv[1][0] != '/' )
 567     {
 568         fprintf(stderr, "Absolute path required to libreoffice install\n");
 569         return 1;
 570     }
 571
 572     const char *doc_url = argv[arg++];
 573     const char *mode = argv[arg++];
 574
 575     bool pre_init = false;
 576     if (!strcmp(mode, "--preinit"))
 577     {
 578         pre_init = true;
 579         mode = argv[arg++];
 580     }
 581
 582     std::string user_url("file:///");
 583     user_url.append(argv[1]);
 584     user_url.append("../user");
 585
 586     if (pre_init)
 587     {
 588         aTimes.emplace_back("pre-initialization");
 589         setenv("LOK_ALLOWLIST_LANGUAGES", "en_US", 0);
 590         // coverity[tainted_string] - build time test tool
 591         lok_preinit(argv[1], user_url.c_str());
 592         aTimes.emplace_back();
 593     }
 594     const char *install_path = argv[1];
 595     const char *user_profile = user_url.c_str();
 596 #else
 597     const char *install_path = nullptr;
 598     const char *user_profile = nullptr;
 599     const char *doc_url = strdup([[[[[NSBundle mainBundle] bundleURL] absoluteString] stringByAppendingString:@"/test.odt"] UTF8String]);
 600     const char *mode = "--tile";
 601 #endif
 602
 603     aTimes.emplace_back("initialization");
 604     // coverity[tainted_string] - build time test tool
 605     std::unique_ptr<Office> pOffice( lok_cpp_init(install_path, user_profile) );
 606     if (pOffice == nullptr)
 607     {
 608         fprintf(stderr, "Failed to initialize Office from %s\n", argv[1]);
 609         return 1;
 610     }
 611     aTimes.emplace_back();
 612     pOffice->registerCallback(ignoreCallback, nullptr);
 613
 614     std::unique_ptr<Document> pDocument;
 615
 616     pOffice->setOptionalFeatures(LOK_FEATURE_NO_TILED_ANNOTATIONS);
 617
 618     aTimes.emplace_back("load document");
 619     if (doc_url != nullptr)
 620         pDocument.reset(pOffice->documentLoad(doc_url));
 621     aTimes.emplace_back();
 622
 623     if (pDocument)
 624     {
 625         pDocument->initializeForRendering("{\".uno:Author\":{\"type\":\"string\",\"value\":\"Local Host #0\"}}");
 626         pDocument->registerCallback(documentCallback, nullptr);
 627         if (!strcmp(mode, "--tile"))
 628         {
 629             const int max_parts = (argc > arg ? atoi(argv[arg++]) : -1);
 630             int max_tiles = (argc > arg ? atoi(argv[arg++]) : -1);
 631             const bool dump = true;
 632
 633             // coverity[tainted_data] - we trust the contents of this variable
 634             testTile (pDocument.get(), max_parts, max_tiles, dump);
 635         }
 636         else if (!strcmp(mode, "--join"))
 637         {
 638             return testJoin (pDocument.get());
 639         }
 640         else if (!strcmp (mode, "--dialog"))
 641         {
 642             const char *uno_cmd = argc > arg ? argv[arg++] : nullptr;
 643             if (!uno_cmd)
 644             {
 645                 switch (pDocument->getDocumentType())
 646                 {
 647                 case LOK_DOCTYPE_SPREADSHEET:
 648                     uno_cmd = ".uno:FormatCellDialog";
 649                     break;
 650                 case LOK_DOCTYPE_TEXT:
 651                 case LOK_DOCTYPE_PRESENTATION:
 652                 case LOK_DOCTYPE_DRAWING:
 653                 case LOK_DOCTYPE_OTHER:
 654                     return help("missing argument to --dialog and no default");
 655                 }
 656             }
 657             testDialog (pDocument.get(), uno_cmd);
 658         } else
 659             return help ("unknown parameter");
 660     }
 661
 662 #ifdef IOS
 663     Application::Quit();
 664 #endif
 665     aTimes.emplace_back("destroy document");
 666     pDocument.reset();
 667     aTimes.emplace_back();
 668
 669     pOffice.reset();
 670
 671     double nTotal = 0.0;
 672     fprintf (stderr, "profile run:\n");
 673     for (size_t i = 0; i < aTimes.size() - 1; i++)
 674     {
 675         const double nDelta = aTimes[i+1].mfTime - aTimes[i].mfTime;
 676         fprintf (stderr, "  %s - %2.4f(ms)\n", aTimes[i].mpName, nDelta * 1000.0);
 677         if (aTimes[i+1].mpName == nullptr)
 678             i++; // skip it.
 679         nTotal += nDelta;
 680     }
 681     fprintf (stderr, "Total: %2.4f(s)\n", nTotal);
 682     return 0;
 683 }
 684
 685 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */