image.h

Go to the documentation of this file.

 
#pragma once
 
#include <promeki/core/namespace.h>
#include <promeki/core/sharedptr.h>
#include <promeki/core/buffer.h>
#include <promeki/proav/imagedesc.h>
#include <promeki/proav/paintengine.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class Image {
        PROMEKI_SHARED_FINAL(Image)
        public:
                using Ptr = SharedPtr<Image>;
 
                using List = promeki::List<Image>;
 
                using PtrList = promeki::List<Ptr>;
 
                Image() = default;
 
                Image(const ImageDesc &desc, const MemSpace &ms = MemSpace::Default);
 
                Image(const Size2Du32 &s, int pixfmt, const MemSpace &ms = MemSpace::Default) :
                        Image(ImageDesc(s, pixfmt), ms) { }
 
                Image(size_t w, size_t h, int pixfmt, const MemSpace &ms = MemSpace::Default) :
                        Image(ImageDesc(w, h, pixfmt), ms) { }
 
                bool isValid() const {
                        return _desc.isValid();
                }
 
                const ImageDesc &desc() const {
                        return _desc;
                }
 
                int pixelFormatID() const {
                        return _desc.pixelFormatID();
                }
 
                const PixelFormat *pixelFormat() const {
                        return _desc.pixelFormat();
                }
 
                const Size2Du32 &size() const {
                        return _desc.size();
                }
 
                size_t width() const {
                        return _desc.width();
                }
 
                size_t height() const {
                        return _desc.height();
                }
 
                const Metadata &metadata() const {
                        return _desc.metadata();
                }
 
                Metadata &metadata() {
                        return _desc.metadata();
                }
 
                size_t lineStride(int plane = 0) const {
                        return _desc.pixelFormat()->lineStride(plane, _desc);
                }
 
                const Buffer::Ptr &plane(int index = 0) const {
                        return _planeList[index];
                }
 
                const Buffer::PtrList &planes() const {
                        return _planeList;
                }
 
                void *data(int index = 0) const {
                        return _planeList[index]->data();
                }
 
                Error fill(char value) const {
                        if(_planeList.isEmpty()) return Error::Invalid;
                        for(auto &p : _planeList) {
                                Error err = p->fill(value);
                                if(err.isError()) return err;
                        }
                        return Error::Ok;
                }
 
                bool isExclusive() const {
                        for(const auto &p : _planeList) {
                                if(p.referenceCount() > 1) return false;
                        }
                        return true;
                }
 
                void ensureExclusive() {
                        for(auto &p : _planeList) {
                                p.modify();
                        }
                        return;
                }
 
                bool isCompressed() const {
                        const PixelFormat *pf = _desc.pixelFormat();
                        return pf != nullptr && pf->isCompressed();
                }
 
                size_t compressedSize() const {
                        if(!isCompressed() || _planeList.isEmpty()) return 0;
                        return _planeList[0]->size();
                }
 
                static Image fromCompressedData(const void *data, size_t size,
                                                size_t width, size_t height, int pixfmt,
                                                const Metadata &metadata = Metadata());
 
                PaintEngine createPaintEngine() const {
                        return _desc.pixelFormat()->createPaintEngine(*this);
                }
 
                Image convert(PixelFormat::ID pixelFormat, const Metadata &metadata) const;
 
        private:
                ImageDesc       _desc;
                Buffer::PtrList _planeList;
 
                bool allocate(const MemSpace &ms);
};
 
PROMEKI_NAMESPACE_END