| Index: skia/sgl/SkGraphics.cpp
|
| ===================================================================
|
| --- skia/sgl/SkGraphics.cpp (revision 16859)
|
| +++ skia/sgl/SkGraphics.cpp (working copy)
|
| @@ -1,528 +0,0 @@
|
| -/* libs/graphics/sgl/SkGraphics.cpp
|
| -**
|
| -** Copyright 2006, The Android Open Source Project
|
| -**
|
| -** Licensed under the Apache License, Version 2.0 (the "License");
|
| -** you may not use this file except in compliance with the License.
|
| -** You may obtain a copy of the License at
|
| -**
|
| -** http://www.apache.org/licenses/LICENSE-2.0
|
| -**
|
| -** Unless required by applicable law or agreed to in writing, software
|
| -** distributed under the License is distributed on an "AS IS" BASIS,
|
| -** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
| -** See the License for the specific language governing permissions and
|
| -** limitations under the License.
|
| -*/
|
| -
|
| -#include "SkGraphics.h"
|
| -
|
| -#include "Sk64.h"
|
| -#include "SkBlitter.h"
|
| -#include "SkCanvas.h"
|
| -#include "SkDOM.h"
|
| -#include "SkFloat.h"
|
| -#include "SkGeometry.h"
|
| -#include "SkGlobals.h"
|
| -#include "SkMath.h"
|
| -#include "SkMatrix.h"
|
| -#include "SkPath.h"
|
| -#include "SkPathEffect.h"
|
| -#include "SkPathMeasure.h"
|
| -#include "SkRandom.h"
|
| -#include "SkRefCnt.h"
|
| -#include "SkScalerContext.h"
|
| -#include "SkShader.h"
|
| -#include "SkStream.h"
|
| -#include "SkTSearch.h"
|
| -#include "SkTime.h"
|
| -#include "SkUtils.h"
|
| -#include "SkXfermode.h"
|
| -
|
| -#if 0
|
| -
|
| -#define SK_SORT_TEMPLATE_TYPE int
|
| -#define SK_SORT_TEMPLATE_NAME sort_int
|
| -#define SK_SORT_TEMPLATE_CMP(a, b) ((a) - (b))
|
| -#include "SkSortTemplate.h"
|
| -
|
| -#define SK_SORT_TEMPLATE_TYPE int*
|
| -#define SK_SORT_TEMPLATE_NAME sort_intptr
|
| -#define SK_SORT_TEMPLATE_CMP(a, b) (*(a) - *(b))
|
| -#include "SkSortTemplate.h"
|
| -
|
| -static void test_sort()
|
| -{
|
| - int array[] = { 4, 3, 7, 5, 2, 5, 1, 2, 9, 6, 7, 4, 5, 3, 1, 0 };
|
| - int* ptr[SK_ARRAY_COUNT(array)];
|
| - int i, N = SK_ARRAY_COUNT(array) - 1;
|
| -
|
| - for (i = 0; i < N; i++)
|
| - printf(" %d", array[i]);
|
| - printf("\n");
|
| -
|
| - for (i = 0; i < N; i++)
|
| - ptr[i] = &array[i];
|
| - sort_intptr(ptr, N);
|
| - for (i = 0; i < N; i++)
|
| - printf(" %d", *ptr[i]);
|
| - printf("\n");
|
| -
|
| - sort_int(array, N);
|
| - for (i = 0; i < N; i++)
|
| - printf(" %d", array[i]);
|
| - printf("\n");
|
| -
|
| -}
|
| -#endif
|
| -
|
| -#define SPEED_TESTx
|
| -
|
| -#define typesizeline(type) { #type , sizeof(type) }
|
| -#define unittestline(type) { #type , type::UnitTest }
|
| -
|
| -
|
| -#ifdef BUILD_EMBOSS_TABLE
|
| - extern void SkEmbossMask_BuildTable();
|
| -#endif
|
| -
|
| -#ifdef BUILD_RADIALGRADIENT_TABLE
|
| - extern void SkRadialGradient_BuildTable();
|
| -#endif
|
| -
|
| -#define BIG_LOOP_COUNT 1000000
|
| -#define TEXT_LOOP_COUNT 1000
|
| -
|
| -#ifdef SPEED_TEST
|
| -static int test_s64(int i)
|
| -{
|
| - Sk64 a, b, c;
|
| -
|
| - c.set(0);
|
| - a.set(i);
|
| - b.setMul(i, i);
|
| - a.add(b);
|
| - a.add(c);
|
| - return c.getFixed();
|
| -}
|
| -
|
| -static int test_native_64(int i)
|
| -{
|
| - int16_t a, b, c;
|
| -
|
| - c = 0;
|
| - a = i;
|
| - b = (int64_t)i * i;
|
| - a += b;
|
| - a += c;
|
| - return (int)(c >> 16);
|
| -}
|
| -
|
| -static void test_drawText(SkBitmap::Config config, SkColor color)
|
| -{
|
| - SkBitmap bm;
|
| -
|
| - bm.setConfig(config, 320, 240);
|
| - bm.allocPixels();
|
| -
|
| - SkCanvas canvas(bm);
|
| - SkPaint paint;
|
| -
|
| - paint.setAntiAlias(true);
|
| - paint.setTextSize(SkIntToScalar(12));
|
| - paint.setColor(color);
|
| -
|
| - SkScalar x = SkIntToScalar(20);
|
| - SkScalar y = SkIntToScalar(100);
|
| - const char* text = "Hamburgefons";
|
| - size_t len = strlen(text);
|
| -
|
| - // draw once to populate the cache
|
| - canvas.drawText(text, len, x, y, paint);
|
| -
|
| - SkMSec now = SkTime::GetMSecs();
|
| - for (int i = 0; i < TEXT_LOOP_COUNT; i++)
|
| - canvas.drawText(text, len, x, y, paint);
|
| - printf("----------- Config: %d, Color=%x, CPS = %g\n", config, color,
|
| - len * TEXT_LOOP_COUNT * 1000.0 / (SkTime::GetMSecs() - now));
|
| -}
|
| -
|
| -#endif
|
| -
|
| -#include "SkFloatBits.h"
|
| -
|
| -static inline float fast_inc(float x) {
|
| - SkFloatIntUnion data;
|
| - data.fFloat = x;
|
| - data.fSignBitInt += 1;
|
| - return data.fFloat;
|
| -}
|
| -
|
| -extern float dummy();
|
| -int time_math() {
|
| - SkMSec now;
|
| - int i;
|
| - int sum = 0;
|
| - const int repeat = 1000000;
|
| - float f;
|
| -
|
| - f = dummy();
|
| - now = SkTime::GetMSecs();
|
| - for (i = repeat - 1; i >= 0; --i) {
|
| - sum += (int)f; f = fast_inc(f);
|
| - sum += (int)f; f = fast_inc(f);
|
| - sum += (int)f; f = fast_inc(f);
|
| - sum += (int)f; f = fast_inc(f);
|
| - }
|
| - SkDebugf("---- native cast %d\n", SkTime::GetMSecs() - now);
|
| -
|
| - f = dummy();
|
| - now = SkTime::GetMSecs();
|
| - for (i = repeat - 1; i >= 0; --i) {
|
| - sum += SkFloatToIntCast(f); f = fast_inc(f);
|
| - sum += SkFloatToIntCast(f); f = fast_inc(f);
|
| - sum += SkFloatToIntCast(f); f = fast_inc(f);
|
| - sum += SkFloatToIntCast(f); f = fast_inc(f);
|
| - }
|
| - SkDebugf("---- hack cast %d\n", SkTime::GetMSecs() - now);
|
| -
|
| - f = dummy();
|
| - now = SkTime::GetMSecs();
|
| - for (i = repeat - 1; i >= 0; --i) {
|
| - sum += (int)floorf(f + 0.5f); f = fast_inc(f);
|
| - sum += (int)floorf(f + 0.5f); f = fast_inc(f);
|
| - sum += (int)floorf(f + 0.5f); f = fast_inc(f);
|
| - sum += (int)floorf(f + 0.5f); f = fast_inc(f);
|
| - }
|
| - SkDebugf("---- native round %d\n", SkTime::GetMSecs() - now);
|
| -
|
| - f = dummy();
|
| - now = SkTime::GetMSecs();
|
| - for (i = repeat - 1; i >= 0; --i) {
|
| - sum += SkFloatToIntRound(f); f = fast_inc(f);
|
| - sum += SkFloatToIntRound(f); f = fast_inc(f);
|
| - sum += SkFloatToIntRound(f); f = fast_inc(f);
|
| - sum += SkFloatToIntRound(f); f = fast_inc(f);
|
| - }
|
| - SkDebugf("---- hack round %d\n", SkTime::GetMSecs() - now);
|
| -
|
| - f = dummy();
|
| - now = SkTime::GetMSecs();
|
| - for (i = repeat - 1; i >= 0; --i) {
|
| - sum += SkFloat2Bits(floorf(f)); f = fast_inc(f);
|
| - sum += SkFloat2Bits(floorf(f)); f = fast_inc(f);
|
| - sum += SkFloat2Bits(floorf(f)); f = fast_inc(f);
|
| - sum += SkFloat2Bits(floorf(f)); f = fast_inc(f);
|
| - }
|
| - SkDebugf("---- native floor %d\n", SkTime::GetMSecs() - now);
|
| -
|
| - f = dummy();
|
| - now = SkTime::GetMSecs();
|
| - for (i = repeat - 1; i >= 0; --i) {
|
| - sum += SkFloatToIntFloor(f); f = fast_inc(f);
|
| - sum += SkFloatToIntFloor(f); f = fast_inc(f);
|
| - sum += SkFloatToIntFloor(f); f = fast_inc(f);
|
| - sum += SkFloatToIntFloor(f); f = fast_inc(f);
|
| - }
|
| - SkDebugf("---- hack floor %d\n", SkTime::GetMSecs() - now);
|
| -
|
| - return sum;
|
| -}
|
| -
|
| -static float time_intToFloat() {
|
| - const int repeat = 1000000;
|
| - int i, n;
|
| - SkMSec now;
|
| - float sum = 0;
|
| -
|
| - n = (int)dummy();
|
| - now = SkTime::GetMSecs();
|
| - for (i = repeat - 1; i >= 0; --i) {
|
| - sum += (float)n; n += 1;
|
| - sum += (float)n; n += 1;
|
| - sum += (float)n; n += 1;
|
| - sum += (float)n; n += 1;
|
| - }
|
| - SkDebugf("---- native i2f %d\n", SkTime::GetMSecs() - now);
|
| -
|
| - n = (int)dummy();
|
| - now = SkTime::GetMSecs();
|
| - for (i = repeat - 1; i >= 0; --i) {
|
| - sum += SkIntToFloatCast(n); n += 1;
|
| - sum += SkIntToFloatCast(n); n += 1;
|
| - sum += SkIntToFloatCast(n); n += 1;
|
| - sum += SkIntToFloatCast(n); n += 1;
|
| - }
|
| - SkDebugf("---- check i2f %d\n", SkTime::GetMSecs() - now);
|
| -
|
| - n = (int)dummy();
|
| - now = SkTime::GetMSecs();
|
| - for (i = repeat - 1; i >= 0; --i) {
|
| - sum += SkIntToFloatCast_NoOverflowCheck(n); n += 1;
|
| - sum += SkIntToFloatCast_NoOverflowCheck(n); n += 1;
|
| - sum += SkIntToFloatCast_NoOverflowCheck(n); n += 1;
|
| - sum += SkIntToFloatCast_NoOverflowCheck(n); n += 1;
|
| - }
|
| - SkDebugf("---- nocheck i2f %d\n", SkTime::GetMSecs() - now);
|
| -
|
| - return sum;
|
| -}
|
| -
|
| -void SkGraphics::Init(bool runUnitTests)
|
| -{
|
| - SkGlobals::Init();
|
| -
|
| -// time_math();
|
| -// time_intToFloat();
|
| -
|
| -#ifdef BUILD_EMBOSS_TABLE
|
| - SkEmbossMask_BuildTable();
|
| -#endif
|
| -#ifdef BUILD_RADIALGRADIENT_TABLE
|
| - SkRadialGradient_BuildTable();
|
| -#endif
|
| -
|
| -#ifdef SK_SUPPORT_UNITTEST
|
| - if (runUnitTests == false)
|
| - return;
|
| - int i;
|
| -
|
| - static const struct {
|
| - const char* fTypeName;
|
| - size_t fSizeOf;
|
| - } gTypeSize[] = {
|
| - typesizeline(char),
|
| - typesizeline(short),
|
| - typesizeline(int),
|
| - typesizeline(long),
|
| - typesizeline(size_t),
|
| - typesizeline(void*),
|
| -
|
| - typesizeline(S8CPU),
|
| - typesizeline(U8CPU),
|
| - typesizeline(S16CPU),
|
| - typesizeline(U16CPU),
|
| -
|
| - typesizeline(SkPoint),
|
| - typesizeline(SkRect),
|
| - typesizeline(SkMatrix),
|
| - typesizeline(SkPath),
|
| - typesizeline(SkGlyph),
|
| - typesizeline(SkRefCnt),
|
| -
|
| - typesizeline(SkPaint),
|
| - typesizeline(SkCanvas),
|
| - typesizeline(SkBlitter),
|
| - typesizeline(SkShader),
|
| - typesizeline(SkXfermode),
|
| - typesizeline(SkPathEffect)
|
| - };
|
| -
|
| -#ifdef SK_CPU_BENDIAN
|
| - SkDebugf("SkGraphics: big-endian\n");
|
| -#else
|
| - SkDebugf("SkGraphics: little-endian\n");
|
| -#endif
|
| -
|
| - {
|
| - char test = 0xFF;
|
| - int itest = test; // promote to int, see if it sign-extended
|
| - if (itest < 0)
|
| - SkDebugf("SkGraphics: char is signed\n");
|
| - else
|
| - SkDebugf("SkGraphics: char is unsigned\n");
|
| - }
|
| - for (i = 0; i < (int)SK_ARRAY_COUNT(gTypeSize); i++)
|
| - SkDebugf("SkGraphics: sizeof(%s) = %d\n", gTypeSize[i].fTypeName, gTypeSize[i].fSizeOf);
|
| -
|
| - static const struct {
|
| - const char* fTypeName;
|
| - void (*fUnitTest)();
|
| - } gUnitTests[] = {
|
| - unittestline(Sk64),
|
| - unittestline(SkMath),
|
| - unittestline(SkUtils),
|
| - unittestline(SkString),
|
| - unittestline(SkMatrix),
|
| - unittestline(SkGeometry),
|
| - unittestline(SkPath),
|
| - unittestline(SkPathMeasure),
|
| - unittestline(SkStream),
|
| - unittestline(SkWStream),
|
| - };
|
| -
|
| - for (i = 0; i < (int)SK_ARRAY_COUNT(gUnitTests); i++)
|
| - {
|
| - SkDebugf("SkGraphics: Running UnitTest for %s\n", gUnitTests[i].fTypeName);
|
| - gUnitTests[i].fUnitTest();
|
| - SkDebugf("SkGraphics: End UnitTest for %s\n", gUnitTests[i].fTypeName);
|
| - }
|
| - SkQSort_UnitTest();
|
| -
|
| -#endif
|
| -
|
| - if (false) // test asm fixmul
|
| - {
|
| - int j;
|
| - SkMSec now = SkTime::GetMSecs();
|
| - for (j = 0; j < BIG_LOOP_COUNT; j++) {
|
| - (void)SkFixedMul_portable(0x8000, 0x150000);
|
| - }
|
| - SkMSec now2 = SkTime::GetMSecs();
|
| - printf("-------- SkFixedMul_portable = %d\n", now2 - now);
|
| -
|
| - for (j = 0; j < BIG_LOOP_COUNT; j++) {
|
| - (void)SkFixedMul(0x8000, 0x150000);
|
| - }
|
| - printf("-------- SkFixedMul = %d\n", SkTime::GetMSecs() - now2);
|
| -
|
| - SkRandom rand;
|
| - for (j = 0; j < 10000; j++) {
|
| - SkFixed a = rand.nextS() >> 8;
|
| - SkFixed b = rand.nextS() >> 8;
|
| - SkFixed c1 = SkFixedMul_portable(a, b);
|
| - SkFixed c2 = SkFixedMul(a, b);
|
| - if (SkAbs32(c1 - c2) > 1)
|
| - printf("------ FixMul disagreement: (%x %x) slow=%x fast=%x\n", a, b, c1, c2);
|
| - }
|
| - }
|
| -
|
| - if (false) // test asm fractmul
|
| - {
|
| - int j;
|
| - SkMSec now = SkTime::GetMSecs();
|
| - for (j = 0; j < BIG_LOOP_COUNT; j++) {
|
| - (void)SkFractMul_portable(0x800000, 0x1500000);
|
| - }
|
| - SkMSec now2 = SkTime::GetMSecs();
|
| - printf("-------- SkFractMul_portable = %d\n", now2 - now);
|
| -
|
| - for (j = 0; j < BIG_LOOP_COUNT; j++) {
|
| - (void)SkFractMul(0x800000, 0x1500000);
|
| - }
|
| - printf("-------- SkFractMul = %d\n", SkTime::GetMSecs() - now2);
|
| -
|
| - SkRandom rand;
|
| - for (j = 0; j < 10000; j++) {
|
| - SkFixed a = rand.nextS() >> 1;
|
| - SkFixed b = rand.nextS() >> 1;
|
| - SkFixed c1 = SkFractMul_portable(a, b);
|
| - SkFixed c2 = SkFractMul(a, b);
|
| - if (SkAbs32(c1 - c2) > 1)
|
| - printf("------ FractMul disagreement: (%x %x) slow=%x fast=%x\n", a, b, c1, c2);
|
| - }
|
| - }
|
| -
|
| - if (false) // test asm clz
|
| - {
|
| - int j;
|
| - SkMSec now = SkTime::GetMSecs();
|
| - for (j = 0; j < BIG_LOOP_COUNT; j++) {
|
| - (void)SkCLZ_portable(now);
|
| - }
|
| - SkMSec now2 = SkTime::GetMSecs();
|
| - printf("-------- SkCLZ_portable = %d\n", now2 - now);
|
| -
|
| - for (j = 0; j < BIG_LOOP_COUNT; j++) {
|
| - (void)SkCLZ(now);
|
| - }
|
| - printf("-------- SkCLZ = %d\n", SkTime::GetMSecs() - now2);
|
| -
|
| - SkRandom rand;
|
| - for (j = 0; j < 10000; j++) {
|
| - uint32_t a = rand.nextU();
|
| - int c1 = SkCLZ_portable(a);
|
| - int c2 = SkCLZ(a);
|
| - if (c1 != c2)
|
| - printf("------ CLZ disagreement: (%x) slow=%x fast=%x\n", a, c1, c2);
|
| - }
|
| - }
|
| -
|
| -#ifdef SPEED_TEST
|
| - if (false) {
|
| - int i;
|
| - int (*proc)(int);
|
| -
|
| - static const struct {
|
| - int (*proc)(int);
|
| - const char* name;
|
| - } gList[] = {
|
| - { test_s64, "Sk64" },
|
| - { test_native_64, "native" }
|
| - };
|
| -
|
| - for (size_t j = 0; j < SK_ARRAY_COUNT(gList); j++) {
|
| - SkMSec now = SkTime::GetMSecs();
|
| - proc = gList[j].proc;
|
| - for (i = 0; i < BIG_LOOP_COUNT; i++) {
|
| - proc(i);
|
| - }
|
| - printf("-------- %s = %d\n", gList[j].name, SkTime::GetMSecs() - now);
|
| - }
|
| - }
|
| -#endif
|
| -
|
| - if (false) {
|
| - size_t i, size = 480;
|
| - char* buffer = (char*)sk_malloc_throw(size);
|
| - uint16_t* buffer16 = (uint16_t*)buffer;
|
| - uint32_t* buffer32 = (uint32_t*)buffer;
|
| -
|
| - SkMSec now = SkTime::GetMSecs();
|
| - for (i = 0; i < 100000; i++) {
|
| - sk_memset16(buffer16, (uint16_t)i, size >> 1);
|
| - }
|
| - SkMSec now2 = SkTime::GetMSecs();
|
| - for (i = 0; i < 100000; i++) {
|
| - sk_memset16_portable(buffer16, (uint16_t)i, size >> 1);
|
| - }
|
| - SkMSec now3 = SkTime::GetMSecs();
|
| - printf("----------- memset16: native %d, portable %d\n", now2 - now, now3 - now2);
|
| -
|
| - now = SkTime::GetMSecs();
|
| - for (i = 0; i < 100000; i++) {
|
| - sk_memset32(buffer32, i, size >> 2);
|
| - }
|
| - now2 = SkTime::GetMSecs();
|
| - for (i = 0; i < 100000; i++) {
|
| - sk_memset32_portable(buffer32, i, size >> 2);
|
| - }
|
| - now3 = SkTime::GetMSecs();
|
| - printf("----------- memset32: native %d, portable %d\n", now2 - now, now3 - now2);
|
| -
|
| - sk_free(buffer);
|
| - }
|
| -
|
| -#ifdef SPEED_TEST
|
| - if (false) {
|
| - test_drawText(SkBitmap::kARGB_8888_Config, SK_ColorBLACK);
|
| - test_drawText(SkBitmap::kARGB_8888_Config, SK_ColorRED);
|
| - test_drawText(SkBitmap::kRGB_565_Config, SK_ColorBLACK);
|
| - test_drawText(SkBitmap::kRGB_565_Config, SK_ColorRED);
|
| - }
|
| -#endif
|
| -
|
| -// if (true) {
|
| -// test_sort();
|
| -// }
|
| -}
|
| -
|
| -////////////////////////////////////////////////////////////////////////////
|
| -
|
| -#include "SkGlyphCache.h"
|
| -#include "SkImageDecoder.h"
|
| -
|
| -void SkGraphics::Term() {
|
| - SkGraphics::SetFontCacheUsed(0);
|
| - SkGlobals::Term();
|
| -}
|
| -
|
| -size_t SkGraphics::GetFontCacheUsed() {
|
| - return SkGlyphCache::GetCacheUsed();
|
| -}
|
| -
|
| -bool SkGraphics::SetFontCacheUsed(size_t usageInBytes) {
|
| - return SkGlyphCache::SetCacheUsed(usageInBytes);
|
| -}
|
| -
|
| -float dummy() { return 1.25f; }
|
|
|