oneechanhax/libglez
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 4 Wiki Activity

Reformatted all files

Browse Source
This commit is contained in:
Rebekah 2022-04-04 16:56:17 -04:00
parent 8c29b72961
commit 72d8bf1644
Signed by: oneechanhax
GPG Key ID: 183EB7902964DAE5
15 changed files with 856 additions and 748 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

84
clang-format-all
View File

@ -1,84 +0,0 @@
#!/bin/bash
#
# clang-format-all: a tool to run clang-format on an entire project
# Copyright (C) 2016 Evan Klitzke <evan@eklitzke.org>
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
function usage {
echo "Usage: $0 DIR..."
exit 1
}
if [ $# -eq 0 ]; then
usage
fi
# Variable that will hold the name of the clang-format command
FMT=""
# Some distros just call it clang-format. Others (e.g. Ubuntu) are insistent
# that the version number be part of the command. We prefer clang-format if
# that's present, otherwise we work backwards from highest version to lowest
# version.
for clangfmt in clang-format{,-{4,3}.{9,8,7,6,5,4,3,2,1,0}}; do
if which "$clangfmt" &>/dev/null; then
FMT="$clangfmt"
break
fi
done
# Check if we found a working clang-format
if [ -z "$FMT" ]; then
echo "failed to find clang-format"
exit 1
fi
# Check all of the arguments first to make sure they're all directories
for dir in "$@"; do
if [ ! -d "${dir}" ]; then
echo "${dir} is not a directory"
usage
fi
done
# Find a dominating file, starting from a given directory and going up.
find-dominating-file() {
if [ -r "$1"/"$2" ]; then
return 0
fi
if [ "$1" = "/" ]; then
return 1
fi
find-dominating-file "$(realpath "$1"/..)" "$2"
return $?
}
# Run clang-format -i on all of the things
for dir in "$@"; do
pushd "${dir}" &>/dev/null
if ! find-dominating-file . .clang-format; then
echo "Failed to find dominating .clang-format starting at $PWD"
continue
fi
find . \
\( -name '*.c' \
-o -name '*.cc' \
-o -name '*.cpp' \
-o -name '*.h' \
-o -name '*.hh' \
-o -name '*.hpp' \) \
-exec "${FMT}" -i '{}' \;
popd &>/dev/null
done

12
include/glez/color.hpp
View File

@ -10,11 +10,15 @@ namespace glez {
struct rgba {
rgba() = default;
inline constexpr rgba(int r, int g, int b)
: r(r / 255.0f), g(g / 255.0f), b(b / 255.0f), a(1.0f)
{}
: r(r / 255.0f)
, g(g / 255.0f)
, b(b / 255.0f)
, a(1.0f) { }
inline constexpr rgba(int r, int g, int b, int a)
: r(r / 255.0f), g(g / 255.0f), b(b / 255.0f), a(a / 255.0f)
{}
: r(r / 255.0f)
, g(g / 255.0f)
, b(b / 255.0f)
, a(a / 255.0f) { }
float r;
float g;

10
include/glez/detail/record.hpp
View File

@ -4,21 +4,19 @@
#pragma once
#include <vector>
#include <cstdint>
#include <glez/texture.hpp>
#include <freetype-gl.h>
#include <glez/font.hpp>
#include <glez/glez.hpp>
#include <glez/texture.hpp>
#include <vector>
#include <vertex-buffer.h>
#include <glez/font.hpp>
#include <freetype-gl.h>
namespace glez::detail::record {
class RecordedCommands {
public:
struct segment
{
struct segment {
std::size_t start { 0 };
std::size_t size { 0 };
glez::texture* texture { nullptr };

2
include/glez/draw.hpp
View File

@ -5,10 +5,10 @@
#pragma once
#include <string>
#include "color.hpp"
#include "font.hpp"
#include "texture.hpp"
#include <string>
namespace glez::draw {

3
include/glez/font.hpp
View File

@ -23,9 +23,10 @@ public:
// void stringSize(std::string_view string, float* width, float* height);
void stringSize(const std::string& string, float* width, float* height);
inline bool isLoaded() { return this->m_font != nullptr && this->atlas != nullptr; };
public:
texture_font_t* m_font = nullptr;
texture_atlas_t* atlas = nullptr;
};
} // namespace glez::detail::font
} // namespace glez

4
include/glez/glez.hpp
View File

@ -5,9 +5,9 @@
#pragma once
#include <vertex-buffer.h>
#include <freetype-gl.h>
#include <glez/color.hpp>
#include <vertex-buffer.h>
namespace glez {
@ -33,4 +33,4 @@ struct vertex {
void bind(GLuint texture);
}; // namespace glez::detail::program
}; // namespace glez

9
include/glez/record.hpp
View File

@ -4,16 +4,13 @@
#pragma once
namespace glez::detail::record
{
namespace glez::detail::record {
class RecordedCommands;
}
namespace glez::record
{
namespace glez::record {
class Record
{
class Record {
public:
Record();
~Record();

12
include/glez/texture.hpp
View File

@ -5,13 +5,12 @@
#pragma once
#include <freetype-gl.h>
#include <string>
#include <limits>
#include <cstddef>
#include <freetype-gl.h>
#include <limits>
#include <string>
namespace glez
{
namespace glez {
class texture {
public:
@ -26,6 +25,7 @@ public:
void bind();
inline bool isLoaded() { return this->init; }
public:
bool init = false;
bool bound = false;
@ -36,4 +36,4 @@ public:
GLubyte* data;
};
} // namespace glez::texture
} // namespace glez

42
src/detail/record.cpp
View File

@ -3,23 +3,20 @@
*/
#include <cstddef>
#include <glez/detail/record.hpp>
#include <glez/record.hpp>
#include <glez/glez.hpp>
#include <cstring>
#include <glez/detail/record.hpp>
#include <glez/glez.hpp>
#include <glez/record.hpp>
namespace glez::detail::record
{
namespace glez::detail::record {
void RecordedCommands::render()
{
void RecordedCommands::render() {
isReplaying = true;
vertex_buffer_render_setup(vertex_buffer, GL_TRIANGLES);
for (const auto& i : segments) {
if (i.texture) {
i.texture->bind();
}
else if (i.font) {
} else if (i.font) {
if (i.font->atlas->id == 0) {
glGenTextures(1, &i.font->atlas->id);
}
@ -68,17 +65,14 @@ void RecordedCommands::bindTexture(glez::texture *tx) {
}
}
void RecordedCommands::bindFont(glez::font *font)
{
if (current.font != font)
{
void RecordedCommands::bindFont(glez::font* font) {
if (current.font != font) {
cutSegment();
current.font = font;
}
}
void RecordedCommands::cutSegment()
{
void RecordedCommands::cutSegment() {
current.size = vertex_buffer->indices->size - current.start;
if (current.size)
segments.push_back(current);
@ -86,8 +80,7 @@ void RecordedCommands::cutSegment()
current.start = vertex_buffer->indices->size;
}
void RecordedCommands::end()
{
void RecordedCommands::end() {
cutSegment();
}
@ -96,29 +89,24 @@ bool isReplaying{ false };
} // namespace glez::detail::record
glez::record::Record::Record()
{
glez::record::Record::Record() {
commands = new glez::detail::record::RecordedCommands {};
}
glez::record::Record::~Record()
{
glez::record::Record::~Record() {
delete commands;
}
void glez::record::Record::begin()
{
void glez::record::Record::begin() {
detail::record::currentRecord = commands;
commands->reset();
}
void glez::record::Record::end()
{
void glez::record::Record::end() {
commands->end();
detail::record::currentRecord = nullptr;
}
void glez::record::Record::replay()
{
void glez::record::Record::replay() {
commands->render();
}

13
src/draw.cpp
View File

@ -4,18 +4,17 @@
*/
#include <cassert>
#include <cmath>
#include <cstring>
#include <glez/detail/record.hpp>
#include <glez/detail/render.hpp>
#include <glez/draw.hpp>
#include <glez/font.hpp>
#include <glez/detail/render.hpp>
#include <glez/glez.hpp>
#include <vertex-buffer.h>
#include <cstring>
#include <glez/texture.hpp>
#include <cmath>
#include <glez/detail/record.hpp>
#include <vertex-buffer.h>
namespace indices
{
namespace indices {
static GLuint rectangle[6] = { 0, 1, 2, 2, 3, 0 };
static GLuint triangle[3] = { 0, 1, 2 };

11
src/font.cpp
View File

@ -3,10 +3,10 @@
Copyright (c) 2018 nullworks. All rights reserved.
*/
#include <glez/font.hpp>
#include <vector>
#include <memory>
#include <cassert>
#include <glez/font.hpp>
#include <memory>
#include <vector>
namespace glez {
@ -46,8 +46,7 @@ void font::stringSize(const std::string& string, float* width, float* height) {
const char* sstring = string.c_str();
for (size_t i = 0; i < string.size(); ++i)
{
for (size_t i = 0; i < string.size(); ++i) {
// c_str guarantees a NULL terminator
texture_glyph_t* glyph = texture_font_find_glyph(m_font, &sstring[i]);
if (glyph == nullptr)
@ -68,4 +67,4 @@ void font::stringSize(const std::string& string, float* width, float* height) {
*height = size_y;
}
} // namespace glez::detail::font
} // namespace glez

24
src/glez.cpp
View File

@ -3,18 +3,17 @@
Copyright (c) 2018 nullworks. All rights reserved.
*/
#include <freetype-gl.h>
#include <vertex-buffer.h>
#include <mat4.h>
#include <glez/glez.hpp>
#include <cstdio>
#include <stdexcept>
#include <cassert>
#include <cstdio>
#include <cstring>
#include <freetype-gl.h>
#include <glez/detail/record.hpp>
#include <glez/detail/render.hpp>
#include <glez/font.hpp>
#include <cstring>
#include <glez/glez.hpp>
#include <glez/detail/record.hpp>
#include <mat4.h>
#include <stdexcept>
#include <vertex-buffer.h>
static const char* shader_vertex = R"END(
#version 130
@ -70,8 +69,7 @@ static GLuint compile(const char *source, GLenum type) {
glCompileShader(result);
glGetShaderiv(result, GL_COMPILE_STATUS, &status);
if (status != GL_TRUE)
{
if (status != GL_TRUE) {
char error[512];
GLsizei length;
glGetShaderInfoLog(result, 512, &length, error);
@ -113,8 +111,7 @@ void resize(int width, int height) {
glUseProgram(0);
}
void init(int width, int height)
{
void init(int width, int height) {
buffer = ftgl::vertex_buffer_new("vertex:2f,tex_coord:2f,color:4f,drawmode:1i");
shader = link(compile(shader_vertex, GL_VERTEX_SHADER), compile(shader_fragment, GL_FRAGMENT_SHADER));
@ -132,7 +129,6 @@ void shutdown() {
static GLuint current_texture { 0 };
void begin() {
glPushAttrib(GL_CURRENT_BIT | GL_ENABLE_BIT | GL_TEXTURE_BIT | GL_COLOR_BUFFER_BIT);
@ -183,4 +179,4 @@ void bind(GLuint texture) {
}
}
}
} // namespace glez

683
src/picopng/picopng.cpp
View File

@ -1,5 +1,5 @@
#include <vector>
#include <stddef.h>
#include <vector>
/*
decodePNG: The picoPNG function, decodes a PNG file buffer in memory, into a raw pixel buffer.
out_image: output parameter, this will contain the raw pixels after decoding.
@ -20,8 +20,7 @@ convert_to_rgba32: optional parameter, true by default.
works for trusted PNG files. Use LodePNG instead of picoPNG if you need this information.
return: 0 if success, not 0 if some error occured.
*/
int decodePNG(unsigned char* &out_image, int& image_width, int& image_height, const unsigned char* in_png, size_t in_size, bool convert_to_rgba32 = true)
{
int decodePNG(unsigned char*& out_image, int& image_width, int& image_height, const unsigned char* in_png, size_t in_size, bool convert_to_rgba32 = true) {
// picoPNG version 20101224
// Copyright (c) 2005-2010 Lode Vandevenne
//
@ -55,41 +54,55 @@ int decodePNG(unsigned char* &out_image, int& image_width, int& image_height, co
static const unsigned long CLCL[19] = { 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15 }; // code length code lengths
struct Zlib // nested functions for zlib decompression
{
static unsigned long readBitFromStream(size_t& bitp, const unsigned char* bits) { unsigned long result = (bits[bitp >> 3] >> (bitp & 0x7)) & 1; bitp++; return result;}
static unsigned long readBitsFromStream(size_t& bitp, const unsigned char* bits, size_t nbits)
{
unsigned long result = 0;
for(size_t i = 0; i < nbits; i++) result += (readBitFromStream(bitp, bits)) << i;
static unsigned long readBitFromStream(size_t& bitp, const unsigned char* bits) {
unsigned long result = (bits[bitp >> 3] >> (bitp & 0x7)) & 1;
bitp++;
return result;
}
struct HuffmanTree
{
int makeFromLengths(const std::vector<unsigned long>& bitlen, unsigned long maxbitlen)
{ //make tree given the lengths
static unsigned long readBitsFromStream(size_t& bitp, const unsigned char* bits, size_t nbits) {
unsigned long result = 0;
for (size_t i = 0; i < nbits; i++)
result += (readBitFromStream(bitp, bits)) << i;
return result;
}
struct HuffmanTree {
int makeFromLengths(const std::vector<unsigned long>& bitlen, unsigned long maxbitlen) { // make tree given the lengths
unsigned long numcodes = (unsigned long)(bitlen.size()), treepos = 0, nodefilled = 0;
std::vector<unsigned long> tree1d(numcodes), blcount(maxbitlen + 1, 0), nextcode(maxbitlen + 1, 0);
for(unsigned long bits = 0; bits < numcodes; bits++) blcount[bitlen[bits]]++; //count number of instances of each code length
for(unsigned long bits = 1; bits <= maxbitlen; bits++) nextcode[bits] = (nextcode[bits - 1] + blcount[bits - 1]) << 1;
for(unsigned long n = 0; n < numcodes; n++) if(bitlen[n] != 0) tree1d[n] = nextcode[bitlen[n]]++; //generate all the codes
tree2d.clear(); tree2d.resize(numcodes * 2, 32767); //32767 here means the tree2d isn't filled there yet
for (unsigned long bits = 0; bits < numcodes; bits++)
blcount[bitlen[bits]]++; // count number of instances of each code length
for (unsigned long bits = 1; bits <= maxbitlen; bits++)
nextcode[bits] = (nextcode[bits - 1] + blcount[bits - 1]) << 1;
for (unsigned long n = 0; n < numcodes; n++)
if (bitlen[n] != 0)
tree1d[n] = nextcode[bitlen[n]]++; // generate all the codes
tree2d.clear();
tree2d.resize(numcodes * 2, 32767); // 32767 here means the tree2d isn't filled there yet
for (unsigned long n = 0; n < numcodes; n++) // the codes
for (unsigned long i = 0; i < bitlen[n]; i++) // the bits for this code
{
unsigned long bit = (tree1d[n] >> (bitlen[n] - i - 1)) & 1;
if(treepos > numcodes - 2) return 55;
if (treepos > numcodes - 2)
return 55;
if (tree2d[2 * treepos + bit] == 32767) // not yet filled in
{
if(i + 1 == bitlen[n]) { tree2d[2 * treepos + bit] = n; treepos = 0; } //last bit
else { tree2d[2 * treepos + bit] = ++nodefilled + numcodes; treepos = nodefilled; } //addresses are encoded as values > numcodes
}
else treepos = tree2d[2 * treepos + bit] - numcodes; //subtract numcodes from address to get address value
if (i + 1 == bitlen[n]) {
tree2d[2 * treepos + bit] = n;
treepos = 0;
} // last bit
else {
tree2d[2 * treepos + bit] = ++nodefilled + numcodes;
treepos = nodefilled;
} // addresses are encoded as values > numcodes
} else
treepos = tree2d[2 * treepos + bit] - numcodes; // subtract numcodes from address to get address value
}
return 0;
}
int decode(bool& decoded, unsigned long& result, size_t& treepos, unsigned long bit) const
{ //Decodes a symbol from the tree
int decode(bool& decoded, unsigned long& result, size_t& treepos, unsigned long bit) const { // Decodes a symbol from the tree
unsigned long numcodes = (unsigned long)tree2d.size() / 2;
if(treepos >= numcodes) return 11; //error: you appeared outside the codetree
if (treepos >= numcodes)
return 11; // error: you appeared outside the codetree
result = tree2d[2 * treepos + bit];
decoded = (result < numcodes);
treepos = decoded ? 0 : result - numcodes;
@ -97,219 +110,353 @@ int decodePNG(unsigned char* &out_image, int& image_width, int& image_height, co
}
std::vector<unsigned long> tree2d; // 2D representation of a huffman tree: The one dimension is "0" or "1", the other contains all nodes and leaves of the tree.
};
struct Inflator
{
struct Inflator {
int error;
void inflate(std::vector<unsigned char>& out, const std::vector<unsigned char>& in, size_t inpos = 0)
{
void inflate(std::vector<unsigned char>& out, const std::vector<unsigned char>& in, size_t inpos = 0) {
size_t bp = 0, pos = 0; // bit pointer and byte pointer
error = 0;
unsigned long BFINAL = 0;
while(!BFINAL && !error)
{
if(bp >> 3 >= in.size()) { error = 52; return; } //error, bit pointer will jump past memory
while (!BFINAL && !error) {
if (bp >> 3 >= in.size()) {
error = 52;
return;
} // error, bit pointer will jump past memory
BFINAL = readBitFromStream(bp, &in[inpos]);
unsigned long BTYPE = readBitFromStream(bp, &in[inpos]); BTYPE += 2 * readBitFromStream(bp, &in[inpos]);
if(BTYPE == 3) { error = 20; return; } //error: invalid BTYPE
else if(BTYPE == 0) inflateNoCompression(out, &in[inpos], bp, pos, in.size());
else inflateHuffmanBlock(out, &in[inpos], bp, pos, in.size(), BTYPE);
unsigned long BTYPE = readBitFromStream(bp, &in[inpos]);
BTYPE += 2 * readBitFromStream(bp, &in[inpos]);
if (BTYPE == 3) {
error = 20;
return;
} // error: invalid BTYPE
else if (BTYPE == 0)
inflateNoCompression(out, &in[inpos], bp, pos, in.size());
else
inflateHuffmanBlock(out, &in[inpos], bp, pos, in.size(), BTYPE);
}
if(!error) out.resize(pos); //Only now we know the true size of out, resize it to that
if (!error)
out.resize(pos); // Only now we know the true size of out, resize it to that
}
void generateFixedTrees(HuffmanTree& tree, HuffmanTree& treeD) // get the tree of a deflated block with fixed tree
{
std::vector<unsigned long> bitlen(288, 8), bitlenD(32, 5);;
for(size_t i = 144; i <= 255; i++) bitlen[i] = 9;
for(size_t i = 256; i <= 279; i++) bitlen[i] = 7;
std::vector<unsigned long> bitlen(288, 8), bitlenD(32, 5);
;
for (size_t i = 144; i <= 255; i++)
bitlen[i] = 9;
for (size_t i = 256; i <= 279; i++)
bitlen[i] = 7;
tree.makeFromLengths(bitlen, 15);
treeD.makeFromLengths(bitlenD, 15);
}
HuffmanTree codetree, codetreeD, codelengthcodetree; // the code tree for Huffman codes, dist codes, and code length codes
unsigned long huffmanDecodeSymbol(const unsigned char* in, size_t& bp, const HuffmanTree& codetree, size_t inlength)
{ //decode a single symbol from given list of bits with given code tree. return value is the symbol
bool decoded; unsigned long ct;
for(size_t treepos = 0;;)
{
if((bp & 0x07) == 0 && (bp >> 3) > inlength) { error = 10; return 0; } //error: end reached without endcode
error = codetree.decode(decoded, ct, treepos, readBitFromStream(bp, in)); if(error) return 0; //stop, an error happened
if(decoded) return ct;
unsigned long huffmanDecodeSymbol(const unsigned char* in, size_t& bp, const HuffmanTree& codetree, size_t inlength) { // decode a single symbol from given list of bits with given code tree. return value is the symbol
bool decoded;
unsigned long ct;
for (size_t treepos = 0;;) {
if ((bp & 0x07) == 0 && (bp >> 3) > inlength) {
error = 10;
return 0;
} // error: end reached without endcode
error = codetree.decode(decoded, ct, treepos, readBitFromStream(bp, in));
if (error)
return 0; // stop, an error happened
if (decoded)
return ct;
}
}
void getTreeInflateDynamic(HuffmanTree& tree, HuffmanTree& treeD, const unsigned char* in, size_t& bp, size_t inlength)
{ //get the tree of a deflated block with dynamic tree, the tree itself is also Huffman compressed with a known tree
void getTreeInflateDynamic(HuffmanTree& tree, HuffmanTree& treeD, const unsigned char* in, size_t& bp, size_t inlength) { // get the tree of a deflated block with dynamic tree, the tree itself is also Huffman compressed with a known tree
std::vector<unsigned long> bitlen(288, 0), bitlenD(32, 0);
if(bp >> 3 >= inlength - 2) { error = 49; return; } //the bit pointer is or will go past the memory
if (bp >> 3 >= inlength - 2) {
error = 49;
return;
} // the bit pointer is or will go past the memory
size_t HLIT = readBitsFromStream(bp, in, 5) + 257; // number of literal/length codes + 257
size_t HDIST = readBitsFromStream(bp, in, 5) + 1; // number of dist codes + 1
size_t HCLEN = readBitsFromStream(bp, in, 4) + 4; // number of code length codes + 4
std::vector<unsigned long> codelengthcode(19); // lengths of tree to decode the lengths of the dynamic tree
for(size_t i = 0; i < 19; i++) codelengthcode[CLCL[i]] = (i < HCLEN) ? readBitsFromStream(bp, in, 3) : 0;
error = codelengthcodetree.makeFromLengths(codelengthcode, 7); if(error) return;
for (size_t i = 0; i < 19; i++)
codelengthcode[CLCL[i]] = (i < HCLEN) ? readBitsFromStream(bp, in, 3) : 0;
error = codelengthcodetree.makeFromLengths(codelengthcode, 7);
if (error)
return;
size_t i = 0, replength;
while(i < HLIT + HDIST)
{
unsigned long code = huffmanDecodeSymbol(in, bp, codelengthcodetree, inlength); if(error) return;
if(code <= 15) { if(i < HLIT) bitlen[i++] = code; else bitlenD[i++ - HLIT] = code; } //a length code
while (i < HLIT + HDIST) {
unsigned long code = huffmanDecodeSymbol(in, bp, codelengthcodetree, inlength);
if (error)
return;
if (code <= 15) {
if (i < HLIT)
bitlen[i++] = code;
else
bitlenD[i++ - HLIT] = code;
} // a length code
else if (code == 16) // repeat previous
{
if(bp >> 3 >= inlength) { error = 50; return; } //error, bit pointer jumps past memory
if (bp >> 3 >= inlength) {
error = 50;
return;
} // error, bit pointer jumps past memory
replength = 3 + readBitsFromStream(bp, in, 2);
unsigned long value; // set value to the previous code
if((i - 1) < HLIT) value = bitlen[i - 1];
else value = bitlenD[i - HLIT - 1];
if ((i - 1) < HLIT)
value = bitlen[i - 1];
else
value = bitlenD[i - HLIT - 1];
for (size_t n = 0; n < replength; n++) // repeat this value in the next lengths
{
if(i >= HLIT + HDIST) { error = 13; return; } //error: i is larger than the amount of codes
if(i < HLIT) bitlen[i++] = value; else bitlenD[i++ - HLIT] = value;
if (i >= HLIT + HDIST) {
error = 13;
return;
} // error: i is larger than the amount of codes
if (i < HLIT)
bitlen[i++] = value;
else
bitlenD[i++ - HLIT] = value;
}
}
else if(code == 17) //repeat "0" 3-10 times
} else if (code == 17) // repeat "0" 3-10 times
{
if(bp >> 3 >= inlength) { error = 50; return; } //error, bit pointer jumps past memory
if (bp >> 3 >= inlength) {
error = 50;
return;
} // error, bit pointer jumps past memory
replength = 3 + readBitsFromStream(bp, in, 3);
for (size_t n = 0; n < replength; n++) // repeat this value in the next lengths
{
if(i >= HLIT + HDIST) { error = 14; return; } //error: i is larger than the amount of codes
if(i < HLIT) bitlen[i++] = 0; else bitlenD[i++ - HLIT] = 0;
if (i >= HLIT + HDIST) {
error = 14;
return;
} // error: i is larger than the amount of codes
if (i < HLIT)
bitlen[i++] = 0;
else
bitlenD[i++ - HLIT] = 0;
}
}
else if(code == 18) //repeat "0" 11-138 times
} else if (code == 18) // repeat "0" 11-138 times
{
if(bp >> 3 >= inlength) { error = 50; return; } //error, bit pointer jumps past memory
if (bp >> 3 >= inlength) {
error = 50;
return;
} // error, bit pointer jumps past memory
replength = 11 + readBitsFromStream(bp, in, 7);
for (size_t n = 0; n < replength; n++) // repeat this value in the next lengths
{
if(i >= HLIT + HDIST) { error = 15; return; } //error: i is larger than the amount of codes
if(i < HLIT) bitlen[i++] = 0; else bitlenD[i++ - HLIT] = 0;
if (i >= HLIT + HDIST) {
error = 15;
return;
} // error: i is larger than the amount of codes
if (i < HLIT)
bitlen[i++] = 0;
else
bitlenD[i++ - HLIT] = 0;
}
} else {
error = 16;
return;
} // error: somehow an unexisting code appeared. This can never happen.
}
else { error = 16; return; } //error: somehow an unexisting code appeared. This can never happen.
if (bitlen[256] == 0) {
error = 64;
return;
} // the length of the end code 256 must be larger than 0
error = tree.makeFromLengths(bitlen, 15);
if (error)
return; // now we've finally got HLIT and HDIST, so generate the code trees, and the function is done
error = treeD.makeFromLengths(bitlenD, 15);
if (error)
return;
}
if(bitlen[256] == 0) { error = 64; return; } //the length of the end code 256 must be larger than 0
error = tree.makeFromLengths(bitlen, 15); if(error) return; //now we've finally got HLIT and HDIST, so generate the code trees, and the function is done
error = treeD.makeFromLengths(bitlenD, 15); if(error) return;
void inflateHuffmanBlock(std::vector<unsigned char>& out, const unsigned char* in, size_t& bp, size_t& pos, size_t inlength, unsigned long btype) {
if (btype == 1) {
generateFixedTrees(codetree, codetreeD);
} else if (btype == 2) {
getTreeInflateDynamic(codetree, codetreeD, in, bp, inlength);
if (error)
return;
}
void inflateHuffmanBlock(std::vector<unsigned char>& out, const unsigned char* in, size_t& bp, size_t& pos, size_t inlength, unsigned long btype)
{
if(btype == 1) { generateFixedTrees(codetree, codetreeD); }
else if(btype == 2) { getTreeInflateDynamic(codetree, codetreeD, in, bp, inlength); if(error) return; }
for(;;)
{
unsigned long code = huffmanDecodeSymbol(in, bp, codetree, inlength); if(error) return;
if(code == 256) return; //end code
for (;;) {
unsigned long code = huffmanDecodeSymbol(in, bp, codetree, inlength);
if (error)
return;
if (code == 256)
return; // end code
else if (code <= 255) // literal symbol
{
if(pos >= out.size()) out.resize((pos + 1) * 2); //reserve more room
if (pos >= out.size())
out.resize((pos + 1) * 2); // reserve more room
out[pos++] = (unsigned char)(code);
}
else if(code >= 257 && code <= 285) //length code
} else if (code >= 257 && code <= 285) // length code
{
size_t length = LENBASE[code - 257], numextrabits = LENEXTRA[code - 257];
if((bp >> 3) >= inlength) { error = 51; return; } //error, bit pointer will jump past memory
if ((bp >> 3) >= inlength) {
error = 51;
return;
} // error, bit pointer will jump past memory
length += readBitsFromStream(bp, in, numextrabits);
unsigned long codeD = huffmanDecodeSymbol(in, bp, codetreeD, inlength); if(error) return;
if(codeD > 29) { error = 18; return; } //error: invalid dist code (30-31 are never used)
unsigned long codeD = huffmanDecodeSymbol(in, bp, codetreeD, inlength);
if (error)
return;
if (codeD > 29) {
error = 18;
return;
} // error: invalid dist code (30-31 are never used)
unsigned long dist = DISTBASE[codeD], numextrabitsD = DISTEXTRA[codeD];
if((bp >> 3) >= inlength) { error = 51; return; } //error, bit pointer will jump past memory
if ((bp >> 3) >= inlength) {
error = 51;
return;
} // error, bit pointer will jump past memory
dist += readBitsFromStream(bp, in, numextrabitsD);
size_t start = pos, back = start - dist; // backwards
if(pos + length >= out.size()) out.resize((pos + length) * 2); //reserve more room
for(size_t i = 0; i < length; i++) { out[pos++] = out[back++]; if(back >= start) back = start - dist; }
if (pos + length >= out.size())
out.resize((pos + length) * 2); // reserve more room
for (size_t i = 0; i < length; i++) {
out[pos++] = out[back++];
if (back >= start)
back = start - dist;
}
}
}
void inflateNoCompression(std::vector<unsigned char>& out, const unsigned char* in, size_t& bp, size_t& pos, size_t inlength)
{
while((bp & 0x7) != 0) bp++; //go to first boundary of byte
}
void inflateNoCompression(std::vector<unsigned char>& out, const unsigned char* in, size_t& bp, size_t& pos, size_t inlength) {
while ((bp & 0x7) != 0)
bp++; // go to first boundary of byte
size_t p = bp / 8;
if(p >= inlength - 4) { error = 52; return; } //error, bit pointer will jump past memory
unsigned long LEN = in[p] + 256 * in[p + 1], NLEN = in[p + 2] + 256 * in[p + 3]; p += 4;
if(LEN + NLEN != 65535) { error = 21; return; } //error: NLEN is not one's complement of LEN
if(pos + LEN >= out.size()) out.resize(pos + LEN);
if(p + LEN > inlength) { error = 23; return; } //error: reading outside of in buffer
for(unsigned long n = 0; n < LEN; n++) out[pos++] = in[p++]; //read LEN bytes of literal data
if (p >= inlength - 4) {
error = 52;
return;
} // error, bit pointer will jump past memory
unsigned long LEN = in[p] + 256 * in[p + 1], NLEN = in[p + 2] + 256 * in[p + 3];
p += 4;
if (LEN + NLEN != 65535) {
error = 21;
return;
} // error: NLEN is not one's complement of LEN
if (pos + LEN >= out.size())
out.resize(pos + LEN);
if (p + LEN > inlength) {
error = 23;
return;
} // error: reading outside of in buffer
for (unsigned long n = 0; n < LEN; n++)
out[pos++] = in[p++]; // read LEN bytes of literal data
bp = p * 8;
}
};
int decompress(std::vector<unsigned char>& out, const std::vector<unsigned char>& in) // returns error value
{
Inflator inflator;
if(in.size() < 2) { return 53; } //error, size of zlib data too small
if((in[0] * 256 + in[1]) % 31 != 0) { return 24; } //error: 256 * in[0] + in[1] must be a multiple of 31, the FCHECK value is supposed to be made that way
if (in.size() < 2) {
return 53;
} // error, size of zlib data too small
if ((in[0] * 256 + in[1]) % 31 != 0) {
return 24;
} // error: 256 * in[0] + in[1] must be a multiple of 31, the FCHECK value is supposed to be made that way
unsigned long CM = in[0] & 15, CINFO = (in[0] >> 4) & 15, FDICT = (in[1] >> 5) & 1;
if(CM != 8 || CINFO > 7) { return 25; } //error: only compression method 8: inflate with sliding window of 32k is supported by the PNG spec
if(FDICT != 0) { return 26; } //error: the specification of PNG says about the zlib stream: "The additional flags shall not specify a preset dictionary."
if (CM != 8 || CINFO > 7) {
return 25;
} // error: only compression method 8: inflate with sliding window of 32k is supported by the PNG spec
if (FDICT != 0) {
return 26;
} // error: the specification of PNG says about the zlib stream: "The additional flags shall not specify a preset dictionary."
inflator.inflate(out, in, 2);
return inflator.error; // note: adler32 checksum was skipped and ignored
}
};
struct PNG // nested functions for PNG decoding
{
struct Info
{
struct Info {
unsigned long width, height, colorType, bitDepth, compressionMethod, filterMethod, interlaceMethod, key_r, key_g, key_b;
bool key_defined; // is a transparent color key given?
std::vector<unsigned char> palette;
} info;
int error;
void decode(unsigned char* &out, const unsigned char* in, size_t size, bool convert_to_rgba32)
{
void decode(unsigned char*& out, const unsigned char* in, size_t size, bool convert_to_rgba32) {
error = 0;
if(size == 0 || in == 0) { error = 48; return; } //the given data is empty
readPngHeader(&in[0], size); if(error) return;
if (size == 0 || in == 0) {
error = 48;
return;
} // the given data is empty
readPngHeader(&in[0], size);
if (error)
return;
size_t pos = 33; // first byte of the first chunk after the header
std::vector<unsigned char> idat; // the data from idat chunks
bool IEND = false, known_type = true;
info.key_defined = false;
while (!IEND) // loop through the chunks, ignoring unknown chunks and stopping at IEND chunk. IDAT data is put at the start of the in buffer
{
if(pos + 8 >= size) { error = 30; return; } //error: size of the in buffer too small to contain next chunk
size_t chunkLength = read32bitInt(&in[pos]); pos += 4;
if(chunkLength > 2147483647) { error = 63; return; }
if(pos + chunkLength >= size) { error = 35; return; } //error: size of the in buffer too small to contain next chunk
if (pos + 8 >= size) {
error = 30;
return;
} // error: size of the in buffer too small to contain next chunk
size_t chunkLength = read32bitInt(&in[pos]);
pos += 4;
if (chunkLength > 2147483647) {
error = 63;
return;
}
if (pos + chunkLength >= size) {
error = 35;
return;
} // error: size of the in buffer too small to contain next chunk
if (in[pos + 0] == 'I' && in[pos + 1] == 'D' && in[pos + 2] == 'A' && in[pos + 3] == 'T') // IDAT chunk, containing compressed image data
{
idat.insert(idat.end(), &in[pos + 4], &in[pos + 4 + chunkLength]);
pos += (4 + chunkLength);
}
else if(in[pos + 0] == 'I' && in[pos + 1] == 'E' && in[pos + 2] == 'N' && in[pos + 3] == 'D') { pos += 4; IEND = true; }
else if(in[pos + 0] == 'P' && in[pos + 1] == 'L' && in[pos + 2] == 'T' && in[pos + 3] == 'E') //palette chunk (PLTE)
} else if (in[pos + 0] == 'I' && in[pos + 1] == 'E' && in[pos + 2] == 'N' && in[pos + 3] == 'D') {
pos += 4;
IEND = true;
} else if (in[pos + 0] == 'P' && in[pos + 1] == 'L' && in[pos + 2] == 'T' && in[pos + 3] == 'E') // palette chunk (PLTE)
{
pos += 4; // go after the 4 letters
info.palette.resize(4 * (chunkLength / 3));
if(info.palette.size() > (4 * 256)) { error = 38; return; } //error: palette too big
for(size_t i = 0; i < info.palette.size(); i += 4)
{
for(size_t j = 0; j < 3; j++) info.palette[i + j] = in[pos++]; //RGB
if (info.palette.size() > (4 * 256)) {
error = 38;
return;
} // error: palette too big
for (size_t i = 0; i < info.palette.size(); i += 4) {
for (size_t j = 0; j < 3; j++)
info.palette[i + j] = in[pos++]; // RGB
info.palette[i + 3] = 255; // alpha
}
}
else if(in[pos + 0] == 't' && in[pos + 1] == 'R' && in[pos + 2] == 'N' && in[pos + 3] == 'S') //palette transparency chunk (tRNS)
} else if (in[pos + 0] == 't' && in[pos + 1] == 'R' && in[pos + 2] == 'N' && in[pos + 3] == 'S') // palette transparency chunk (tRNS)
{
pos += 4; // go after the 4 letters
if(info.colorType == 3)
{
if(4 * chunkLength > info.palette.size()) { error = 39; return; } //error: more alpha values given than there are palette entries
for(size_t i = 0; i < chunkLength; i++) info.palette[4 * i + 3] = in[pos++];
}
else if(info.colorType == 0)
{
if(chunkLength != 2) { error = 40; return; } //error: this chunk must be 2 bytes for greyscale image
info.key_defined = 1; info.key_r = info.key_g = info.key_b = 256 * in[pos] + in[pos + 1]; pos += 2;
}
else if(info.colorType == 2)
{
if(chunkLength != 6) { error = 41; return; } //error: this chunk must be 6 bytes for RGB image
if (info.colorType == 3) {
if (4 * chunkLength > info.palette.size()) {
error = 39;
return;
} // error: more alpha values given than there are palette entries
for (size_t i = 0; i < chunkLength; i++)
info.palette[4 * i + 3] = in[pos++];
} else if (info.colorType == 0) {
if (chunkLength != 2) {
error = 40;
return;
} // error: this chunk must be 2 bytes for greyscale image
info.key_defined = 1;
info.key_r = 256 * in[pos] + in[pos + 1]; pos += 2;
info.key_g = 256 * in[pos] + in[pos + 1]; pos += 2;
info.key_b = 256 * in[pos] + in[pos + 1]; pos += 2;
}
else { error = 42; return; } //error: tRNS chunk not allowed for other color models
}
else //it's not an implemented chunk type, so ignore it: skip over the data
info.key_r = info.key_g = info.key_b = 256 * in[pos] + in[pos + 1];
pos += 2;
} else if (info.colorType == 2) {
if (chunkLength != 6) {
error = 41;
return;
} // error: this chunk must be 6 bytes for RGB image
info.key_defined = 1;
info.key_r = 256 * in[pos] + in[pos + 1];
pos += 2;
info.key_g = 256 * in[pos] + in[pos + 1];
pos += 2;
info.key_b = 256 * in[pos] + in[pos + 1];
pos += 2;
} else {
error = 42;
return;
} // error: tRNS chunk not allowed for other color models
} else // it's not an implemented chunk type, so ignore it: skip over the data
{
if(!(in[pos + 0] & 32)) { error = 69; return; } //error: unknown critical chunk (5th bit of first byte of chunk type is 0)
if (!(in[pos + 0] & 32)) {
error = 69;
return;
} // error: unknown critical chunk (5th bit of first byte of chunk type is 0)
pos += (chunkLength + 4); // skip 4 letters and uninterpreted data of unimplemented chunk
known_type = false;
}
@ -318,29 +465,34 @@ int decodePNG(unsigned char* &out_image, int& image_width, int& image_height, co
unsigned long bpp = getBpp(info);
std::vector<unsigned char> scanlines(((info.width * (info.height * bpp + 7)) / 8) + info.height); // now the out buffer will be filled
Zlib zlib; // decompress with the Zlib decompressor
error = zlib.decompress(scanlines, idat); if(error) return; //stop if the zlib decompressor returned an error
error = zlib.decompress(scanlines, idat);
if (error)
return; // stop if the zlib decompressor returned an error
size_t bytewidth = (bpp + 7) / 8, outlength = (info.height * info.width * bpp + 7) / 8;
out = new unsigned char[outlength + 1]; // time to fill the out buffer
if (info.interlaceMethod == 0) // no interlace, just filter
{
size_t linestart = 0, linelength = (info.width * bpp + 7) / 8; // length in bytes of a scanline, excluding the filtertype byte
if (bpp >= 8) // byte per byte
for(unsigned long y = 0; y < info.height; y++)
{
for (unsigned long y = 0; y < info.height; y++) {
unsigned long filterType = scanlines[linestart];
const unsigned char* prevline = (y == 0) ? 0 : &out[(y - 1) * info.width * bytewidth];
unFilterScanline(&out[linestart - y], &scanlines[linestart + 1], prevline, bytewidth, filterType, linelength); if(error) return;
unFilterScanline(&out[linestart - y], &scanlines[linestart + 1], prevline, bytewidth, filterType, linelength);
if (error)
return;
linestart += (1 + linelength); // go to start of next scanline
}
else // less than 8 bits per pixel, so fill it up bit per bit
{
unsigned char* templine = new unsigned char[((info.width * bpp + 7) >> 3) + 1]; // only used if bpp < 8
for(size_t y = 0, obp = 0; y < info.height; y++)
{
for (size_t y = 0, obp = 0; y < info.height; y++) {
unsigned long filterType = scanlines[linestart];
const unsigned char* prevline = (y == 0) ? 0 : &out[(y - 1) * info.width * bytewidth];
unFilterScanline(templine, &scanlines[linestart + 1], prevline, bytewidth, filterType, linelength); if(error) return;
for(size_t bp = 0; bp < info.width * bpp;) setBitOfReversedStream(obp, out, readBitFromReversedStream(bp, &templine[0]));
unFilterScanline(templine, &scanlines[linestart + 1], prevline, bytewidth, filterType, linelength);
if (error)
return;
for (size_t bp = 0; bp < info.width * bpp;)
setBitOfReversedStream(obp, out, readBitFromReversedStream(bp, &templine[0]));
linestart += (1 + linelength); // go to start of next scanline
}
delete[] templine;
@ -354,149 +506,210 @@ int decodePNG(unsigned char* &out_image, int& image_width, int& image_height, co
}
void readPngHeader(const unsigned char* in, size_t inlength) // read the information from the header and store it in the Info
{
if(inlength < 29) { error = 27; return; } //error: the data length is smaller than the length of the header
if(in[0] != 137 || in[1] != 80 || in[2] != 78 || in[3] != 71 || in[4] != 13 || in[5] != 10 || in[6] != 26 || in[7] != 10) { error = 28; return; } //no PNG signature
if(in[12] != 'I' || in[13] != 'H' || in[14] != 'D' || in[15] != 'R') { error = 29; return; } //error: it doesn't start with a IHDR chunk!
info.width = read32bitInt(&in[16]); info.height = read32bitInt(&in[20]);
info.bitDepth = in[24]; info.colorType = in[25];
info.compressionMethod = in[26]; if(in[26] != 0) { error = 32; return; } //error: only compression method 0 is allowed in the specification
info.filterMethod = in[27]; if(in[27] != 0) { error = 33; return; } //error: only filter method 0 is allowed in the specification
info.interlaceMethod = in[28]; if(in[28] > 1) { error = 34; return; } //error: only interlace methods 0 and 1 exist in the specification
if (inlength < 29) {
error = 27;
return;
} // error: the data length is smaller than the length of the header
if (in[0] != 137 || in[1] != 80 || in[2] != 78 || in[3] != 71 || in[4] != 13 || in[5] != 10 || in[6] != 26 || in[7] != 10) {
error = 28;
return;
} // no PNG signature
if (in[12] != 'I' || in[13] != 'H' || in[14] != 'D' || in[15] != 'R') {
error = 29;
return;
} // error: it doesn't start with a IHDR chunk!
info.width = read32bitInt(&in[16]);
info.height = read32bitInt(&in[20]);
info.bitDepth = in[24];
info.colorType = in[25];
info.compressionMethod = in[26];
if (in[26] != 0) {
error = 32;
return;
} // error: only compression method 0 is allowed in the specification
info.filterMethod = in[27];
if (in[27] != 0) {
error = 33;
return;
} // error: only filter method 0 is allowed in the specification
info.interlaceMethod = in[28];
if (in[28] > 1) {
error = 34;
return;
} // error: only interlace methods 0 and 1 exist in the specification
error = checkColorValidity(info.colorType, info.bitDepth);
}
void unFilterScanline(unsigned char* recon, const unsigned char* scanline, const unsigned char* precon, size_t bytewidth, unsigned long filterType, size_t length)
{
switch(filterType)
{
case 0: for(size_t i = 0; i < length; i++) recon[i] = scanline[i]; break;
void unFilterScanline(unsigned char* recon, const unsigned char* scanline, const unsigned char* precon, size_t bytewidth, unsigned long filterType, size_t length) {
switch (filterType) {
case 0:
for (size_t i = 0; i < length; i++)
recon[i] = scanline[i];
break;
case 1:
for(size_t i = 0; i < bytewidth; i++) recon[i] = scanline[i];
for(size_t i = bytewidth; i < length; i++) recon[i] = scanline[i] + recon[i - bytewidth];
for (size_t i = 0; i < bytewidth; i++)
recon[i] = scanline[i];
for (size_t i = bytewidth; i < length; i++)
recon[i] = scanline[i] + recon[i - bytewidth];
break;
case 2:
if(precon) for(size_t i = 0; i < length; i++) recon[i] = scanline[i] + precon[i];
else for(size_t i = 0; i < length; i++) recon[i] = scanline[i];
if (precon)
for (size_t i = 0; i < length; i++)
recon[i] = scanline[i] + precon[i];
else
for (size_t i = 0; i < length; i++)
recon[i] = scanline[i];
break;
case 3:
if(precon)
{
for(size_t i = 0; i < bytewidth; i++) recon[i] = scanline[i] + precon[i] / 2;
for(size_t i = bytewidth; i < length; i++) recon[i] = scanline[i] + ((recon[i - bytewidth] + precon[i]) / 2);
}
else
{
for(size_t i = 0; i < bytewidth; i++) recon[i] = scanline[i];
for(size_t i = bytewidth; i < length; i++) recon[i] = scanline[i] + recon[i - bytewidth] / 2;
if (precon) {
for (size_t i = 0; i < bytewidth; i++)
recon[i] = scanline[i] + precon[i] / 2;
for (size_t i = bytewidth; i < length; i++)
recon[i] = scanline[i] + ((recon[i - bytewidth] + precon[i]) / 2);
} else {
for (size_t i = 0; i < bytewidth; i++)
recon[i] = scanline[i];
for (size_t i = bytewidth; i < length; i++)
recon[i] = scanline[i] + recon[i - bytewidth] / 2;
}
break;
case 4:
if(precon)
{
for(size_t i = 0; i < bytewidth; i++) recon[i] = scanline[i] + paethPredictor(0, precon[i], 0);
for(size_t i = bytewidth; i < length; i++) recon[i] = scanline[i] + paethPredictor(recon[i - bytewidth], precon[i], precon[i - bytewidth]);
}
else
{
for(size_t i = 0; i < bytewidth; i++) recon[i] = scanline[i];
for(size_t i = bytewidth; i < length; i++) recon[i] = scanline[i] + paethPredictor(recon[i - bytewidth], 0, 0);
if (precon) {
for (size_t i = 0; i < bytewidth; i++)
recon[i] = scanline[i] + paethPredictor(0, precon[i], 0);
for (size_t i = bytewidth; i < length; i++)
recon[i] = scanline[i] + paethPredictor(recon[i - bytewidth], precon[i], precon[i - bytewidth]);
} else {
for (size_t i = 0; i < bytewidth; i++)
recon[i] = scanline[i];
for (size_t i = bytewidth; i < length; i++)
recon[i] = scanline[i] + paethPredictor(recon[i - bytewidth], 0, 0);
}
break;
default: error = 36; return; //error: unexisting filter type given
default:
error = 36;
return; // error: unexisting filter type given
}
}
static unsigned long readBitFromReversedStream(size_t& bitp, const unsigned char* bits) { unsigned long result = (bits[bitp >> 3] >> (7 - (bitp & 0x7))) & 1; bitp++; return result;}
static unsigned long readBitsFromReversedStream(size_t& bitp, const unsigned char* bits, unsigned long nbits)
{
unsigned long result = 0;
for(size_t i = nbits - 1; i < nbits; i--) result += ((readBitFromReversedStream(bitp, bits)) << i);
static unsigned long readBitFromReversedStream(size_t& bitp, const unsigned char* bits) {
unsigned long result = (bits[bitp >> 3] >> (7 - (bitp & 0x7))) & 1;
bitp++;
return result;
}
void setBitOfReversedStream(size_t& bitp, unsigned char* bits, unsigned long bit) { bits[bitp >> 3] |= (bit << (7 - (bitp & 0x7))); bitp++; }
static unsigned long readBitsFromReversedStream(size_t& bitp, const unsigned char* bits, unsigned long nbits) {
unsigned long result = 0;
for (size_t i = nbits - 1; i < nbits; i--)
result += ((readBitFromReversedStream(bitp, bits)) << i);
return result;
}
void setBitOfReversedStream(size_t& bitp, unsigned char* bits, unsigned long bit) {
bits[bitp >> 3] |= (bit << (7 - (bitp & 0x7)));
bitp++;
}
unsigned long read32bitInt(const unsigned char* buffer) { return (buffer[0] << 24) | (buffer[1] << 16) | (buffer[2] << 8) | buffer[3]; }
int checkColorValidity(unsigned long colorType, unsigned long bd) // return type is a LodePNG error code
{
if((colorType == 2 || colorType == 4 || colorType == 6)) { if(!(bd == 8 || bd == 16)) return 37; else return 0; }
else if(colorType == 0) { if(!(bd == 1 || bd == 2 || bd == 4 || bd == 8 || bd == 16)) return 37; else return 0; }
else if(colorType == 3) { if(!(bd == 1 || bd == 2 || bd == 4 || bd == 8 )) return 37; else return 0; }
else return 31; //unexisting color type
if ((colorType == 2 || colorType == 4 || colorType == 6)) {
if (!(bd == 8 || bd == 16))
return 37;
else
return 0;
} else if (colorType == 0) {
if (!(bd == 1 || bd == 2 || bd == 4 || bd == 8 || bd == 16))
return 37;
else
return 0;
} else if (colorType == 3) {
if (!(bd == 1 || bd == 2 || bd == 4 || bd == 8))
return 37;
else
return 0;
} else
return 31; // unexisting color type
}
unsigned long getBpp(const Info& info)
{
if(info.colorType == 2) return (3 * info.bitDepth);
else if(info.colorType >= 4) return (info.colorType - 2) * info.bitDepth;
else return info.bitDepth;
unsigned long getBpp(const Info& info) {
if (info.colorType == 2)
return (3 * info.bitDepth);
else if (info.colorType >= 4)
return (info.colorType - 2) * info.bitDepth;
else
return info.bitDepth;
}
int convert(unsigned char* &out, const unsigned char* in, Info& infoIn, unsigned long w, unsigned long h)
{ //converts from any color type to 32-bit. return value = LodePNG error code
int convert(unsigned char*& out, const unsigned char* in, Info& infoIn, unsigned long w, unsigned long h) { // converts from any color type to 32-bit. return value = LodePNG error code
size_t numpixels = w * h, bp = 0;
out = new unsigned char[numpixels * 4 + 1];
if (infoIn.bitDepth == 8 && infoIn.colorType == 0) // greyscale
for(size_t i = 0; i < numpixels; i++)
{
for (size_t i = 0; i < numpixels; i++) {
out[4 * i + 0] = out[4 * i + 1] = out[4 * i + 2] = in[i];
out[4 * i + 3] = (infoIn.key_defined && in[i] == infoIn.key_r) ? 0 : 255;
}
else if (infoIn.bitDepth == 8 && infoIn.colorType == 2) // RGB color
for(size_t i = 0; i < numpixels; i++)
{
for(size_t c = 0; c < 3; c++) out[4 * i + c] = in[3 * i + c];
for (size_t i = 0; i < numpixels; i++) {
for (size_t c = 0; c < 3; c++)
out[4 * i + c] = in[3 * i + c];
out[4 * i + 3] = (infoIn.key_defined == 1 && in[3 * i + 0] == infoIn.key_r && in[3 * i + 1] == infoIn.key_g && in[3 * i + 2] == infoIn.key_b) ? 0 : 255;
}
else if (infoIn.bitDepth == 8 && infoIn.colorType == 3) // indexed color (palette)
for(size_t i = 0; i < numpixels; i++)
{
if(4U * in[i] >= infoIn.palette.size()) return 46;
for(size_t c = 0; c < 4; c++) out[4 * i + c] = infoIn.palette[4 * in[i] + c]; //get rgb colors from the palette
for (size_t i = 0; i < numpixels; i++) {
if (4U * in[i] >= infoIn.palette.size())
return 46;
for (size_t c = 0; c < 4; c++)
out[4 * i + c] = infoIn.palette[4 * in[i] + c]; // get rgb colors from the palette
}
else if (infoIn.bitDepth == 8 && infoIn.colorType == 4) // greyscale with alpha
for(size_t i = 0; i < numpixels; i++)
{
for (size_t i = 0; i < numpixels; i++) {
out[4 * i + 0] = out[4 * i + 1] = out[4 * i + 2] = in[2 * i + 0];
out[4 * i + 3] = in[2 * i + 1];
}
else if(infoIn.bitDepth == 8 && infoIn.colorType == 6) for(size_t i = 0; i < numpixels; i++) for(size_t c = 0; c < 4; c++) out[4 * i + c] = in[4 * i + c]; //RGB with alpha
else if(infoIn.bitDepth == 16 && infoIn.colorType == 0) //greyscale
else if (infoIn.bitDepth == 8 && infoIn.colorType == 6)
for (size_t i = 0; i < numpixels; i++)
{
for (size_t c = 0; c < 4; c++)
out[4 * i + c] = in[4 * i + c]; // RGB with alpha
else if (infoIn.bitDepth == 16 && infoIn.colorType == 0) // greyscale
for (size_t i = 0; i < numpixels; i++) {
out[4 * i + 0] = out[4 * i + 1] = out[4 * i + 2] = in[2 * i];
out[4 * i + 3] = (infoIn.key_defined && 256U * in[i] + in[i + 1] == infoIn.key_r) ? 0 : 255;
}
else if (infoIn.bitDepth == 16 && infoIn.colorType == 2) // RGB color
for(size_t i = 0; i < numpixels; i++)
{
for(size_t c = 0; c < 3; c++) out[4 * i + c] = in[6 * i + 2 * c];
for (size_t i = 0; i < numpixels; i++) {
for (size_t c = 0; c < 3; c++)
out[4 * i + c] = in[6 * i + 2 * c];
out[4 * i + 3] = (infoIn.key_defined && 256U * in[6 * i + 0] + in[6 * i + 1] == infoIn.key_r && 256U * in[6 * i + 2] + in[6 * i + 3] == infoIn.key_g && 256U * in[6 * i + 4] + in[6 * i + 5] == infoIn.key_b) ? 0 : 255;
}
else if (infoIn.bitDepth == 16 && infoIn.colorType == 4) // greyscale with alpha
for(size_t i = 0; i < numpixels; i++)
{
for (size_t i = 0; i < numpixels; i++) {
out[4 * i + 0] = out[4 * i + 1] = out[4 * i + 2] = in[4 * i]; // most significant byte
out[4 * i + 3] = in[4 * i + 2];
}
else if(infoIn.bitDepth == 16 && infoIn.colorType == 6) for(size_t i = 0; i < numpixels; i++) for(size_t c = 0; c < 4; c++) out[4 * i + c] = in[8 * i + 2 * c]; //RGB with alpha
else if(infoIn.bitDepth < 8 && infoIn.colorType == 0) //greyscale
else if (infoIn.bitDepth == 16 && infoIn.colorType == 6)
for (size_t i = 0; i < numpixels; i++)
{
for (size_t c = 0; c < 4; c++)
out[4 * i + c] = in[8 * i + 2 * c]; // RGB with alpha
else if (infoIn.bitDepth < 8 && infoIn.colorType == 0) // greyscale
for (size_t i = 0; i < numpixels; i++) {
unsigned long value = (readBitsFromReversedStream(bp, in, infoIn.bitDepth) * 255) / ((1 << infoIn.bitDepth) - 1); // scale value from 0 to 255
out[4 * i + 0] = out[4 * i + 1] = out[4 * i + 2] = (unsigned char)(value);
out[4 * i + 3] = (infoIn.key_defined && value && ((1U << infoIn.bitDepth) - 1U) == infoIn.key_r && ((1U << infoIn.bitDepth) - 1U)) ? 0 : 255;
}
else if (infoIn.bitDepth < 8 && infoIn.colorType == 3) // palette
for(size_t i = 0; i < numpixels; i++)
{
for (size_t i = 0; i < numpixels; i++) {
unsigned long value = readBitsFromReversedStream(bp, in, infoIn.bitDepth);
if(4 * value >= infoIn.palette.size()) return 47;
for(size_t c = 0; c < 4; c++) out[4 * i + c] = infoIn.palette[4 * value + c]; //get rgb colors from the palette
if (4 * value >= infoIn.palette.size())
return 47;
for (size_t c = 0; c < 4; c++)
out[4 * i + c] = infoIn.palette[4 * value + c]; // get rgb colors from the palette
}
return 0;
}
unsigned char paethPredictor(short a, short b, short c) // Paeth predicter, used by PNG filter type 4
{
short p = a + b - c, pa = p > a ? (p - a) : (a - p), pb = p > b ? (p - b) : (b - p), pc = p > c ? (p - c) : (c - p);
return (unsigned char)((pa <= pb && pa <= pc) ? a : pb <= pc ? b : c);
return (unsigned char)((pa <= pb && pa <= pc) ? a : pb <= pc ? b
: c);
}
};
PNG decoder; decoder.decode(out_image, in_png, in_size, convert_to_rgba32);
image_width = decoder.info.width; image_height = decoder.info.height;
PNG decoder;
decoder.decode(out_image, in_png, in_size, convert_to_rgba32);
image_width = decoder.info.width;
image_height = decoder.info.height;
return decoder.error;
}

19
src/texture.cpp
View File

@ -3,21 +3,19 @@
Copyright (c) 2018 nullworks. All rights reserved.
*/
#include <glez/texture.hpp>
#include <glez/glez.hpp>
#include <cassert>
#include <vector>
#include <glez/picopng/picopng.hpp>
#include <memory>
#include <cstring>
#include <glez/glez.hpp>
#include <glez/picopng/picopng.hpp>
#include <glez/texture.hpp>
#include <memory>
#include <vector>
#include <fstream> // required to load the file
namespace glez
{
namespace glez {
void texture::bind()
{
void texture::bind() {
if (!bound) {
glGenTextures(1, &id);
glBindTexture(GL_TEXTURE_2D, id);
@ -62,7 +60,6 @@ texture texture::loadFromFile(const std::string &path) {
return ret;
}
texture texture::loadFromMemory(const std::byte* mem, std::size_t size, unsigned w, unsigned h) {
if (size < 1)
throw std::runtime_error("Unable to load texture from memory!");
@ -105,4 +102,4 @@ texture& texture::operator=(texture&& var) {
return *this;
}
} // namespace glez::detail::texture
} // namespace glez