tests/SkpSkGrTest.cpp

   1 #if !SK_SUPPORT_GPU
   2 #error "GPU support required"
   3 #endif
   4
   5 #include "GrContext.h"
   6 #include "GrContextFactory.h"
   7 #include "GrRenderTarget.h"
   8 #include "SkGpuDevice.h"
   9 #include "gl/GrGLDefines.h"
  10
  11 #include "SkBitmap.h"
  12 #include "SkCanvas.h"
  13 #include "SkColor.h"
  14 #include "SkDevice.h"
  15 #include "SkGraphics.h"
  16 #include "SkImageDecoder.h"
  17 #include "SkImageEncoder.h"
  18 #include "SkOSFile.h"
  19 #include "SkPicture.h"
  20 #include "SkRTConf.h"
  21 #include "SkRunnable.h"
  22 #include "SkStream.h"
  23 #include "SkString.h"
  24 #include "SkTArray.h"
  25 #include "SkTDArray.h"
  26 #include "SkTaskGroup.h"
  27 #include "SkTime.h"
  28 #include "Test.h"
  29
  30 #ifdef SK_BUILD_FOR_WIN
  31     #define PATH_SLASH "\\"
  32     #define IN_DIR "D:\\9-30-13\\"
  33     #define OUT_DIR "D:\\skpSkGr\\11\\"
  34     #define LINE_FEED "\r\n"
  35 #else
  36     #define PATH_SLASH "/"
  37     #define IN_DIR "/usr/local/google/home/caryclark" PATH_SLASH "9-30-13-skp"
  38     #define OUT_DIR "/media/01CD75512A7F9EE0/4" PATH_SLASH
  39     #define LINE_FEED "\n"
  40 #endif
  41
  42 #define PATH_STR_SIZE 512
  43
  44 static const struct {
  45     int directory;
  46     const char* filename;
  47 } skipOverSkGr[] = {
  48     {1, "http___accuweather_com_.skp"},  // Couldn't convert bitmap to texture.http___absoku072_com_
  49 };
  50
  51 static const size_t skipOverSkGrCount = SK_ARRAY_COUNT(skipOverSkGr);
  52
  53 /////////////////////////////////////////
  54
  55 class SkpSkGrThreadedRunnable;
  56
  57 enum TestStep {
  58     kCompareBits,
  59     kEncodeFiles,
  60 };
  61
  62 enum {
  63     kMaxLength = 128,
  64     kMaxFiles = 128,
  65 };
  66
  67 struct TestResult {
  68     void init(int dirNo) {
  69         fDirNo = dirNo;
  70         sk_bzero(fFilename, sizeof(fFilename));
  71         fTestStep = kCompareBits;
  72         fScaleOversized = true;
  73     }
  74
  75     SkString status() {
  76         SkString outStr;
  77         outStr.printf("%s %d %d%s", fFilename, fPixelError, fTime, LINE_FEED);
  78         return outStr;
  79     }
  80
  81     static void Test(int dirNo, const char* filename, TestStep testStep, bool verbose) {
  82         TestResult test;
  83         test.init(dirNo);
  84         test.fTestStep = testStep;
  85         strcpy(test.fFilename, filename);
  86         test.testOne();
  87         if (verbose) {
  88             SkDebugf("%s", test.status().c_str());
  89         }
  90     }
  91
  92     void test(int dirNo, const SkString& filename) {
  93         init(dirNo);
  94         strcpy(fFilename, filename.c_str());
  95         testOne();
  96     }
  97
  98     void testOne();
  99
 100     char fFilename[kMaxLength];
 101     TestStep fTestStep;
 102     int fDirNo;
 103     int fPixelError;
 104     int fTime;
 105     bool fScaleOversized;
 106 };
 107
 108 struct SkpSkGrThreadState {
 109     void init(int dirNo) {
 110         fResult.init(dirNo);
 111         fFoundCount = 0;
 112         fSmallestError = 0;
 113         sk_bzero(fFilesFound, sizeof(fFilesFound));
 114         sk_bzero(fDirsFound, sizeof(fDirsFound));
 115         sk_bzero(fError, sizeof(fError));
 116     }
 117
 118     char fFilesFound[kMaxFiles][kMaxLength];
 119     int fDirsFound[kMaxFiles];
 120     int fError[kMaxFiles];
 121     int fFoundCount;
 122     int fSmallestError;
 123     skiatest::Reporter* fReporter;
 124     TestResult fResult;
 125 };
 126
 127 struct SkpSkGrThreadedTestRunner {
 128     SkpSkGrThreadedTestRunner(skiatest::Reporter* reporter)
 129         : fReporter(reporter) {
 130     }
 131
 132     ~SkpSkGrThreadedTestRunner();
 133     void render();
 134     SkTDArray<SkpSkGrThreadedRunnable*> fRunnables;
 135     skiatest::Reporter* fReporter;
 136 };
 137
 138 class SkpSkGrThreadedRunnable : public SkRunnable {
 139 public:
 140     SkpSkGrThreadedRunnable(void (*testFun)(SkpSkGrThreadState*), int dirNo, const char* str,
 141             SkpSkGrThreadedTestRunner* runner) {
 142         SkASSERT(strlen(str) < sizeof(fState.fResult.fFilename) - 1);
 143         fState.init(dirNo);
 144         strcpy(fState.fResult.fFilename, str);
 145         fState.fReporter = runner->fReporter;
 146         fTestFun = testFun;
 147     }
 148
 149     void run() override {
 150         SkGraphics::SetTLSFontCacheLimit(1 * 1024 * 1024);
 151         (*fTestFun)(&fState);
 152     }
 153
 154     SkpSkGrThreadState fState;
 155     void (*fTestFun)(SkpSkGrThreadState*);
 156 };
 157
 158 SkpSkGrThreadedTestRunner::~SkpSkGrThreadedTestRunner() {
 159     for (int index = 0; index < fRunnables.count(); index++) {
 160         SkDELETE(fRunnables[index]);
 161     }
 162 }
 163
 164 void SkpSkGrThreadedTestRunner::render() {
 165     SkTaskGroup tg;
 166     for (int index = 0; index < fRunnables.count(); ++ index) {
 167         tg.add(fRunnables[index]);
 168     }
 169 }
 170
 171 ////////////////////////////////////////////////
 172
 173 static const char outGrDir[] = OUT_DIR "grTest";
 174 static const char outSkDir[] = OUT_DIR "skTest";
 175 static const char outSkpDir[] = OUT_DIR "skpTest";
 176 static const char outDiffDir[] = OUT_DIR "outTest";
 177 static const char outStatusDir[] = OUT_DIR "statusTest";
 178
 179 static SkString make_filepath(int dirIndex, const char* dir, const char* name) {
 180     SkString path(dir);
 181     if (dirIndex) {
 182         path.appendf("%d", dirIndex);
 183     }
 184     path.append(PATH_SLASH);
 185     path.append(name);
 186     return path;
 187 }
 188
 189 static SkString make_in_dir_name(int dirIndex) {
 190     SkString dirName(IN_DIR);
 191     dirName.appendf("%d", dirIndex);
 192     if (!sk_exists(dirName.c_str())) {
 193         SkDebugf("could not read dir %s\n", dirName.c_str());
 194         return SkString();
 195     }
 196     return dirName;
 197 }
 198
 199 static bool make_out_dirs() {
 200     SkString outDir = make_filepath(0, OUT_DIR, "");
 201     if (!sk_exists(outDir.c_str())) {
 202         if (!sk_mkdir(outDir.c_str())) {
 203             SkDebugf("could not create dir %s\n", outDir.c_str());
 204             return false;
 205         }
 206     }
 207     SkString grDir = make_filepath(0, outGrDir, "");
 208     if (!sk_exists(grDir.c_str())) {
 209         if (!sk_mkdir(grDir.c_str())) {
 210             SkDebugf("could not create dir %s\n", grDir.c_str());
 211             return false;
 212         }
 213     }
 214     SkString skDir = make_filepath(0, outSkDir, "");
 215     if (!sk_exists(skDir.c_str())) {
 216         if (!sk_mkdir(skDir.c_str())) {
 217             SkDebugf("could not create dir %s\n", skDir.c_str());
 218             return false;
 219         }
 220     }
 221     SkString skpDir = make_filepath(0, outSkpDir, "");
 222     if (!sk_exists(skpDir.c_str())) {
 223         if (!sk_mkdir(skpDir.c_str())) {
 224             SkDebugf("could not create dir %s\n", skpDir.c_str());
 225             return false;
 226         }
 227     }
 228     SkString diffDir = make_filepath(0, outDiffDir, "");
 229     if (!sk_exists(diffDir.c_str())) {
 230         if (!sk_mkdir(diffDir.c_str())) {
 231             SkDebugf("could not create dir %s\n", diffDir.c_str());
 232             return false;
 233         }
 234     }
 235     SkString statusDir = make_filepath(0, outStatusDir, "");
 236     if (!sk_exists(statusDir.c_str())) {
 237         if (!sk_mkdir(statusDir.c_str())) {
 238             SkDebugf("could not create dir %s\n", statusDir.c_str());
 239             return false;
 240         }
 241     }
 242     return true;
 243 }
 244
 245 static SkString make_png_name(const char* filename) {
 246     SkString pngName = SkString(filename);
 247     pngName.remove(pngName.size() - 3, 3);
 248     pngName.append("png");
 249     return pngName;
 250 }
 251
 252 typedef GrContextFactory::GLContextType GLContextType;
 253 #ifdef SK_BUILD_FOR_WIN
 254 static const GLContextType kAngle = GrContextFactory::kANGLE_GLContextType;
 255 #else
 256 static const GLContextType kNative = GrContextFactory::kNative_GLContextType;
 257 #endif
 258
 259 static int similarBits(const SkBitmap& gr, const SkBitmap& sk) {
 260     const int kRowCount = 3;
 261     const int kThreshold = 3;
 262     int width = SkTMin(gr.width(), sk.width());
 263     if (width < kRowCount) {
 264         return true;
 265     }
 266     int height = SkTMin(gr.height(), sk.height());
 267     if (height < kRowCount) {
 268         return true;
 269     }
 270     int errorTotal = 0;
 271     SkTArray<char, true> errorRows;
 272     errorRows.push_back_n(width * kRowCount);
 273     SkAutoLockPixels autoGr(gr);
 274     SkAutoLockPixels autoSk(sk);
 275     char* base = &errorRows[0];
 276     for (int y = 0; y < height; ++y) {
 277         SkPMColor* grRow = gr.getAddr32(0, y);
 278         SkPMColor* skRow = sk.getAddr32(0, y);
 279         char* cOut = &errorRows[(y % kRowCount) * width];
 280         for (int x = 0; x < width; ++x) {
 281             SkPMColor grColor = grRow[x];
 282             SkPMColor skColor = skRow[x];
 283             int dr = SkGetPackedR32(grColor) - SkGetPackedR32(skColor);
 284             int dg = SkGetPackedG32(grColor) - SkGetPackedG32(skColor);
 285             int db = SkGetPackedB32(grColor) - SkGetPackedB32(skColor);
 286             int error = SkTMax(SkAbs32(dr), SkTMax(SkAbs32(dg), SkAbs32(db)));
 287             if ((cOut[x] = error >= kThreshold) && x >= 2
 288                     && base[x - 2] && base[width + x - 2] && base[width * 2 + x - 2]
 289                     && base[x - 1] && base[width + x - 1] && base[width * 2 + x - 1]
 290                     && base[x - 0] && base[width + x - 0] && base[width * 2 + x - 0]) {
 291                 errorTotal += error;
 292             }
 293         }
 294     }
 295     return errorTotal;
 296 }
 297
 298 static bool addError(SkpSkGrThreadState* data) {
 299     bool foundSmaller = false;
 300     int dCount = data->fFoundCount;
 301     int pixelError = data->fResult.fPixelError;
 302     if (data->fFoundCount < kMaxFiles) {
 303         data->fError[dCount] = pixelError;
 304         strcpy(data->fFilesFound[dCount], data->fResult.fFilename);
 305         data->fDirsFound[dCount] = data->fResult.fDirNo;
 306         ++data->fFoundCount;
 307     } else if (pixelError > data->fSmallestError) {
 308         int smallest = SK_MaxS32;
 309         int smallestIndex = 0;
 310         for (int index = 0; index < kMaxFiles; ++index) {
 311             if (smallest > data->fError[index]) {
 312                 smallest = data->fError[index];
 313                 smallestIndex = index;
 314             }
 315         }
 316         data->fError[smallestIndex] = pixelError;
 317         strcpy(data->fFilesFound[smallestIndex], data->fResult.fFilename);
 318         data->fDirsFound[smallestIndex] = data->fResult.fDirNo;
 319         data->fSmallestError = SK_MaxS32;
 320         for (int index = 0; index < kMaxFiles; ++index) {
 321             if (data->fSmallestError > data->fError[index]) {
 322                 data->fSmallestError = data->fError[index];
 323             }
 324         }
 325         SkDebugf("*%d*", data->fSmallestError);
 326         foundSmaller = true;
 327     }
 328     return foundSmaller;
 329 }
 330
 331 static SkMSec timePict(SkPicture* pic, SkCanvas* canvas) {
 332     canvas->save();
 333     int pWidth = pic->width();
 334     int pHeight = pic->height();
 335     const int maxDimension = 1000;
 336     const int slices = 3;
 337     int xInterval = SkTMax(pWidth - maxDimension, 0) / (slices - 1);
 338     int yInterval = SkTMax(pHeight - maxDimension, 0) / (slices - 1);
 339     SkRect rect = {0, 0, SkIntToScalar(SkTMin(maxDimension, pWidth)),
 340             SkIntToScalar(SkTMin(maxDimension, pHeight))};
 341     canvas->clipRect(rect);
 342     SkMSec start = SkTime::GetMSecs();
 343     for (int x = 0; x < slices; ++x) {
 344         for (int y = 0; y < slices; ++y) {
 345             pic->draw(canvas);
 346             canvas->translate(0, SkIntToScalar(yInterval));
 347         }
 348         canvas->translate(SkIntToScalar(xInterval), SkIntToScalar(-yInterval * slices));
 349     }
 350     SkMSec end = SkTime::GetMSecs();
 351     canvas->restore();
 352     return end - start;
 353 }
 354
 355 static void drawPict(SkPicture* pic, SkCanvas* canvas, int scale) {
 356     canvas->clear(SK_ColorWHITE);
 357     if (scale != 1) {
 358         canvas->save();
 359         canvas->scale(1.0f / scale, 1.0f / scale);
 360     }
 361     pic->draw(canvas);
 362     if (scale != 1) {
 363         canvas->restore();
 364     }
 365 }
 366
 367 static void writePict(const SkBitmap& bitmap, const char* outDir, const char* pngName) {
 368     SkString outFile = make_filepath(0, outDir, pngName);
 369     if (!SkImageEncoder::EncodeFile(outFile.c_str(), bitmap,
 370             SkImageEncoder::kPNG_Type, 100)) {
 371         SkDebugf("unable to encode gr %s (width=%d height=%d)br \n", pngName,
 372                     bitmap.width(), bitmap.height());
 373     }
 374 }
 375
 376 void TestResult::testOne() {
 377     SkPicture* pic = NULL;
 378     {
 379         SkString d;
 380         d.printf("    {%d, \"%s\"},", fDirNo, fFilename);
 381         SkString path = make_filepath(fDirNo, IN_DIR, fFilename);
 382         SkFILEStream stream(path.c_str());
 383         if (!stream.isValid()) {
 384             SkDebugf("invalid stream %s\n", path.c_str());
 385             goto finish;
 386         }
 387         if (fTestStep == kEncodeFiles) {
 388             size_t length = stream.getLength();
 389             SkTArray<char, true> bytes;
 390             bytes.push_back_n(length);
 391             stream.read(&bytes[0], length);
 392             stream.rewind();
 393             SkString wPath = make_filepath(0, outSkpDir, fFilename);
 394             SkFILEWStream wStream(wPath.c_str());
 395             wStream.write(&bytes[0], length);
 396             wStream.flush();
 397         }
 398         pic = SkPicture::CreateFromStream(&stream, &SkImageDecoder::DecodeMemory);
 399         if (!pic) {
 400             SkDebugf("unable to decode %s\n", fFilename);
 401             goto finish;
 402         }
 403         int pWidth = pic->width();
 404         int pHeight = pic->height();
 405         int pLargerWH = SkTMax(pWidth, pHeight);
 406         GrContextFactory contextFactory;
 407 #ifdef SK_BUILD_FOR_WIN
 408         GrContext* context = contextFactory.get(kAngle);
 409 #else
 410         GrContext* context = contextFactory.get(kNative);
 411 #endif
 412         if (NULL == context) {
 413             SkDebugf("unable to allocate context for %s\n", fFilename);
 414             goto finish;
 415         }
 416         int maxWH = context->getMaxRenderTargetSize();
 417         int scale = 1;
 418         while (pLargerWH / scale > maxWH) {
 419             scale *= 2;
 420         }
 421         SkBitmap bitmap;
 422         SkIPoint dim;
 423         do {
 424             dim.fX = (pWidth + scale - 1) / scale;
 425             dim.fY = (pHeight + scale - 1) / scale;
 426             bool success = bitmap.allocN32Pixels(dim.fX, dim.fY);
 427             if (success) {
 428                 break;
 429             }
 430             SkDebugf("-%d-", scale);
 431         } while ((scale *= 2) < 256);
 432         if (scale >= 256) {
 433             SkDebugf("unable to allocate bitmap for %s (w=%d h=%d) (sw=%d sh=%d)\n",
 434                     fFilename, pWidth, pHeight, dim.fX, dim.fY);
 435             goto finish;
 436         }
 437         SkCanvas skCanvas(bitmap);
 438         drawPict(pic, &skCanvas, fScaleOversized ? scale : 1);
 439         GrTextureDesc desc;
 440         desc.fConfig = kSkia8888_GrPixelConfig;
 441         desc.fFlags = kRenderTarget_GrTextureFlagBit;
 442         desc.fWidth = dim.fX;
 443         desc.fHeight = dim.fY;
 444         desc.fSampleCnt = 0;
 445         SkAutoTUnref<GrTexture> texture(context->createUncachedTexture(desc, NULL, 0));
 446         if (!texture) {
 447             SkDebugf("unable to allocate texture for %s (w=%d h=%d)\n", fFilename,
 448                 dim.fX, dim.fY);
 449             goto finish;
 450         }
 451         SkGpuDevice grDevice(context, texture.get());
 452         SkCanvas grCanvas(&grDevice);
 453         drawPict(pic, &grCanvas, fScaleOversized ? scale : 1);
 454
 455         SkBitmap grBitmap;
 456         grBitmap.allocPixels(grCanvas.imageInfo());
 457         grCanvas.readPixels(&grBitmap, 0, 0);
 458
 459         if (fTestStep == kCompareBits) {
 460             fPixelError = similarBits(grBitmap, bitmap);
 461             int skTime = timePict(pic, &skCanvas);
 462             int grTime = timePict(pic, &grCanvas);
 463             fTime = skTime - grTime;
 464         } else if (fTestStep == kEncodeFiles) {
 465             SkString pngStr = make_png_name(fFilename);
 466             const char* pngName = pngStr.c_str();
 467             writePict(grBitmap, outGrDir, pngName);
 468             writePict(bitmap, outSkDir, pngName);
 469         }
 470     }
 471 finish:
 472     SkDELETE(pic);
 473 }
 474
 475 static SkString makeStatusString(int dirNo) {
 476     SkString statName;
 477     statName.printf("stats%d.txt", dirNo);
 478     SkString statusFile = make_filepath(0, outStatusDir, statName.c_str());
 479     return statusFile;
 480 }
 481
 482 class PreParser {
 483 public:
 484     PreParser(int dirNo)
 485         : fDirNo(dirNo)
 486         , fIndex(0)
 487         , fStatusPath(makeStatusString(dirNo)) {
 488         if (!sk_exists(fStatusPath.c_str())) {
 489             return;
 490         }
 491         SkFILEStream reader;
 492         reader.setPath(fStatusPath.c_str());
 493         while (fetch(reader, &fResults.push_back()))
 494             ;
 495         fResults.pop_back();
 496     }
 497
 498     bool fetch(SkFILEStream& reader, TestResult* result) {
 499         char c;
 500         int i = 0;
 501         result->init(fDirNo);
 502         result->fPixelError = 0;
 503         result->fTime = 0;
 504         do {
 505             bool readOne = reader.read(&c, 1) != 0;
 506             if (!readOne) {
 507                 SkASSERT(i == 0);
 508                 return false;
 509             }
 510             if (c == ' ') {
 511                 result->fFilename[i++] = '\0';
 512                 break;
 513             }
 514             result->fFilename[i++] = c;
 515             SkASSERT(i < kMaxLength);
 516         } while (true);
 517         do {
 518             SkAssertResult(reader.read(&c, 1) != 0);
 519             if (c == ' ') {
 520                 break;
 521             }
 522             SkASSERT(c >= '0' && c <= '9');
 523             result->fPixelError = result->fPixelError * 10 + (c - '0');
 524         } while (true);
 525         bool minus = false;
 526         do {
 527             if (reader.read(&c, 1) == 0) {
 528                 break;
 529             }
 530             if (c == '\r' && reader.read(&c, 1) == 0) {
 531                 break;
 532             }
 533             if (c == '\n') {
 534                 break;
 535             }
 536             if (c == '-') {
 537                 minus = true;
 538                 continue;
 539             }
 540             SkASSERT(c >= '0' && c <= '9');
 541             result->fTime = result->fTime * 10 + (c - '0');
 542         } while (true);
 543         if (minus) {
 544             result->fTime = -result->fTime;
 545         }
 546         return true;
 547     }
 548
 549     bool match(const SkString& filename, SkFILEWStream* stream, TestResult* result) {
 550         if (fIndex < fResults.count()) {
 551             *result = fResults[fIndex++];
 552             SkASSERT(filename.equals(result->fFilename));
 553             SkString outStr(result->status());
 554             stream->write(outStr.c_str(), outStr.size());
 555             stream->flush();
 556             return true;
 557         }
 558         return false;
 559     }
 560
 561 private:
 562     int fDirNo;
 563     int fIndex;
 564     SkTArray<TestResult, true> fResults;
 565     SkString fStatusPath;
 566 };
 567
 568 static bool initTest() {
 569 #if !defined SK_BUILD_FOR_WIN && !defined SK_BUILD_FOR_MAC
 570     SK_CONF_SET("images.jpeg.suppressDecoderWarnings", true);
 571     SK_CONF_SET("images.png.suppressDecoderWarnings", true);
 572 #endif
 573     return make_out_dirs();
 574 }
 575
 576 DEF_TEST(SkpSkGr, reporter) {
 577     SkTArray<TestResult, true> errors;
 578     if (!initTest()) {
 579         return;
 580     }
 581     SkpSkGrThreadState state;
 582     state.init(0);
 583     int smallCount = 0;
 584     for (int dirNo = 1; dirNo <= 100; ++dirNo) {
 585         SkString pictDir = make_in_dir_name(dirNo);
 586         SkASSERT(pictDir.size());
 587         if (reporter->verbose()) {
 588             SkDebugf("dirNo=%d\n", dirNo);
 589         }
 590         SkOSFile::Iter iter(pictDir.c_str(), "skp");
 591         SkString filename;
 592         int testCount = 0;
 593         PreParser preParser(dirNo);
 594         SkFILEWStream statusStream(makeStatusString(dirNo).c_str());
 595         while (iter.next(&filename)) {
 596             for (size_t index = 0; index < skipOverSkGrCount; ++index) {
 597                 if (skipOverSkGr[index].directory == dirNo
 598                         && strcmp(filename.c_str(), skipOverSkGr[index].filename) == 0) {
 599                     goto skipOver;
 600                 }
 601             }
 602             if (preParser.match(filename, &statusStream, &state.fResult)) {
 603                 addError(&state);
 604                 ++testCount;
 605                 goto checkEarlyExit;
 606             }
 607             if (state.fSmallestError > 5000000) {
 608                 goto breakOut;
 609             }
 610             {
 611                 TestResult& result = state.fResult;
 612                 result.test(dirNo, filename);
 613                 SkString outStr(result.status());
 614                 statusStream.write(outStr.c_str(), outStr.size());
 615                 statusStream.flush();
 616                 if (1) {
 617                     SkDebugf("%s", outStr.c_str());
 618                 }
 619                 bool noMatch = addError(&state);
 620                 if (noMatch) {
 621                     smallCount = 0;
 622                 } else if (++smallCount > 10000) {
 623                     goto breakOut;
 624                 }
 625             }
 626             ++testCount;
 627             if (reporter->verbose()) {
 628                 if (testCount % 100 == 0) {
 629                     SkDebugf("#%d\n", testCount);
 630                 }
 631             }
 632      skipOver:
 633              reporter->bumpTestCount();
 634     checkEarlyExit:
 635             if (1 && testCount == 20) {
 636                 break;
 637             }
 638         }
 639     }
 640 breakOut:
 641     if (reporter->verbose()) {
 642         for (int index = 0; index < state.fFoundCount; ++index) {
 643             SkDebugf("%d %s %d\n", state.fDirsFound[index], state.fFilesFound[index],
 644                      state.fError[index]);
 645         }
 646     }
 647     for (int index = 0; index < state.fFoundCount; ++index) {
 648         TestResult::Test(state.fDirsFound[index], state.fFilesFound[index], kEncodeFiles,
 649                 reporter->verbose());
 650         if (reporter->verbose()) SkDebugf("+");
 651     }
 652 }
 653
 654 static void bumpCount(skiatest::Reporter* reporter, bool skipping) {
 655     if (reporter->verbose()) {
 656         static int threadTestCount;
 657         sk_atomic_inc(&threadTestCount);
 658         if (!skipping && threadTestCount % 100 == 0) {
 659             SkDebugf("#%d\n", threadTestCount);
 660         }
 661         if (skipping && threadTestCount % 10000 == 0) {
 662             SkDebugf("#%d\n", threadTestCount);
 663         }
 664     }
 665 }
 666
 667 static void testSkGrMain(SkpSkGrThreadState* data) {
 668     data->fResult.testOne();
 669     bumpCount(data->fReporter, false);
 670     data->fReporter->bumpTestCount();
 671 }
 672
 673 DEF_TEST(SkpSkGrThreaded, reporter) {
 674     if (!initTest()) {
 675         return;
 676     }
 677     SkpSkGrThreadedTestRunner testRunner(reporter);
 678     for (int dirIndex = 1; dirIndex <= 100; ++dirIndex) {
 679         SkString pictDir = make_in_dir_name(dirIndex);
 680         if (pictDir.size() == 0) {
 681             continue;
 682         }
 683         SkOSFile::Iter iter(pictDir.c_str(), "skp");
 684         SkString filename;
 685         while (iter.next(&filename)) {
 686             SkString pngName = make_png_name(filename.c_str());
 687             SkString oldPng = make_filepath(dirIndex, outSkDir, pngName.c_str());
 688             SkString newPng = make_filepath(dirIndex, outGrDir, pngName.c_str());
 689             if (sk_exists(oldPng.c_str()) && sk_exists(newPng.c_str())) {
 690                 bumpCount(reporter, true);
 691                 continue;
 692             }
 693             for (size_t index = 0; index < skipOverSkGrCount; ++index) {
 694                 if (skipOverSkGr[index].directory == dirIndex
 695                         && strcmp(filename.c_str(), skipOverSkGr[index].filename) == 0) {
 696                     bumpCount(reporter, true);
 697                     goto skipOver;
 698                 }
 699             }
 700             *testRunner.fRunnables.append() = SkNEW_ARGS(SkpSkGrThreadedRunnable,
 701                     (&testSkGrMain, dirIndex, filename.c_str(), &testRunner));
 702     skipOver:
 703             ;
 704         }
 705     }
 706     testRunner.render();
 707     SkpSkGrThreadState& max = testRunner.fRunnables[0]->fState;
 708     for (int dirIndex = 2; dirIndex <= 100; ++dirIndex) {
 709         SkpSkGrThreadState& state = testRunner.fRunnables[dirIndex - 1]->fState;
 710         for (int index = 0; index < state.fFoundCount; ++index) {
 711             int maxIdx = max.fFoundCount;
 712             if (maxIdx < kMaxFiles) {
 713                 max.fError[maxIdx] = state.fError[index];
 714                 strcpy(max.fFilesFound[maxIdx], state.fFilesFound[index]);
 715                 max.fDirsFound[maxIdx] = state.fDirsFound[index];
 716                 ++max.fFoundCount;
 717                 continue;
 718             }
 719             for (maxIdx = 0; maxIdx < max.fFoundCount; ++maxIdx) {
 720                 if (max.fError[maxIdx] < state.fError[index]) {
 721                     max.fError[maxIdx] = state.fError[index];
 722                     strcpy(max.fFilesFound[maxIdx], state.fFilesFound[index]);
 723                     max.fDirsFound[maxIdx] = state.fDirsFound[index];
 724                     break;
 725                 }
 726             }
 727         }
 728     }
 729     TestResult encoder;
 730     encoder.fTestStep = kEncodeFiles;
 731     for (int index = 0; index < max.fFoundCount; ++index) {
 732         encoder.fDirNo = max.fDirsFound[index];
 733         strcpy(encoder.fFilename, max.fFilesFound[index]);
 734         encoder.testOne();
 735         SkDebugf("+");
 736     }
 737 }
 738
 739 DEF_TEST(SkpSkGrOneOff, reporter) {
 740     if (!initTest()) {
 741         return;
 742     }
 743     int testIndex = 166;
 744     int dirIndex = skipOverSkGr[testIndex - 166].directory;
 745     SkString pictDir = make_in_dir_name(dirIndex);
 746     if (pictDir.size() == 0) {
 747         return;
 748     }
 749     SkString filename(skipOverSkGr[testIndex - 166].filename);
 750     TestResult::Test(dirIndex, filename.c_str(), kCompareBits, reporter->verbose());
 751     TestResult::Test(dirIndex, filename.c_str(), kEncodeFiles, reporter->verbose());
 752 }