Slic3r::GUI::anonymous_namespace{AnimatedTexture.cpp} Namespace Reference

Classes
struct	DecodedFrame

Functions
std::vector< unsigned char >	read_file_bytes (const std::string &path)
bool	has_gif_signature (const std::vector< unsigned char > &bytes)
std::vector< unsigned char >	image_to_rgba (const wxImage &image)
bool	decode_gif (const std::vector< unsigned char > &bytes, int &width, int &height, std::vector< DecodedFrame > &out)

---

Class Documentation

Slic3r::GUI::anonymous_namespace{AnimatedTexture.cpp}::DecodedFrame

struct Slic3r::GUI::anonymous_namespace{AnimatedTexture.cpp}::DecodedFrame

Collaboration diagram for Slic3r::GUI::anonymous_namespace{AnimatedTexture.cpp}::DecodedFrame:

Class Members
double	delay
vector< unsigned char >	rgba

Function Documentation

decode_gif()

bool Slic3r::GUI::anonymous_namespace{AnimatedTexture.cpp}::decode_gif	(	const std::vector< unsigned char > &	bytes,
		int &	width,
		int &	height,
		std::vector< DecodedFrame > &	out )

{
    wxMemoryInputStream stream(bytes.data(), bytes.size());
    wxGIFDecoder        decoder;
 
    // A truncated file still decodes everything up to the cut, which is worth showing.
    const wxGIFErrorCode err = decoder.LoadGIF(stream);
    if ((err != wxGIF_OK && err != wxGIF_TRUNCATED) || decoder.GetFrameCount() == 0)
        return false;
 
    const wxSize size = decoder.GetAnimationSize();
    width             = size.GetWidth();
    height            = size.GetHeight();
    if (width <= 0 || height <= 0)
        return false;
 
    std::vector<unsigned char> canvas(size_t(width) * size_t(height) * 4, 0);
    std::vector<unsigned char> saved;
 
    for (unsigned int i = 0; i < decoder.GetFrameCount(); ++i) {
        const wxSize              frame_size = decoder.GetFrameSize(i);
        const wxPoint             frame_pos  = decoder.GetFramePosition(i);
        const wxAnimationDisposal disposal   = decoder.GetDisposalMethod(i);
        const unsigned char      *indices    = decoder.GetData(i);
        const unsigned char      *palette    = decoder.GetPalette(i);
        const int                 transparent = decoder.GetTransparentColourIndex(i);
 
        if (disposal == wxANIM_TOPREVIOUS)
            saved = canvas;
 
        if (indices != nullptr && palette != nullptr)
            for (int y = 0; y < frame_size.GetHeight(); ++y) {
                const int cy = frame_pos.y + y;
                if (cy < 0 || cy >= height)
                    continue;
                for (int x = 0; x < frame_size.GetWidth(); ++x) {
                    const int cx = frame_pos.x + x;
                    if (cx < 0 || cx >= width)
                        continue;
                    const unsigned char index = indices[size_t(y) * size_t(frame_size.GetWidth()) + size_t(x)];
                    if (int(index) == transparent)
                        continue;
                    unsigned char *dst = &canvas[(size_t(cy) * size_t(width) + size_t(cx)) * 4];
                    dst[0]             = palette[3 * size_t(index) + 0];
                    dst[1]             = palette[3 * size_t(index) + 1];
                    dst[2]             = palette[3 * size_t(index) + 2];
                    dst[3]             = 255;
                }
            }
 
        // Browsers treat 0 and 1 hundredths of a second as "as fast as the file can mean", and settle
        // on 100 ms; an animation authored against that convention plays at the intended speed only if
        // this does the same.
        const long delay_ms = decoder.GetDelay(i);
        out.push_back({ canvas, (delay_ms <= 10 ? 100.0 : double(delay_ms)) / 1000.0 });
 
        if (disposal == wxANIM_TOBACKGROUND) {
            for (int y = 0; y < frame_size.GetHeight(); ++y) {
                const int cy = frame_pos.y + y;
                if (cy < 0 || cy >= height)
                    continue;
                const int x0 = std::max(0, frame_pos.x);
                const int x1 = std::min(width, frame_pos.x + frame_size.GetWidth());
                if (x1 > x0)
                    std::fill_n(&canvas[(size_t(cy) * size_t(width) + size_t(x0)) * 4], size_t(x1 - x0) * 4, 0);
            }
        } else if (disposal == wxANIM_TOPREVIOUS) {
            canvas = saved;
        }
    }
    return !out.empty();
}

References decode_gif().

Referenced by decode_gif().

Here is the call graph for this function:

Here is the caller graph for this function:

has_gif_signature()

bool Slic3r::GUI::anonymous_namespace{AnimatedTexture.cpp}::has_gif_signature

(

const std::vector< unsigned char > &

bytes

)

{
    return bytes.size() > 6 && bytes[0] == 'G' && bytes[1] == 'I' && bytes[2] == 'F';
}

References has_gif_signature().

Referenced by has_gif_signature().

Here is the call graph for this function:

Here is the caller graph for this function:

image_to_rgba()

std::vector< unsigned char > Slic3r::GUI::anonymous_namespace{AnimatedTexture.cpp}::image_to_rgba

(

const wxImage &

image

)

{
    const size_t         n   = size_t(image.GetWidth()) * size_t(image.GetHeight());
    const unsigned char *rgb = image.GetData();
    const unsigned char *a   = image.HasAlpha() ? image.GetAlpha() : nullptr;
 
    std::vector<unsigned char> out(n * 4);
    for (size_t i = 0; i < n; ++i) {
        out[i * 4 + 0] = rgb[i * 3 + 0];
        out[i * 4 + 1] = rgb[i * 3 + 1];
        out[i * 4 + 2] = rgb[i * 3 + 2];
        out[i * 4 + 3] = a != nullptr ? a[i] : 255;
    }
    return out;
}

References image_to_rgba().

Referenced by image_to_rgba().

Here is the call graph for this function:

Here is the caller graph for this function:

read_file_bytes()

std::vector< unsigned char > Slic3r::GUI::anonymous_namespace{AnimatedTexture.cpp}::read_file_bytes

(

const std::string &

path

)

{
    std::ifstream ifs(path, std::ios::binary);
    return std::vector<unsigned char>(std::istreambuf_iterator<char>(ifs), std::istreambuf_iterator<char>());
}

References read_file_bytes().

Referenced by read_file_bytes().

Here is the call graph for this function:

Here is the caller graph for this function: