Slic3r::png Namespace Reference

Classes
struct	PNGDescr
struct	IStream
struct	Image
struct	ImageColorscale
struct	ReadBuf
struct	ReadBufStream

Typedefs
using	ImageGreyscale = Image<uint8_t>

Functions
bool	is_png (const ReadBuf &rb)
static void	png_read_callback (png_struct *png_ptr, png_bytep outBytes, png_size_t byteCountToRead)
static bool	png_read_header_guarded (png_struct *png, png_info *info, IStream *in_buf, int sig_bytes)
static bool	png_read_rows_guarded (png_struct *png, png_info *info, png_bytep dst, size_t rows, size_t rowbytes, bool bottom_up, bool read_end)
bool	decode_png (IStream &in_buf, ImageGreyscale &out_img)
bool	decode_colored_png (IStream &in_buf, ImageColorscale &out_img)
bool	decode_colored_png (const ReadBuf &in_buf, ImageColorscale &out_img)
bool	is_decodable_8bit_png (const ReadBuf &pngbuf)
static bool	write_rgb_or_gray_to_file (const char *file_name_utf8, size_t width, size_t height, int png_color_type, const uint8_t *data)
bool	write_rgb_to_file (const char *file_name_utf8, size_t width, size_t height, const uint8_t *data_rgb)
bool	write_rgb_to_file (const std::string &file_name_utf8, size_t width, size_t height, const uint8_t *data_rgb)
bool	write_rgb_to_file (const std::string &file_name_utf8, size_t width, size_t height, const std::vector< uint8_t > &data_rgb)
bool	write_gray_to_file (const char *file_name_utf8, size_t width, size_t height, const uint8_t *data_gray)
bool	write_gray_to_file (const std::string &file_name_utf8, size_t width, size_t height, const uint8_t *data_gray)
bool	write_gray_to_file (const std::string &file_name_utf8, size_t width, size_t height, const std::vector< uint8_t > &data_gray)
static bool	write_rgb_or_gray_to_file_scaled (const char *file_name_utf8, size_t width, size_t height, int png_color_type, const uint8_t *data, size_t scale)
bool	write_rgb_to_file_scaled (const char *file_name_utf8, size_t width, size_t height, const uint8_t *data_rgb, size_t scale)
bool	write_rgb_to_file_scaled (const std::string &file_name_utf8, size_t width, size_t height, const uint8_t *data_rgb, size_t scale)
bool	write_rgb_to_file_scaled (const std::string &file_name_utf8, size_t width, size_t height, const std::vector< uint8_t > &data_rgb, size_t scale)
bool	write_gray_to_file_scaled (const char *file_name_utf8, size_t width, size_t height, const uint8_t *data_gray, size_t scale)
bool	write_gray_to_file_scaled (const std::string &file_name_utf8, size_t width, size_t height, const uint8_t *data_gray, size_t scale)
bool	write_gray_to_file_scaled (const std::string &file_name_utf8, size_t width, size_t height, const std::vector< uint8_t > &data_gray, size_t scale)
template<class Img>
bool	decode_png (const ReadBuf &in_buf, Img &out_img)

---

Class Documentation

Slic3r::png::ReadBuf

struct Slic3r::png::ReadBuf

Class Members
const void *	buf = nullptr
const size_t	sz = 0

Typedef Documentation

ImageGreyscale

using Slic3r::png::ImageGreyscale = Image<uint8_t>

Function Documentation

decode_colored_png() [1/2]

bool Slic3r::png::decode_colored_png	(	const ReadBuf &	in_buf,
		ImageColorscale &	out_img )

{
    struct ReadBufStream stream{in_buf};
 
    return decode_colored_png(stream, out_img);
}

References decode_colored_png().

Here is the call graph for this function:

decode_colored_png() [2/2]

bool Slic3r::png::decode_colored_png	(	IStream &	in_buf,
		ImageColorscale &	out_img )

