#pragma once
#include "ImageFrame.h"
#include "TextStream.h"
#include <wtf/Forward.h>
#include <wtf/Optional.h>
#include <wtf/SynchronizedFixedQueue.h>
#include <wtf/WorkQueue.h>
#include <wtf/threads/BinarySemaphore.h>
namespace WebCore {
class GraphicsContext;
class Image;
class ImageDecoder;
class ImageFrameCache : public RefCounted<ImageFrameCache> {
friend class ImageSource;
public:
static Ref<ImageFrameCache> create(Image* image)
{
return adoptRef(*new ImageFrameCache(image));
}
static Ref<ImageFrameCache> create(NativeImagePtr&& nativeImage)
{
return adoptRef(*new ImageFrameCache(WTFMove(nativeImage)));
}
~ImageFrameCache();
void setDecoder(ImageDecoder* decoder) { m_decoder = decoder; }
ImageDecoder* decoder() const { return m_decoder; }
unsigned decodedSize() const { return m_decodedSize; }
void destroyAllDecodedData() { destroyDecodedData(frameCount(), frameCount()); }
void destroyAllDecodedDataExcludeFrame(size_t excludeFrame) { destroyDecodedData(frameCount(), excludeFrame); }
void destroyDecodedDataBeforeFrame(size_t beforeFrame) { destroyDecodedData(beforeFrame, beforeFrame); }
void destroyIncompleteDecodedData();
void growFrames();
void clearMetadata();
void startAsyncDecodingQueue();
bool requestFrameAsyncDecodingAtIndex(size_t, SubsamplingLevel);
void stopAsyncDecodingQueue();
bool hasDecodingQueue() { return m_decodingQueue; }
bool isSizeAvailable();
size_t frameCount();
RepetitionCount repetitionCount();
String filenameExtension();
std::optional<IntPoint> hotSpot();
IntSize size();
IntSize sizeRespectingOrientation();
Color singlePixelSolidColor();
bool frameIsBeingDecodedAtIndex(size_t);
bool frameIsCompleteAtIndex(size_t);
bool frameHasAlphaAtIndex(size_t);
bool frameHasImageAtIndex(size_t);
bool frameHasValidNativeImageAtIndex(size_t, SubsamplingLevel);
SubsamplingLevel frameSubsamplingLevelAtIndex(size_t);
IntSize frameSizeAtIndex(size_t, SubsamplingLevel = SubsamplingLevel::Default);
unsigned frameBytesAtIndex(size_t, SubsamplingLevel = SubsamplingLevel::Default);
float frameDurationAtIndex(size_t);
ImageOrientation frameOrientationAtIndex(size_t);
NativeImagePtr frameImageAtIndex(size_t, SubsamplingLevel = SubsamplingLevel::Default);
private:
ImageFrameCache(Image*);
ImageFrameCache(NativeImagePtr&&);
template<typename T, T (ImageDecoder::*functor)() const>
T metadata(const T& defaultValue, std::optional<T>* cachedValue = nullptr);
template<typename T, T (ImageFrame::*functor)() const>
T frameMetadataAtIndex(size_t index, SubsamplingLevel = SubsamplingLevel::Undefinded, ImageFrame::Caching = ImageFrame::Caching::Empty, std::optional<T>* = nullptr);
bool isDecoderAvailable() const { return m_decoder; }
void destroyDecodedData(size_t frameCount, size_t excludeFrame);
void decodedSizeChanged(long long decodedSize);
void didDecodeProperties(unsigned decodedPropertiesSize);
void decodedSizeIncreased(unsigned decodedSize);
void decodedSizeDecreased(unsigned decodedSize);
void decodedSizeReset(unsigned decodedSize);
void setNativeImage(NativeImagePtr&&);
void setFrameNativeImageAtIndex(NativeImagePtr&&, size_t, SubsamplingLevel);
void setFrameMetadataAtIndex(size_t, SubsamplingLevel);
void replaceFrameNativeImageAtIndex(NativeImagePtr&&, size_t, SubsamplingLevel);
void cacheFrameNativeImageAtIndex(NativeImagePtr&&, size_t, SubsamplingLevel);
Ref<WorkQueue> decodingQueue();
const ImageFrame& frameAtIndex(size_t, SubsamplingLevel, ImageFrame::Caching);
Image* m_image { nullptr };
ImageDecoder* m_decoder { nullptr };
unsigned m_decodedSize { 0 };
unsigned m_decodedPropertiesSize { 0 };
Vector<ImageFrame, 1> m_frames;
struct ImageFrameRequest {
size_t index;
SubsamplingLevel subsamplingLevel;
};
static const int BufferSize = 8;
using FrameRequestQueue = SynchronizedFixedQueue<ImageFrameRequest, BufferSize>;
FrameRequestQueue m_frameRequestQueue;
RefPtr<WorkQueue> m_decodingQueue;
std::optional<bool> m_isSizeAvailable;
std::optional<size_t> m_frameCount;
std::optional<RepetitionCount> m_repetitionCount;
std::optional<String> m_filenameExtension;
std::optional<std::optional<IntPoint>> m_hotSpot;
std::optional<IntSize> m_size;
std::optional<IntSize> m_sizeRespectingOrientation;
std::optional<Color> m_singlePixelSolidColor;
};
}