'include_dirs': [
'config/win',
],
+ 'sources!': [
+ '../include/core/SkMMapStream.h',
+ '../src/core/SkMMapStream.cpp',
+ ],
}],
[ 'skia_os in ("android", "nacl")', {
'dependencies': [
'<(skia_src_path)/core/SkMath.cpp',
'<(skia_src_path)/core/SkMatrix.cpp',
'<(skia_src_path)/core/SkMetaData.cpp',
+ '<(skia_src_path)/core/SkMMapStream.cpp',
'<(skia_src_path)/core/SkOrderedReadBuffer.cpp',
'<(skia_src_path)/core/SkOrderedWriteBuffer.cpp',
'<(skia_src_path)/core/SkPackBits.cpp',
*/
static SkData* NewFromMalloc(const void* data, size_t length);
- /**
- * Create a new dataref from a pointer allocated by mmap. The Data object
- * will handle calling munmap().
- */
- static SkData* NewFromMMap(const void* data, size_t length);
-
/**
* Create a new dataref using a subset of the data in the specified
* src dataref.
--- /dev/null
+
+/*
+ * Copyright 2008 The Android Open Source Project
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+
+#ifndef SkMMapStream_DEFINED
+#define SkMMapStream_DEFINED
+
+#include "SkStream.h"
+
+class SkMMAPStream : public SkMemoryStream {
+public:
+ SkMMAPStream(const char filename[]);
+ virtual ~SkMMAPStream();
+
+ virtual void setMemory(const void* data, size_t length, bool);
+private:
+ void* fAddr;
+ size_t fSize;
+
+ void closeMMap();
+
+ typedef SkMemoryStream INHERITED;
+};
+
+#endif
//////////////////////////////////////////////////////////////////////
-#ifndef SK_MMAP_SUPPORT
- #ifdef SK_BUILD_FOR_WIN32
- // by default, if we're windows, we assume we don't have mmap
- #define SK_MMAP_SUPPORT 0
- #else
- #define SK_MMAP_SUPPORT 1
- #endif
-#endif
-
-//////////////////////////////////////////////////////////////////////
-
/**
* SK_CPU_SSE_LEVEL
*
class SK_API SkStream : public SkRefCnt {
public:
- /**
- * Attempts to open the specified file, and return a stream to it (using
- * mmap if available). On success, the caller must call unref() on the
- * returned object. On failure, returns NULL.
- */
- static SkStream* NewFromFile(const char path[]);
-
SK_DECLARE_INST_COUNT(SkStream)
/** Called to rewind to the beginning of the stream. If this cannot be
#include "SkData.h"
#include "SkFlattenableBuffers.h"
-#if SK_MMAP_SUPPORT
- #include <unistd.h>
- #include <sys/mman.h>
- #include <fcntl.h>
- #include <errno.h>
-#endif
-
SK_DEFINE_INST_COUNT(SkData)
SkData::SkData(const void* ptr, size_t size, ReleaseProc proc, void* context) {
return NewWithCopy(cstr, size);
}
-#if SK_MMAP_SUPPORT
-static void sk_munmap_releaseproc(const void* addr, size_t length, void*) {
- munmap(const_cast<void*>(addr), length);
-}
-
-SkData* SkData::NewFromMMap(const void* addr, size_t length) {
- return SkNEW_ARGS(SkData, (addr, length, sk_munmap_releaseproc, NULL));
-}
-#else
-SkData* SkData::NewFromMMap(const void* addr, size_t length) {
- return NULL;
-}
-#endif
-
///////////////////////////////////////////////////////////////////////////////
void SkData::flatten(SkFlattenableWriteBuffer& buffer) const {
gEmptySet->ref();
return gEmptySet;
}
-
--- /dev/null
+
+/*
+ * Copyright 2011 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+#include "SkMMapStream.h"
+
+#include <unistd.h>
+#include <sys/mman.h>
+#include <fcntl.h>
+#include <errno.h>
+
+SkMMAPStream::SkMMAPStream(const char filename[])
+{
+ fAddr = NULL; // initialize to failure case
+ fSize = 0;
+
+ int fildes = open(filename, O_RDONLY);
+ if (fildes < 0)
+ {
+ SkDEBUGF(("---- failed to open(%s) for mmap stream error=%d\n", filename, errno));
+ return;
+ }
+
+ off_t offset = lseek(fildes, 0, SEEK_END); // find the file size
+ if (offset == -1)
+ {
+ SkDEBUGF(("---- failed to lseek(%s) for mmap stream error=%d\n", filename, errno));
+ close(fildes);
+ return;
+ }
+ (void)lseek(fildes, 0, SEEK_SET); // restore file offset to beginning
+
+ // to avoid a 64bit->32bit warning, I explicitly create a size_t size
+ size_t size = static_cast<size_t>(offset);
+
+ void* addr = mmap(NULL, size, PROT_READ, MAP_SHARED, fildes, 0);
+
+ // According to the POSIX documentation of mmap it adds an extra reference
+ // to the file associated with the fildes which is not removed by a
+ // subsequent close() on that fildes. This reference is removed when there
+ // are no more mappings to the file.
+ close(fildes);
+
+ if (MAP_FAILED == addr)
+ {
+ SkDEBUGF(("---- failed to mmap(%s) for mmap stream error=%d\n", filename, errno));
+ return;
+ }
+
+ this->INHERITED::setMemory(addr, size);
+
+ fAddr = addr;
+ fSize = size;
+}
+
+SkMMAPStream::~SkMMAPStream()
+{
+ this->closeMMap();
+}
+
+void SkMMAPStream::setMemory(const void* data, size_t length, bool copyData)
+{
+ this->closeMMap();
+ this->INHERITED::setMemory(data, length, copyData);
+}
+
+void SkMMAPStream::closeMMap()
+{
+ if (fAddr)
+ {
+ munmap(fAddr, fSize);
+ fAddr = NULL;
+ }
+}
#include "SkString.h"
#include "SkOSFile.h"
-#if SK_MMAP_SUPPORT
- #include <unistd.h>
- #include <sys/mman.h>
- #include <fcntl.h>
- #include <errno.h>
- #include <unistd.h>
-#endif
-
SK_DEFINE_INST_COUNT(SkStream)
SK_DEFINE_INST_COUNT(SkWStream)
SK_DEFINE_INST_COUNT(SkFILEStream)
#endif
return true;
}
-
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-
-static bool mmap_filename(const char path[], void** addrPtr, size_t* sizePtr) {
-#if SK_MMAP_SUPPORT
- int fd = open(path, O_RDONLY);
- if (fd < 0) {
- return false;
- }
-
- off_t offset = lseek(fd, 0, SEEK_END); // find the file size
- if (offset == -1) {
- close(fd);
- return false;
- }
- (void)lseek(fd, 0, SEEK_SET); // restore file offset to beginning
-
- // to avoid a 64bit->32bit warning, I explicitly create a size_t size
- size_t size = static_cast<size_t>(offset);
-
- void* addr = mmap(NULL, size, PROT_READ, MAP_SHARED, fd, 0);
- close(fd);
-
- if (MAP_FAILED == addr) {
- return false;
- }
-
- *addrPtr = addr;
- *sizePtr = size;
- return true;
-#else
- return false;
-#endif
-}
-
-SkStream* SkStream::NewFromFile(const char path[]) {
- void* addr;
- size_t size;
- if (mmap_filename(path, &addr, &size)) {
- SkAutoTUnref<SkData> data(SkData::NewFromMMap(addr, size));
- if (data.get()) {
- return SkNEW_ARGS(SkMemoryStream, (data.get()));
- }
- }
-
- // If we get here, then our attempt at using mmap failed, so try normal
- // file access.
- SkFILEStream* stream = SkNEW_ARGS(SkFILEStream, (path));
- if (!stream->isValid()) {
- stream->unref();
- stream = NULL;
- }
- return stream;
-}
-
*/
#include "SkFontHost.h"
-#include "SkFontHost_FreeType_common.h"
#include "SkFontDescriptor.h"
#include "SkGraphics.h"
#include "SkDescriptor.h"
+#include "SkMMapStream.h"
#include "SkPaint.h"
#include "SkString.h"
#include "SkStream.h"
///////////////////////////////////////////////////////////////////////////////
-class FamilyTypeface : public SkTypeface_FreeType {
+class FamilyTypeface : public SkTypeface {
public:
FamilyTypeface(Style style, bool sysFont, SkTypeface* familyMember,
bool isFixedWidth)
- : INHERITED(style, sk_atomic_inc(&gUniqueFontID) + 1, isFixedWidth) {
+ : SkTypeface(style, sk_atomic_inc(&gUniqueFontID) + 1, isFixedWidth) {
fIsSysFont = sysFont;
// our caller has acquired the gFamilyHeadAndNameListMutex so this is safe
private:
bool fIsSysFont;
- typedef SkTypeface_FreeType INHERITED;
+ typedef SkTypeface INHERITED;
};
///////////////////////////////////////////////////////////////////////////////
fPath.set(path);
}
- virtual SkStream* openStream() SK_OVERRIDE {
- return SkStream::NewFromFile(fPath.c_str());
+ // overrides
+ virtual SkStream* openStream() {
+ SkStream* stream = SkNEW_ARGS(SkMMAPStream, (fPath.c_str()));
+
+ // check for failure
+ if (stream->getLength() <= 0) {
+ SkDELETE(stream);
+ // maybe MMAP isn't supported. try FILE
+ stream = SkNEW_ARGS(SkFILEStream, (fPath.c_str()));
+ if (stream->getLength() <= 0) {
+ SkDELETE(stream);
+ stream = NULL;
+ }
+ }
+ return stream;
}
-
- virtual const char* getUniqueString() const SK_OVERRIDE {
+ virtual const char* getUniqueString() const {
const char* str = strrchr(fPath.c_str(), '/');
if (str) {
str += 1; // skip the '/'
}
return str;
}
-
- virtual const char* getFilePath() const SK_OVERRIDE {
+ virtual const char* getFilePath() const {
return fPath.c_str();
}
SkString fullpath;
GetFullPathForSysFonts(&fullpath, path);
- SkAutoTUnref<SkStream> stream(SkStream::NewFromFile(fullpath.c_str()));
- if (stream.get()) {
- return find_name_and_attributes(stream, name, style, isFixedWidth);
- } else {
- if (isExpected) {
- SkDebugf("---- failed to open <%s> as a font", fullpath.c_str());
+ SkMMAPStream stream(fullpath.c_str());
+ if (stream.getLength() > 0) {
+ return find_name_and_attributes(&stream, name, style, isFixedWidth);
+ }
+ else {
+ SkFILEStream stream(fullpath.c_str());
+ if (stream.getLength() > 0) {
+ return find_name_and_attributes(&stream, name, style, isFixedWidth);
}
- return false;
}
+
+ if (isExpected) {
+ SkDebugf("---- failed to open <%s> as a font", fullpath.c_str());
+ }
+ return false;
}
// used to record our notion of the pre-existing fonts
}
}
-SkTypeface* SkFontHost::NextLogicalTypeface(SkFontID currFontID, SkFontID origFontID) {
+SkFontID SkFontHost::NextLogicalFont(SkFontID currFontID, SkFontID origFontID) {
#if defined(SK_BUILD_FOR_ANDROID) && !defined(SK_BUILD_FOR_ANDROID_FRAMEWORK)
// Skia does not support font fallback for ndk applications in order to
// enable clients such as WebKit to customize their font selection.
// Clients can use GetFallbackFamilyNameForChar() to get the fallback
// font for individual characters.
- return NULL;
+ return 0;
#else
SkAutoMutexAcquire ac(gFamilyHeadAndNameListMutex);
for (int i = 0; list[i] != 0; i++) {
if (list[i] == currFontID) {
if (list[i+1] == 0)
- return NULL;
+ return 0;
const SkTypeface* nextTypeface = find_from_uniqueID(list[i+1]);
- return SkRef(find_typeface(nextTypeface, origTypeface->style()));
+ return find_typeface(nextTypeface, origTypeface->style())->uniqueID();
}
}
// beginning of our list. Assuming there is at least one fallback font,
// i.e. gFallbackFonts[0] != 0.
const SkTypeface* firstTypeface = find_from_uniqueID(list[0]);
- return SkRef(find_typeface(firstTypeface, origTypeface->style()));
+ return find_typeface(firstTypeface, origTypeface->style())->uniqueID();
#endif
}
}
SkTypeface* SkFontHost::CreateTypefaceFromFile(const char path[]) {
- SkAutoTUnref<SkStream> stream(SkStream::NewFromFile(path));
- return stream.get() ? SkFontHost::CreateTypefaceFromStream(stream) : NULL;
+ SkStream* stream = SkNEW_ARGS(SkMMAPStream, (path));
+ SkTypeface* face = SkFontHost::CreateTypefaceFromStream(stream);
+ // since we created the stream, we let go of our ref() here
+ stream->unref();
+ return face;
}
///////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
+#include "SkMMapStream.h"
+
class SkScalerContext_Ascender : public SkScalerContext {
public:
SkScalerContext_Ascender(const SkDescriptor* desc);
*/
#include "SkFontHost.h"
+#include "SkMMapStream.h"
#include "SkTypefaceCache.h"
#define FONT_PATH "/Library/Fonts/Skia.ttf"
};
static FTMacTypeface* create_from_path(const char path[]) {
- SkStream* stream = SkStream::NewFromFile(path);
- if (!stream) {
- return NULL;
- }
-
+ SkStream* stream = new SkMMAPStream(path);
size_t size = stream->getLength();
SkASSERT(size);
FTMacTypeface* tf = new FTMacTypeface(SkTypeface::kNormal,
#include "SkFontHost.h"
#include "SkFontDescriptor.h"
#include "SkDescriptor.h"
+#include "SkMMapStream.h"
#include "SkOSFile.h"
#include "SkPaint.h"
#include "SkString.h"
EmptyTypeface() : INHERITED(SkTypeface::kNormal, true, NULL, false) {}
// overrides
- virtual SkStream* openStream() SK_OVERRIDE { return NULL; }
- virtual const char* getUniqueString() SK_OVERRIDE const { return NULL; }
+ virtual SkStream* openStream() { return NULL; }
+ virtual const char* getUniqueString() const { return NULL; }
private:
typedef FamilyTypeface INHERITED;
fStream->unref();
}
- virtual SkStream* openStream() SK_OVERRIDE {
+ // overrides
+ virtual SkStream* openStream()
+ {
// openStream returns a refed stream.
fStream->ref();
return fStream;
}
- virtual const char* getUniqueString() const SK_OVERRIDE { return NULL; }
+ virtual const char* getUniqueString() const { return NULL; }
private:
SkStream* fStream;
fPath.set(path);
}
- virtual SkStream* openStream() SK_OVERRIDE {
- return SkStream::NewFromFile(fPath.c_str());
+ // overrides
+ virtual SkStream* openStream()
+ {
+ SkStream* stream = SkNEW_ARGS(SkMMAPStream, (fPath.c_str()));
+
+ // check for failure
+ if (stream->getLength() <= 0) {
+ SkDELETE(stream);
+ // maybe MMAP isn't supported. try FILE
+ stream = SkNEW_ARGS(SkFILEStream, (fPath.c_str()));
+ if (stream->getLength() <= 0) {
+ SkDELETE(stream);
+ stream = NULL;
+ }
+ }
+ return stream;
}
- virtual const char* getUniqueString() const SK_OVERRIDE {
+ virtual const char* getUniqueString() const {
const char* str = strrchr(fPath.c_str(), '/');
if (str) {
str += 1; // skip the '/'
static bool get_name_and_style(const char path[], SkString* name,
SkTypeface::Style* style, bool* isFixedWidth) {
- SkAutoTUnref<SkStream> stream(SkStream::NewFromFile(path));
- if (stream.get()) {
- return find_name_and_attributes(stream, name, style, isFixedWidth);
- } else {
- SkDebugf("---- failed to open <%s> as a font\n", path);
- return false;
+ SkMMAPStream stream(path);
+ if (stream.getLength() > 0) {
+ return find_name_and_attributes(&stream, name, style, isFixedWidth);
+ }
+ else {
+ SkFILEStream stream(path);
+ if (stream.getLength() > 0) {
+ return find_name_and_attributes(&stream, name, style, isFixedWidth);
+ }
}
+
+ SkDebugf("---- failed to open <%s> as a font\n", path);
+ return false;
}
// these globals are assigned (once) by load_system_fonts()
#include "SkFontHost.h"
#include "SkDescriptor.h"
+#include "SkMMapStream.h"
#include "SkPaint.h"
#include "SkString.h"
#include "SkStream.h"
fPath.set(path);
}
- virtual SkStream* openStream() SK_OVERRIDE {
- return SkStream::NewFromFile(fPath.c_str());
+ // overrides
+ virtual SkStream* openStream() {
+ SkStream* stream = SkNEW_ARGS(SkMMAPStream, (fPath.c_str()));
+
+ // check for failure
+ if (stream->getLength() <= 0) {
+ SkDELETE(stream);
+ // maybe MMAP isn't supported. try FILE
+ stream = SkNEW_ARGS(SkFILEStream, (fPath.c_str()));
+ if (stream->getLength() <= 0) {
+ SkDELETE(stream);
+ stream = NULL;
+ }
+ }
+ return stream;
}
-
- virtual const char* getUniqueString() const SK_OVERRIDE {
+ virtual const char* getUniqueString() const {
const char* str = strrchr(fPath.c_str(), '/');
if (str) {
str += 1; // skip the '/'
}
return str;
}
- virtual const char* getFilePath() const SK_OVERRIDE {
+ virtual const char* getFilePath() const {
return fPath.c_str();
}
SkString fullpath;
GetFullPathForSysFonts(&fullpath, path);
- SkAutoTUnref<SkStream> stream(SkStream::NewFromFile(fullpath.c_str()));
- if (stream.get()) {
+ SkMMAPStream stream(fullpath.c_str());
+ if (stream.getLength() > 0) {
return find_name_and_attributes(&stream, name, style, NULL);
- } else {
- if (isExpected) {
- SkDebugf("---- failed to open <%s> as a font\n", fullpath.c_str());
+ }
+ else {
+ SkFILEStream stream(fullpath.c_str());
+ if (stream.getLength() > 0) {
+ return find_name_and_attributes(&stream, name, style, NULL);
}
- return false;
}
+
+ if (isExpected) {
+ SkDebugf("---- failed to open <%s> as a font\n", fullpath.c_str());
+ }
+ return false;
}
// used to record our notion of the pre-existing fonts
fontIDs that can be used for fallback consideration, in sorted order (sorted
meaning element[0] should be used first, then element[1], etc. When we hit
a fontID==0 in the array, the list is done, hence our allocation size is
- +1 the total number of possible system fonts. Also see NextLogicalTypeface().
+ +1 the total number of possible system fonts. Also see NextLogicalFont().
*/
static uint32_t gFallbackFonts[SK_ARRAY_COUNT(gSystemFonts)+1];
}
}
-SkTypeface* SkFontHost::NextLogicalTypeface(SkFontID currFontID, SkFontID origFontID) {
+SkFontID SkFontHost::NextLogicalFont(SkFontID currFontID, SkFontID origFontID) {
load_system_fonts();
/* First see if fontID is already one of our fallbacks. If so, return
const uint32_t* list = gFallbackFonts;
for (int i = 0; list[i] != 0; i++) {
if (list[i] == currFontID) {
- return SkSafeRef(find_from_uniqueID(list[i+1]));
+ return list[i+1];
}
}
- return SkSafeRef(list[0]);
+ return list[0];
}
///////////////////////////////////////////////////////////////////////////////
}
SkTypeface* SkFontHost::CreateTypefaceFromFile(const char path[]) {
- SkAutoTUnref<SkStream> stream(SkStream::NewFromFile(path));
- return stream.get() ? SkFontHost::CreateTypefaceFromStream(stream) : NULL;
+ SkStream* stream = SkNEW_ARGS(SkMMAPStream, (path));
+ SkTypeface* face = SkFontHost::CreateTypefaceFromStream(stream);
+ // since we created the stream, we let go of our ref() here
+ stream->unref();
+ return face;
}
projects / platform / upstream / libSkiaSharp.git / commitdiff