{
    static const constexpr int PNG_SIG_BYTES = 8;
 
    std::vector<png_byte> sig(PNG_SIG_BYTES, 0);
    in_buf.read(sig.data(), PNG_SIG_BYTES);
    if (!png_check_sig(sig.data(), PNG_SIG_BYTES)) {
        BOOST_LOG_TRIVIAL(error) << boost::format("decode_colored_png: png_check_sig failed");
        return false;
    }
 
    PNGDescr dsc;
    dsc.png = png_create_read_struct(PNG_LIBPNG_VER_STRING, nullptr, nullptr,
                                     nullptr);
 
    if(!dsc.png) {
        BOOST_LOG_TRIVIAL(error) << boost::format("decode_colored_png: png_create_read_struct failed");
        return false;
    }
 
    dsc.info = png_create_info_struct(dsc.png);
    if(!dsc.info) {
        BOOST_LOG_TRIVIAL(error) << boost::format("decode_colored_png: png_create_info_struct failed");
        png_destroy_read_struct(&dsc.png, &dsc.info, NULL);
        return false;
    }
 
    if (!png_read_header_guarded(dsc.png, dsc.info, &in_buf, PNG_SIG_BYTES)) {
        BOOST_LOG_TRIVIAL(error) << "decode_colored_png: corrupt or truncated PNG data";
        return false;
    }
 
    out_img.cols = png_get_image_width(dsc.png, dsc.info);
    out_img.rows = png_get_image_height(dsc.png, dsc.info);
    size_t color_type = png_get_color_type(dsc.png, dsc.info);
    size_t bit_depth  = png_get_bit_depth(dsc.png, dsc.info);
    unsigned long rowbytes = png_get_rowbytes(dsc.png, dsc.info);
 
    switch(color_type)
    {
        case PNG_COLOR_TYPE_RGB:
            out_img.bytes_per_pixel = 3;
            break;
        case PNG_COLOR_TYPE_RGB_ALPHA:
            out_img.bytes_per_pixel = 4;
            break;
        default: //not supported currently
            png_destroy_read_struct(&dsc.png, &dsc.info, NULL);
            return false;
    }
 
    BOOST_LOG_TRIVIAL(info) << boost::format("png's cols %1%, rows %2%, color_type %3%, bit_depth %4%, bytes_per_pixel %5%, rowbytes %6%")%out_img.cols %out_img.rows %color_type %bit_depth %out_img.bytes_per_pixel %rowbytes;
    out_img.buf.resize(out_img.rows * rowbytes);
 
    int filter_type = png_get_filter_type(dsc.png, dsc.info);
    int compression_type = png_get_compression_type(dsc.png, dsc.info);
    int interlace_type = png_get_interlace_type(dsc.png, dsc.info);
    BOOST_LOG_TRIVIAL(info) << boost::format("filter_type %1%, compression_type %2%, interlace_type %3%, rowbytes %4%")%filter_type %compression_type %interlace_type %rowbytes;
 
    if (!png_read_rows_guarded(dsc.png, dsc.info, static_cast<png_bytep>(out_img.buf.data()), out_img.rows, rowbytes,
                               /* bottom_up */ true, /* read_end */ true)) {
        BOOST_LOG_TRIVIAL(error) << "decode_colored_png: corrupt or truncated PNG data";
        return false;
    }
 
    png_destroy_read_struct(&dsc.png, &dsc.info, NULL);
 
    return true;
}

References Slic3r::png::Image< PxT >::buf, Slic3r::png::ImageColorscale::bytes_per_pixel, Slic3r::png::Image< PxT >::cols, Slic3r::png::PNGDescr::info, Slic3r::png::PNGDescr::png, png_read_header_guarded(), png_read_rows_guarded(), Slic3r::png::IStream::read(), and Slic3r::png::Image< PxT >::rows.

Referenced by decode_colored_png(), Slic3r::decode_height_texture(), and decode_png_to_thumbnail().

Here is the call graph for this function:

Here is the caller graph for this function:

decode_png() [1/2]

template<class Img>

bool Slic3r::png::decode_png	(	const ReadBuf &	in_buf,
		Img &	out_img )

{
    struct ReadBufStream stream{in_buf};
 
    return decode_png(stream, out_img);
}

References decode_png().

Here is the call graph for this function:

decode_png() [2/2]

bool Slic3r::png::decode_png	(	IStream &	in_buf,
		ImageGreyscale &	out_img )

