SkMallocPixelRef Namespace Reference

Functions
SK_API sk_sp< SkPixelRef >	MakeAllocate (const SkImageInfo &, size_t rowBytes)
SK_API sk_sp< SkPixelRef >	MakeWithData (const SkImageInfo &, size_t rowBytes, sk_sp< SkData > data)

Detailed Description

We explicitly use the same allocator for our pixels that SkMask does, so that we can freely assign memory allocated by one class to the other.

Function Documentation

MakeAllocate()

sk_sp< SkPixelRef > SkMallocPixelRef::MakeAllocate	(	const SkImageInfo &	info,
		size_t	rowBytes
	)

Return a new SkMallocPixelRef, automatically allocating storage for the pixels. If rowBytes are 0, an optimal value will be chosen automatically. If rowBytes is > 0, then it will be respected, or NULL will be returned if rowBytes is invalid for the specified info.

All pixel bytes are zeroed.

Returns NULL on failure.

Definition at line 29 of file SkMallocPixelRef.cpp.

                                                                                         {
    if (rowBytes == 0) {
        rowBytes = info.minRowBytes();
        // rowBytes can still be zero, if it overflowed (width * bytesPerPixel > size_t)
        // or if colortype is unknown
    }
    if (!is_valid(info) || !info.validRowBytes(rowBytes)) {
        return nullptr;
    }
    size_t size = info.computeByteSize(rowBytes);
    if (SkImageInfo::ByteSizeOverflowed(size)) {
        return nullptr;
    }
#if defined(SK_BUILD_FOR_FUZZER)
    if (size > 10000000) {
        return nullptr;
    }
#endif
    void* addr = sk_calloc_canfail(size);
    if (nullptr == addr) {
        return nullptr;
    }
 
    struct PixelRef final : public SkPixelRef {
        PixelRef(int w, int h, void* s, size_t r) : SkPixelRef(w, h, s, r) {}
        ~PixelRef() override { sk_free(this->pixels()); }
    };
    return sk_sp<SkPixelRef>(new PixelRef(info.width(), info.height(), addr, rowBytes));
}

MakeWithData()

sk_sp< SkPixelRef > SkMallocPixelRef::MakeWithData	(	const SkImageInfo &	info,
		size_t	rowBytes,
		sk_sp< SkData >	data
	)

Return a new SkMallocPixelRef that will use the provided SkData and rowBytes as pixel storage. The SkData will be ref()ed and on destruction of the PixelRef, the SkData will be unref()ed.

Returns NULL on failure.

Definition at line 59 of file SkMallocPixelRef.cpp.

                                                                     {
    SkASSERT(data != nullptr);
    if (!is_valid(info)) {
        return nullptr;
    }
    // TODO: what should we return if computeByteSize returns 0?
    // - the info was empty?
    // - we overflowed computing the size?
    if ((rowBytes < info.minRowBytes()) || (data->size() < info.computeByteSize(rowBytes))) {
        return nullptr;
    }
    struct PixelRef final : public SkPixelRef {
        sk_sp<SkData> fData;
        PixelRef(int w, int h, void* s, size_t r, sk_sp<SkData> d)
            : SkPixelRef(w, h, s, r), fData(std::move(d)) {}
    };
    void* pixels = const_cast<void*>(data->data());
    sk_sp<SkPixelRef> pr(new PixelRef(info.width(), info.height(), pixels, rowBytes,
                                      std::move(data)));
    pr->setImmutable(); // since we were created with (immutable) data
    return pr;
}