int main() { p_srand(0); static int32_t x[MAXN], y[MAXN], w[MAXN]; int N = 1000, M = 10000, R = 100; init(N, R, x, y, w); int32_t hash = 0; for (int it = 0; it < M; it++) { Rect rect = rand_rect(R); int32_t ret = search_range(rect, x, y, w, N); hash ^= ret; tick(N, R, x, y, w); } printf("%" PRIi32 "\n", hash); return 0; }
static void make_rand_rgn(SkRegion* rgn, SkRandom& rand) { int count = rand.nextU() % 20; for (int i = 0; i < count; ++i) { rgn->op(rand_rect(rand, 100), SkRegion::kXOR_Op); } }
static void test_gatherpixelrefs(skiatest::Reporter* reporter) { const int IW = 8; const int IH = IW; const SkScalar W = SkIntToScalar(IW); const SkScalar H = W; static const int N = 4; SkBitmap bm[N]; SkPixelRef* refs[N]; const SkPoint pos[] = { { 0, 0 }, { W, 0 }, { 0, H }, { W, H } }; // Our convention is that the color components contain the index of their // corresponding bitmap/pixelref for (int i = 0; i < N; ++i) { make_bm(&bm[i], IW, IH, SkColorSetARGB(0xFF, i, i, i), true); refs[i] = bm[i].pixelRef(); } static const DrawBitmapProc procs[] = { drawbitmap_proc, drawbitmaprect_proc, drawshader_proc }; SkRandom rand; for (size_t k = 0; k < SK_ARRAY_COUNT(procs); ++k) { SkAutoTUnref<SkPicture> pic(record_bitmaps(bm, pos, N, procs[k])); REPORTER_ASSERT(reporter, pic->willPlayBackBitmaps() || N == 0); // quick check for a small piece of each quadrant, which should just // contain 1 bitmap. for (size_t i = 0; i < SK_ARRAY_COUNT(pos); ++i) { SkRect r; r.set(2, 2, W - 2, H - 2); r.offset(pos[i].fX, pos[i].fY); SkAutoDataUnref data(SkPictureUtils::GatherPixelRefs(pic, r)); REPORTER_ASSERT(reporter, data); if (data) { int count = static_cast<int>(data->size() / sizeof(SkPixelRef*)); REPORTER_ASSERT(reporter, 1 == count); REPORTER_ASSERT(reporter, *(SkPixelRef**)data->data() == refs[i]); } } // Test a bunch of random (mostly) rects, and compare the gather results // with a deduced list of refs by looking at the colors drawn. for (int j = 0; j < 100; ++j) { SkRect r; rand_rect(&r, rand, 2*W, 2*H); SkBitmap result; draw(pic, r, &result); SkTDArray<SkPixelRef*> array; SkData* data = SkPictureUtils::GatherPixelRefs(pic, r); size_t dataSize = data ? data->size() : 0; int gatherCount = static_cast<int>(dataSize / sizeof(SkPixelRef*)); SkASSERT(gatherCount * sizeof(SkPixelRef*) == dataSize); SkPixelRef** gatherRefs = data ? (SkPixelRef**)(data->data()) : NULL; SkAutoDataUnref adu(data); gather_from_colors(result, refs, N, &array); /* * GatherPixelRefs is conservative, so it can return more bitmaps * that we actually can see (usually because of conservative bounds * inflation for antialiasing). Thus our check here is only that * Gather didn't miss any that we actually saw. Even that isn't * a strict requirement on Gather, which is meant to be quick and * only mostly-correct, but at the moment this test should work. */ for (int i = 0; i < array.count(); ++i) { bool found = find(gatherRefs, array[i], gatherCount); REPORTER_ASSERT(reporter, found); #if 0 // enable this block of code to debug failures, as it will rerun // the case that failed. if (!found) { SkData* data = SkPictureUtils::GatherPixelRefs(pic, r); size_t dataSize = data ? data->size() : 0; } #endif } } } }