{
    static const constexpr int PNG_SIG_BYTES = 8;
 
    std::vector<png_byte> sig(PNG_SIG_BYTES, 0);
    in_buf.read(sig.data(), PNG_SIG_BYTES);
    if (!png_check_sig(sig.data(), PNG_SIG_BYTES))
        return false;
 
    PNGDescr dsc;
    dsc.png = png_create_read_struct(PNG_LIBPNG_VER_STRING, nullptr, nullptr,
                                     nullptr);
 
    if(!dsc.png) return false;
 
    dsc.info = png_create_info_struct(dsc.png);
    if(!dsc.info) return false;
 
    if (!png_read_header_guarded(dsc.png, dsc.info, &in_buf, PNG_SIG_BYTES))
        return false;
 
    out_img.cols = png_get_image_width(dsc.png, dsc.info);
    out_img.rows = png_get_image_height(dsc.png, dsc.info);
    size_t color_type = png_get_color_type(dsc.png, dsc.info);
    size_t bit_depth  = png_get_bit_depth(dsc.png, dsc.info);
 
    if (color_type != PNG_COLOR_TYPE_GRAY || bit_depth != 8)
        return false;
 
    out_img.buf.resize(out_img.rows * out_img.cols);
 
    return png_read_rows_guarded(dsc.png, dsc.info, static_cast<png_bytep>(out_img.buf.data()), out_img.rows,
                                 out_img.cols, /* bottom_up */ false, /* read_end */ false);
}

References Slic3r::png::Image< PxT >::buf, Slic3r::png::Image< PxT >::cols, Slic3r::png::PNGDescr::info, Slic3r::png::PNGDescr::png, png_read_header_guarded(), png_read_rows_guarded(), Slic3r::png::IStream::read(), and Slic3r::png::Image< PxT >::rows.

Referenced by Slic3r::decode_height_texture(), decode_png(), and Slic3r::anonymous_namespace{SL1.cpp}::extract_slices_from_sla_archive().

Here is the call graph for this function:

Here is the caller graph for this function:

is_decodable_8bit_png()

bool Slic3r::png::is_decodable_8bit_png

(

const ReadBuf &

pngbuf

)

{
    static const constexpr int PNG_SIG_BYTES = 8;
 
    struct ReadBufStream stream{pngbuf};
    std::vector<png_byte> sig(PNG_SIG_BYTES, 0);
    stream.read(sig.data(), PNG_SIG_BYTES);
    if (!png_check_sig(sig.data(), PNG_SIG_BYTES))
        return false;
 
    PNGDescr dsc;
    dsc.png = png_create_read_struct(PNG_LIBPNG_VER_STRING, nullptr, nullptr, nullptr);
    if (!dsc.png)
        return false;
    dsc.info = png_create_info_struct(dsc.png);
    if (!dsc.info)
        return false;
 
    if (!png_read_header_guarded(dsc.png, dsc.info, &stream, PNG_SIG_BYTES))
        return false;
 
    const size_t color_type = png_get_color_type(dsc.png, dsc.info);
    const size_t bit_depth  = png_get_bit_depth(dsc.png, dsc.info);
    const bool   grey       = color_type == PNG_COLOR_TYPE_GRAY;
    const bool   colour     = color_type == PNG_COLOR_TYPE_RGB || color_type == PNG_COLOR_TYPE_RGB_ALPHA;
    return png_get_image_width(dsc.png, dsc.info) > 0 && png_get_image_height(dsc.png, dsc.info) > 0 &&
           bit_depth == 8 && (grey || colour);
}

References Slic3r::png::PNGDescr::info, Slic3r::png::PNGDescr::png, png_read_header_guarded(), and Slic3r::png::ReadBufStream::read().

Referenced by Slic3r::GUI::anonymous_namespace{TextureLibrary.cpp}::is_supported_height_map().

Here is the call graph for this function:

Here is the caller graph for this function:

is_png()

bool Slic3r::png::is_png

(

const ReadBuf &

rb

)

{
    static const constexpr int PNG_SIG_BYTES = 8;
 
#if PNG_LIBPNG_VER_MINOR <= 2
    // Earlier libpng versions had png_sig_cmp(png_bytep, ...) which is not
    // a const pointer. It is not possible to cast away the const qualifier from
    // the input buffer so... yes... life is challenging...
    png_byte buf[PNG_SIG_BYTES];
    auto inbuf = static_cast<const std::uint8_t *>(rb.buf);
    std::copy(inbuf, inbuf + PNG_SIG_BYTES, buf);
#else
    auto buf = static_cast<png_const_bytep>(rb.buf);
#endif
 
    return rb.sz >= PNG_SIG_BYTES && !png_sig_cmp(buf, 0, PNG_SIG_BYTES);
}

References Slic3r::png::ReadBuf::buf, and Slic3r::png::ReadBuf::sz.

Referenced by Slic3r::decode_height_texture().

Here is the caller graph for this function:

png_read_callback()

void Slic3r::png::png_read_callback ( png_struct * png_ptr, png_bytep outBytes, png_size_t byteCountToRead )

static

{
    // Retrieve our input buffer through the png_ptr
    auto reader = static_cast<IStream *>(png_get_io_ptr(png_ptr));
 
    // libpng expects a short read to be reported through png_error(); returning quietly would leave
    // it decoding whatever happened to be in outBytes.
    if (!reader || !reader->is_ok() ||
        reader->read(static_cast<std::uint8_t *>(outBytes), byteCountToRead) != byteCountToRead)
        png_error(png_ptr, "PNG data is truncated");
}

Referenced by png_read_header_guarded().

Here is the caller graph for this function:

png_read_header_guarded()

bool Slic3r::png::png_read_header_guarded ( png_struct * png, png_info * info, IStream * in_buf, int sig_bytes )

static

{
    if (setjmp(png_jmpbuf(png)))
        return false;
 
    png_set_read_fn(png, static_cast<void *>(in_buf), png_read_callback);
    // Tell that we have already read the first bytes to check the signature
    png_set_sig_bytes(png, sig_bytes);
    png_read_info(png, info);
    return true;
}

References png_read_callback().

Referenced by decode_colored_png(), decode_png(), and is_decodable_8bit_png().

Here is the call graph for this function:

Here is the caller graph for this function:

png_read_rows_guarded()

bool Slic3r::png::png_read_rows_guarded ( png_struct * png, png_info * info, png_bytep dst, size_t rows, size_t rowbytes, bool bottom_up, bool read_end )

static

{
    if (setjmp(png_jmpbuf(png)))
        return false;
 
    for (size_t i = 0; i < rows; ++i)
        png_read_row(png, dst + (bottom_up ? rows - 1 - i : i) * rowbytes, nullptr);
    if (read_end)
        png_read_end(png, info);
    return true;
}

Referenced by decode_colored_png(), and decode_png().

Here is the caller graph for this function:

write_gray_to_file() [1/3]

bool Slic3r::png::write_gray_to_file	(	const char *	file_name_utf8,
		size_t	width,
		size_t	height,
		const uint8_t *	data_gray )

{
    return write_rgb_or_gray_to_file(file_name_utf8, width, height, PNG_COLOR_TYPE_GRAY, data_gray);
}

References write_rgb_or_gray_to_file().

Referenced by Slic3r::GUI::anonymous_namespace{TextureLibrary.cpp}::encode_gray_png_bytes(), write_gray_to_file(), and write_gray_to_file().

Here is the call graph for this function:

Here is the caller graph for this function:

write_gray_to_file() [2/3]

bool Slic3r::png::write_gray_to_file	(	const std::string &	file_name_utf8,
		size_t	width,
		size_t	height,
		const std::vector< uint8_t > &	data_gray )

{
    assert(width * height == data_gray.size());
    return write_gray_to_file(file_name_utf8.c_str(), width, height, data_gray.data());
}

References write_gray_to_file().

Here is the call graph for this function:

write_gray_to_file() [3/3]

bool Slic3r::png::write_gray_to_file	(	const std::string &	file_name_utf8,
		size_t	width,
		size_t	height,
		const uint8_t *	data_gray )

{
    return write_gray_to_file(file_name_utf8.c_str(), width, height, data_gray);
}

References write_gray_to_file().

Here is the call graph for this function:

write_gray_to_file_scaled() [1/3]

bool Slic3r::png::write_gray_to_file_scaled	(	const char *	file_name_utf8,
		size_t	width,
		size_t	height,
		const uint8_t *	data_gray,
		size_t	scale )

{
    return write_rgb_or_gray_to_file_scaled(file_name_utf8, width, height, PNG_COLOR_TYPE_GRAY, data_gray, scale);
}

References scale(), and write_rgb_or_gray_to_file_scaled().

Referenced by Slic3r::SupportGridPattern::SupportGridPattern(), write_gray_to_file_scaled(), and write_gray_to_file_scaled().

Here is the call graph for this function:

Here is the caller graph for this function:

write_gray_to_file_scaled() [2/3]

bool Slic3r::png::write_gray_to_file_scaled	(	const std::string &	file_name_utf8,
		size_t	width,
		size_t	height,
		const std::vector< uint8_t > &	data_gray,
		size_t	scale )

{
    assert(width * height == data_gray.size());
    return write_gray_to_file_scaled(file_name_utf8.c_str(), width, height, data_gray.data(), scale);
}

References scale(), and write_gray_to_file_scaled().

Here is the call graph for this function:

write_gray_to_file_scaled() [3/3]

bool Slic3r::png::write_gray_to_file_scaled	(	const std::string &	file_name_utf8,
		size_t	width,
		size_t	height,
		const uint8_t *	data_gray,
		size_t	scale )

{
    return write_gray_to_file_scaled(file_name_utf8.c_str(), width, height, data_gray, scale);
}

References scale(), and write_gray_to_file_scaled().

Here is the call graph for this function:

write_rgb_or_gray_to_file()

bool Slic3r::png::write_rgb_or_gray_to_file ( const char * file_name_utf8, size_t width, size_t height, int png_color_type, const uint8_t * data )

static

{
    bool         result       = false;
 
    // Forward declaration due to the gotos.
    png_structp  png_ptr      = nullptr;
    png_infop    info_ptr     = nullptr;
    png_byte   **row_pointers = nullptr;
 
    FILE        *fp = boost::nowide::fopen(file_name_utf8, "wb");
    if (! fp) {
        BOOST_LOG_TRIVIAL(error) << "write_png_file: File could not be opened for writing: " << file_name_utf8;
        goto fopen_failed;
    }
 
    png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, nullptr, nullptr, nullptr);
    if (! png_ptr) {
        BOOST_LOG_TRIVIAL(error) << "write_png_file: png_create_write_struct() failed";
        goto png_create_write_struct_failed;
    }
 
    info_ptr = png_create_info_struct(png_ptr);
    if (! info_ptr) {
        BOOST_LOG_TRIVIAL(error) << "write_png_file: png_create_info_struct() failed";
        goto png_create_info_struct_failed;
    }
 
    // Set up error handling.
    if (setjmp(png_jmpbuf(png_ptr))) {
        BOOST_LOG_TRIVIAL(error) << "write_png_file: setjmp() failed";
        goto png_failure;
    }
 
    // Set image attributes.
    png_set_IHDR(png_ptr,
        info_ptr,
        png_uint_32(width),
        png_uint_32(height),
        8, // depth
        png_color_type,
        PNG_INTERLACE_NONE,
        PNG_COMPRESSION_TYPE_DEFAULT,
        PNG_FILTER_TYPE_DEFAULT);
 
    // Initialize rows of PNG.
    row_pointers = reinterpret_cast<png_byte**>(::png_malloc(png_ptr, height * sizeof(png_byte*)));
    {
        int line_width = width;
        if (png_color_type == PNG_COLOR_TYPE_RGB)
            line_width *= 3;
        for (size_t y = 0; y < height; ++ y) {
            auto row = reinterpret_cast<png_byte*>(::png_malloc(png_ptr, line_width));
            row_pointers[y] = row;
            memcpy(row, data + line_width * y, line_width);
        }
    }
 
    // Write the image data to "fp".
    png_init_io(png_ptr, fp);
    png_set_rows(png_ptr, info_ptr, row_pointers);
    png_write_png(png_ptr, info_ptr, PNG_TRANSFORM_IDENTITY, nullptr);
 
    for (size_t y = 0; y < height; ++ y)
        png_free(png_ptr, row_pointers[y]);
    png_free(png_ptr, row_pointers);
 
    result = true;
 
png_failure:
png_create_info_struct_failed:
    ::png_destroy_write_struct(&png_ptr, &info_ptr);
png_create_write_struct_failed:
    ::fclose(fp);
fopen_failed:
    return result;
}

Referenced by write_gray_to_file(), write_rgb_or_gray_to_file_scaled(), and write_rgb_to_file().

Here is the caller graph for this function:

write_rgb_or_gray_to_file_scaled()

bool Slic3r::png::write_rgb_or_gray_to_file_scaled ( const char * file_name_utf8, size_t width, size_t height, int png_color_type, const uint8_t * data, size_t scale )

static

{
    if (scale <= 1)
        return write_rgb_or_gray_to_file(file_name_utf8, width, height, png_color_type, data);
    else {
        size_t pixel_bytes = png_color_type == PNG_COLOR_TYPE_RGB ? 3 : 1;
        size_t line_width  = width * pixel_bytes;
        std::vector<uint8_t> scaled(line_width * height * scale * scale);
        uint8_t *dst = scaled.data();
        for (size_t r = 0; r < height; ++ r) {
            for (size_t repr = 0; repr < scale; ++ repr) {
                const uint8_t *row = data + line_width * r;
                for (size_t c = 0; c < width; ++ c) {
                    for (size_t repc = 0; repc < scale; ++ repc)
                        for (size_t b = 0; b < pixel_bytes; ++ b)
                            *dst ++ = row[b];
                    row += pixel_bytes;
                }
            }
        }
        return write_rgb_or_gray_to_file(file_name_utf8, width * scale, height * scale, png_color_type, scaled.data());
    }
}

References scale(), Slic3r::scaled(), and write_rgb_or_gray_to_file().

Referenced by write_gray_to_file_scaled(), and write_rgb_to_file_scaled().

Here is the call graph for this function:

Here is the caller graph for this function:

write_rgb_to_file() [1/3]

bool Slic3r::png::write_rgb_to_file	(	const char *	file_name_utf8,
		size_t	width,
		size_t	height,
		const uint8_t *	data_rgb )

{
    return write_rgb_or_gray_to_file(file_name_utf8, width, height, PNG_COLOR_TYPE_RGB, data_rgb);
}

References write_rgb_or_gray_to_file().

Referenced by write_rgb_to_file(), and write_rgb_to_file().

Here is the call graph for this function:

Here is the caller graph for this function:

write_rgb_to_file() [2/3]

bool Slic3r::png::write_rgb_to_file	(	const std::string &	file_name_utf8,
		size_t	width,
		size_t	height,
		const std::vector< uint8_t > &	data_rgb )

{
    assert(width * height * 3 == data_rgb.size());
    return write_rgb_to_file(file_name_utf8.c_str(), width, height, data_rgb.data());
}

References write_rgb_to_file().

Here is the call graph for this function:

write_rgb_to_file() [3/3]

bool Slic3r::png::write_rgb_to_file	(	const std::string &	file_name_utf8,
		size_t	width,
		size_t	height,
		const uint8_t *	data_rgb )

{
    return write_rgb_to_file(file_name_utf8.c_str(), width, height, data_rgb);
}

References write_rgb_to_file().

Here is the call graph for this function:

write_rgb_to_file_scaled() [1/3]

bool Slic3r::png::write_rgb_to_file_scaled	(	const char *	file_name_utf8,
		size_t	width,
		size_t	height,
		const uint8_t *	data_rgb,
		size_t	scale )

{
    return write_rgb_or_gray_to_file_scaled(file_name_utf8, width, height, PNG_COLOR_TYPE_RGB, data_rgb, scale);
}

References scale(), and write_rgb_or_gray_to_file_scaled().

Referenced by Slic3r::EdgeGrid::Grid::calculate_sdf(), Slic3r::EdgeGrid::save_png(), write_rgb_to_file_scaled(), and write_rgb_to_file_scaled().

Here is the call graph for this function:

Here is the caller graph for this function:

write_rgb_to_file_scaled() [2/3]

bool Slic3r::png::write_rgb_to_file_scaled	(	const std::string &	file_name_utf8,
		size_t	width,
		size_t	height,
		const std::vector< uint8_t > &	data_rgb,
		size_t	scale )

{
    assert(width * height * 3 == data_rgb.size());
    return write_rgb_to_file_scaled(file_name_utf8.c_str(), width, height, data_rgb.data(), scale);
}

References scale(), and write_rgb_to_file_scaled().

Here is the call graph for this function:

write_rgb_to_file_scaled() [3/3]

bool Slic3r::png::write_rgb_to_file_scaled	(	const std::string &	file_name_utf8,
		size_t	width,
		size_t	height,
		const uint8_t *	data_rgb,
		size_t	scale )

{
    return write_rgb_to_file_scaled(file_name_utf8.c_str(), width, height, data_rgb, scale);
}

References scale(), and write_rgb_to_file_scaled().

Here is the call graph for this function: