forks
/
arsd
mirror of https://github.com/adamdruppe/arsd.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

png reworking

This commit is contained in:
Adam D. Ruppe 2013-06-10 12:21:32 -04:00
parent 84832e6f86
commit 0ef6ebd977
9 changed files with 1222 additions and 1008 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

81
cgi.d
View File

@ -2715,11 +2715,45 @@ class ListeningConnectionManager {
running = true;
shared(int) loopBroken;
version(cgi_multiple_connections_per_thread) {
ConnectionThread[16] pool;
foreach(ref t; pool) {
t = new ConnectionThread(null, &loopBroken, dg);
t.start();
}
}
while(!loopBroken && running) {
auto sn = listener.accept();
try {
auto thread = new ConnectionThread(sn, &loopBroken, dg);
thread.start();
version(cgi_no_threads) {
// NEVER USE THIS
// it exists only for debugging and other special occasions
// the thread mode is faster and less likely to stall the whole
// thing when a request is slow
dg(sn);
} else {
/*
version(cgi_multiple_connections_per_thread) {
bool foundOne = false;
tryAgain:
foreach(t; pool)
if(t.s is null) {
t.s = sn;
foundOne = true;
break;
}
Thread.sleep(dur!"msecs"(1));
if(!foundOne)
goto tryAgain;
} else {
*/
auto thread = new ConnectionThread(sn, &loopBroken, dg);
thread.start();
//}
}
// loopBroken = dg(sn);
} catch(Exception e) {
// if a connection goes wrong, we want to just say no, but try to carry on unless it is an Error of some sort (in which case, we'll die. You might want an external helper program to revive the server when it dies)
@ -2752,7 +2786,21 @@ class ConnectionThread : Thread {
this.s = s;
this.breakSignifier = breakSignifier;
this.dg = dg;
super(&run);
super(&runAll);
}
void runAll() {
if(s !is null)
run();
/*
version(cgi_multiple_connections_per_thread) {
while(1) {
while(s is null)
sleep(dur!"msecs"(1));
run();
}
}
*/
}
void run() {
@ -2761,6 +2809,7 @@ class ConnectionThread : Thread {
// might be fragile, but meh
if(s.handle() != socket_t.init)
s.close();
s = null; // so we know this thread is clear
}
if(auto result = dg(s)) {
*breakSignifier = result;
@ -2981,6 +3030,7 @@ ByChunkRange byChunk(BufferedInputRange ir, size_t atMost) {
}
version(cgi_with_websocket) {
// http://tools.ietf.org/html/rfc6455
/**
WEBSOCKET SUPPORT:
@ -3022,6 +3072,19 @@ version(cgi_with_websocket) {
this.cgi = cgi;
}
// returns true if data available, false if it timed out
bool recvAvailable(Duration timeout = dur!"msecs"(0)) {
Socket socket = cgi.idlol.source;
auto check = new SocketSet();
check.add(socket);
auto got = Socket.select(check, null, null, timeout);
if(got > 0)
return true;
return false;
}
// note: this blocks
WebSocketMessage recv() {
// FIXME: should we automatically handle pings and pongs?
@ -3059,6 +3122,16 @@ version(cgi_with_websocket) {
auto msg = WebSocketMessage.simpleMessage(WebSocketOpcode.close, null);
msg.send(cgi);
}
void ping() {
auto msg = WebSocketMessage.simpleMessage(WebSocketOpcode.ping, null);
msg.send(cgi);
}
void pong() {
auto msg = WebSocketMessage.simpleMessage(WebSocketOpcode.pong, null);
msg.send(cgi);
}
}
bool websocketRequested(Cgi cgi) {
@ -3201,7 +3274,7 @@ version(cgi_with_websocket) {
}
}
writeln("SENDING ", headerScratch[0 .. headerScratchPos], data);
//writeln("SENDING ", headerScratch[0 .. headerScratchPos], data);
cgi.write(headerScratch[0 .. headerScratchPos]);
cgi.write(data);
}

8
dom.d
View File

@ -1979,7 +1979,10 @@ class Element {
Element addField(string label, string name, string type = "text", FormFieldOptions fieldOptions = FormFieldOptions.none) {
auto fs = this;
auto i = fs.addChild("label");
i.addChild("span", label);
if(!(type == "checkbox" || type == "radio"))
i.addChild("span", label);
Element input;
if(type == "textarea")
input = i.addChild("textarea").
@ -1990,6 +1993,9 @@ class Element {
setAttribute("name", name).
setAttribute("type", type);
if(type == "checkbox" || type == "radio")
i.addChild("span", label);
// these are html 5 attributes; you'll have to implement fallbacks elsewhere. In Javascript or maybe I'll add a magic thing to html.d later.
fieldOptions.applyToElement(input);
return i;

5
htmltotext.d
View File

@ -124,7 +124,7 @@ string htmlToText(string html, bool wantWordWrap = true, int wrapAmount = 74) {
}
again2:
start.innerHTML = start.innerHTML().replace("\u0001", "\n");
//start.innerHTML = start.innerHTML().replace("\u0001", "\n");
foreach(ele; start.tree) {
if(ele.tagName == "td") {
@ -173,6 +173,9 @@ string htmlToText(string html, bool wantWordWrap = true, int wrapAmount = 74) {
result = result.replace(""", "\""); // HACK: this shouldn't be needed, but apparently is in practice surely due to a bug elsewhere
//result = htmlEntitiesDecode(result); // for special chars mainly
result = result.replace("\u0001 ", "\n");
result = result.replace("\u0001", "\n");
//a = std.regex.replace(a, std.regex.regex("(\n\t)+", "g"), "\n"); //\t");
return result.strip;
}

46
image.d
View File

@ -20,16 +20,11 @@ module arsd.image;
*/
import arsd.color;
/*
struct Color {
ubyte r;
ubyte g;
ubyte b;
ubyte a = 255;
}
*/
interface Image {
interface Image {
//IndexedImage convertToIndexedImage() const;
//TrueColorImage convertToTrueColor() const;
TrueColorImage getAsTrueColorImage();
}
class IndexedImage : Image {
@ -46,14 +41,24 @@ class IndexedImage : Image {
data = new ubyte[w*h];
}
/*
void resize(int w, int h, bool scale) {
}
/+
TrueColorImage convertToTrueColor() const {
*/
override TrueColorImage getAsTrueColorImage() {
return convertToTrueColor();
}
+/
TrueColorImage convertToTrueColor() const {
auto tci = new TrueColorImage(width, height);
foreach(i, b; data) {
tci.imageData.colors[i] = palette[b];
}
return tci;
}
ubyte getOrAddColor(Color c) {
foreach(i, co; palette) {
if(c == co)
@ -80,7 +85,16 @@ class IndexedImage : Image {
class TrueColorImage : Image {
// bool hasAlpha;
// bool isGreyscale;
ubyte[] data; // stored as rgba quads, upper left to right to bottom
//ubyte[] data; // stored as rgba quads, upper left to right to bottom
union Data {
ubyte[] bytes;
Color[] colors;
static assert(Color.sizeof == 4);
}
Data imageData;
alias imageData.bytes data;
int width;
int height;
@ -88,7 +102,11 @@ class TrueColorImage : Image {
this(int w, int h) {
width = w;
height = h;
data = new ubyte[w*h*4];
imageData.bytes = new ubyte[w*h*4];
}
override TrueColorImage getAsTrueColorImage() {
return this;
}
/+

876
lazypng.d
View File

@ -1,875 +1,3 @@
// this is like png.d but all range based so more complicated...
// and I don't remember how to actually use it.
// some day I'll prolly merge it with png.d but for now just throwing it up there
/* this file is now obsolete, use png.d instead */
module arsd.lazypng;
import arsd.color;
import std.stdio;
import std.range;
import std.traits;
import std.exception;
import std.string;
import std.conv;
/*
struct Color {
ubyte r;
ubyte g;
ubyte b;
ubyte a;
string toString() {
return format("#%2x%2x%2x %2x", r, g, b, a);
}
}
*/
//import simpledisplay;
struct RgbaScanline {
Color[] pixels;
}
auto convertToGreyscale(ImageLines)(ImageLines lines)
if(isInputRange!ImageLines && is(ElementType!ImageLines == RgbaScanline))
{
struct GreyscaleLines {
ImageLines lines;
bool isEmpty;
this(ImageLines lines) {
this.lines = lines;
if(!empty())
popFront(); // prime
}
int length() {
return lines.length;
}
bool empty() {
return isEmpty;
}
RgbaScanline current;
RgbaScanline front() {
return current;
}
void popFront() {
if(lines.empty()) {
isEmpty = true;
return;
}
auto old = lines.front();
current.pixels.length = old.pixels.length;
foreach(i, c; old.pixels) {
ubyte v = cast(ubyte) (
cast(int) c.r * 0.30 +
cast(int) c.g * 0.59 +
cast(int) c.b * 0.11);
current.pixels[i] = Color(v, v, v, c.a);
}
lines.popFront;
}
}
return GreyscaleLines(lines);
}
/// Lazily breaks the buffered input range into
/// png chunks, as defined in the PNG spec
///
/// Note: bufferedInputRange is defined in this file too.
LazyPngChunks!(Range) readPngChunks(Range)(Range r)
if(isBufferedInputRange!(Range) && is(ElementType!(Range) == ubyte[]))
{
// First, we need to check the header
// Then we'll lazily pull the chunks
while(r.front.length < 8) {
enforce(!r.empty(), "This isn't big enough to be a PNG file");
r.appendToFront();
}
enforce(r.front[0..8] == PNG_MAGIC_NUMBER,
"The file's magic number doesn't look like PNG");
r.consumeFromFront(8);
return LazyPngChunks!Range(r);
}
/// Same as above, but takes a regular input range instead of a buffered one.
/// Provided for easier compatibility with standard input ranges
/// (for example, std.stdio.File.byChunk)
auto readPngChunks(Range)(Range r)
if(!isBufferedInputRange!(Range) && isInputRange!(Range))
{
return readPngChunks(BufferedInputRange!Range(r));
}
/// Given an input range of bytes, return a lazy PNG file
auto pngFromBytes(Range)(Range r)
if(isInputRange!(Range) && is(ElementType!Range == ubyte[]))
{
auto chunks = readPngChunks(r);
auto file = LazyPngFile!(typeof(chunks))(chunks);
return file;
}
struct LazyPngChunks(T)
if(isBufferedInputRange!(T) && is(ElementType!T == ubyte[]))
{
T bytes;
Chunk current;
this(T range) {
bytes = range;
popFront(); // priming it
}
Chunk front() {
return current;
}
bool empty() {
return (bytes.front.length == 0 && bytes.empty);
}
void popFront() {
enforce(!empty());
while(bytes.front().length < 4) {
enforce(!bytes.empty,
format("Malformed PNG file - chunk size too short (%s < 4)",
bytes.front().length));
bytes.appendToFront();
}
Chunk n;
n.size |= bytes.front()[0] << 24;
n.size |= bytes.front()[1] << 16;
n.size |= bytes.front()[2] << 8;
n.size |= bytes.front()[3] << 0;
bytes.consumeFromFront(4);
while(bytes.front().length < n.size + 8) {
enforce(!bytes.empty,
format("Malformed PNG file - chunk too short (%s < %s)",
bytes.front.length, n.size));
bytes.appendToFront();
}
n.type[0 .. 4] = bytes.front()[0 .. 4];
bytes.consumeFromFront(4);
n.payload.length = n.size;
n.payload[0 .. n.size] = bytes.front()[0 .. n.size];
bytes.consumeFromFront(n.size);
n.checksum |= bytes.front()[0] << 24;
n.checksum |= bytes.front()[1] << 16;
n.checksum |= bytes.front()[2] << 8;
n.checksum |= bytes.front()[3] << 0;
bytes.consumeFromFront(4);
enforce(n.checksum == crcPng(n.stype, n.payload), "Chunk checksum didn't match");
current = n;
}
}
/// Lazily reads out basic info from a png (header, palette, image data)
/// It will only allocate memory to read a palette, and only copies on
/// the header and the palette. It ignores everything else.
///
/// FIXME: it doesn't handle interlaced files.
struct LazyPngFile(LazyPngChunksProvider)
if(isInputRange!(LazyPngChunksProvider) &&
is(ElementType!(LazyPngChunksProvider) == Chunk))
{
LazyPngChunksProvider chunks;
this(LazyPngChunksProvider chunks) {
enforce(!chunks.empty(), "There are no chunks in this png");
header = PngHeader.fromChunk(chunks.front());
chunks.popFront();
// And now, find the datastream so we're primed for lazy
// reading, saving the palette and transparency info, if
// present
chunkLoop:
while(!chunks.empty()) {
auto chunk = chunks.front();
switch(chunks.front.stype) {
case "PLTE":
// if it is in color, palettes are
// always stored as 8 bit per channel
// RGB triplets Alpha is stored elsewhere.
// FIXME: doesn't do greyscale palettes!
enforce(chunk.size % 3 == 0);
palette.length = chunk.size / 3;
auto offset = 0;
foreach(i; 0 .. palette.length) {
palette[i] = Color(
chunk.payload[offset+0],
chunk.payload[offset+1],
chunk.payload[offset+2],
255);
offset += 3;
}
break;
case "tRNS":
// 8 bit channel in same order as
// palette
enforce(chunk.size < palette.length);
foreach(i, a; chunk.payload)
palette[i].a = a;
break;
case "IDAT":
// leave the datastream for later
break chunkLoop;
default:
// ignore chunks we don't care about
}
chunks.popFront();
}
this.chunks = chunks;
enforce(!chunks.empty() && chunks.front().stype == "IDAT",
"Malformed PNG file - no image data is present");
}
/// Lazily reads and decompresses the image datastream, returning chunkSize bytes of
/// it per front. It does *not* change anything, so the filter byte is still there.
///
/// If chunkSize == 0, it automatically calculates chunk size to give you data by line.
auto rawDatastreamByChunk(int chunkSize = 0) {
assert(chunks.front().stype == "IDAT");
if(chunkSize == 0)
chunkSize = bytesPerLine();
struct DatastreamByChunk(T) {
std.zlib.UnCompress decompressor;
int chunkSize;
T chunks;
this(int cs, T chunks) {
decompressor = new std.zlib.UnCompress();
this.chunkSize = cs;
this.chunks = chunks;
popFront(); // priming
}
ubyte[] front() {
assert(current.length == chunkSize);
return current;
}
ubyte[] current;
ubyte[] buffer;
void popFront() {
if(buffer.length < chunkSize) {
if(chunks.front().stype != "IDAT") {
buffer ~= cast(ubyte[]) decompressor.flush();
if(buffer.length != 0)
goto stillMore;
current = null;
buffer = null;
return;
}
buffer ~= cast(ubyte[])
decompressor.uncompress(chunks.front().payload);
chunks.popFront();
}
stillMore:
current = buffer[0 .. chunkSize];
buffer = buffer[chunkSize .. $];
}
bool empty() {
return (current.length == 0);
}
}
auto range = DatastreamByChunk!(typeof(chunks))(chunkSize, chunks);
return range;
}
auto byRgbaScanline() {
static struct ByRgbaScanline {
ReturnType!(rawDatastreamByChunk) datastream;
RgbaScanline current;
PngHeader header;
int bpp;
Color[] palette;
bool isEmpty = false;
bool empty() {
return isEmpty;
}
int length() {
return header.height;
}
// This is needed for the filter algorithms
immutable(ubyte)[] previousLine;
// FIXME: I think my range logic got screwed somewhere
// in the stack... this is messed up.
void popFront() {
assert(!empty());
if(datastream.empty()) {
isEmpty = true;
return;
}
current.pixels.length = header.width;
// ensure it is primed
if(datastream.front.length == 0)
datastream.popFront;
auto rawData = datastream.front();
auto filter = rawData[0];
auto data = unfilter(filter, rawData[1 .. $], previousLine, bpp);
if(data.length == 0) {
isEmpty = true;
return;
}
assert(data.length);
previousLine = data;
// FIXME: if it's rgba, this could probably be faster
assert(header.depth == 8,
"Sorry, depths other than 8 aren't implemented yet.");
auto offset = 0;
foreach(i; 0 .. header.width) {
switch(header.type) {
case 0: // greyscale
case 4: // grey with alpha
auto value = data[offset++];
current.pixels[i] = Color(
value,
value,
value,
(header.type == 4)
? data[offset++] : 255
);
break;
case 3: // indexed
current.pixels[i] = palette[data[offset++]];
break;
case 2: // truecolor
case 6: // true with alpha
current.pixels[i] = Color(
data[offset++],
data[offset++],
data[offset++],
(header.type == 6)
? data[offset++] : 255
);
break;
default:
throw new Exception("invalid png file");
}
}
assert(offset == data.length);
if(!datastream.empty())
datastream.popFront();
}
RgbaScanline front() {
return current;
}
}
assert(chunks.front.stype == "IDAT");
ByRgbaScanline range;
range.header = header;
range.bpp = bytesPerPixel;
range.palette = palette;
range.datastream = rawDatastreamByChunk(bytesPerLine());
range.popFront();
return range;
}
int bytesPerPixel() {
immutable bitsPerChannel = header.depth;
int bitsPerPixel = bitsPerChannel;
if(header.type & 2 && !(header.type & 1)) // in color, but no palette
bitsPerPixel *= 3;
if(header.type & 4) // has alpha channel
bitsPerPixel += bitsPerChannel;
return (bitsPerPixel + 7) / 8;
}
// FIXME: doesn't handle interlacing... I think
int bytesPerLine() {
immutable bitsPerChannel = header.depth;
int bitsPerPixel = bitsPerChannel;
if(header.type & 2 && !(header.type & 1)) // in color, but no palette
bitsPerPixel *= 3;
if(header.type & 4) // has alpha channel
bitsPerPixel += bitsPerChannel;
immutable int sizeInBits = header.width * bitsPerPixel;
// need to round up to the nearest byte
int sizeInBytes = (sizeInBits + 7) / 8;
return sizeInBytes + 1; // the +1 is for the filter byte that precedes all lines
}
PngHeader header;
Color[] palette;
}
/**************************************************
* Buffered input range - generic, non-image code
***************************************************/
/// Is the given range a buffered input range? That is, an input range
/// that also provides consumeFromFront(int) and appendToFront()
template isBufferedInputRange(R) {
enum bool isBufferedInputRange =
isInputRange!(R) && is(typeof(
{
R r;
r.consumeFromFront(0);
r.appendToFront();
}()));
}
/// Allows appending to front on a regular input range, if that range is
/// an array. It appends to the array rather than creating an array of
/// arrays; it's meant to make the illusion of one continuous front rather
/// than simply adding capability to walk backward to an existing input range.
///
/// I think something like this should be standard; I find File.byChunk
/// to be almost useless without this capability.
// FIXME: what if Range is actually an array itself? We should just use
// slices right into it... I guess maybe r.front() would be the whole
// thing in that case though, so we would indeed be slicing in right now.
// Gotta check it though.
struct BufferedInputRange(Range)
if(isInputRange!(Range) && isArray!(ElementType!(Range)))
{
private Range underlyingRange;
private ElementType!(Range) buffer;
/// Creates a buffer for the given range. You probably shouldn't
/// keep using the underlying range directly.
///
/// It assumes the underlying range has already been primed.
this(Range r) {
underlyingRange = r;
// Is this really correct? Want to make sure r.front
// is valid but it doesn't necessarily need to have
// more elements...
enforce(!r.empty());
buffer = r.front();
usingUnderlyingBuffer = true;
}
/// Forwards to the underlying range's empty function
bool empty() {
return underlyingRange.empty();
}
/// Returns the current buffer
ElementType!(Range) front() {
return buffer;
}
// actually, not terribly useful IMO. appendToFront calls it
// implicitly when necessary
/// Discard the current buffer and get the next item off the
/// underlying range. Be sure to call at least once to prime
/// the range (after checking if it is empty, of course)
void popFront() {
enforce(!empty());
underlyingRange.popFront();
buffer = underlyingRange.front();
usingUnderlyingBuffer = true;
}
bool usingUnderlyingBuffer = false;
/// Remove the first count items from the buffer
void consumeFromFront(int count) {
buffer = buffer[count .. $];
}
/// Append the next item available on the underlying range to
/// our buffer.
void appendToFront() {
if(buffer.length == 0) {
// may let us reuse the underlying range's buffer,
// hopefully avoiding an extra allocation
popFront();
} else {
enforce(!underlyingRange.empty());
// need to make sure underlyingRange.popFront doesn't overwrite any
// of our buffer...
if(usingUnderlyingBuffer) {
buffer = buffer.dup;
usingUnderlyingBuffer = false;
}
underlyingRange.popFront();
buffer ~= underlyingRange.front();
}
}
}
/**************************************************
* Lower level implementations of image formats.
* and associated helper functions.
*
* Related to the module, but not particularly
* interesting, so it's at the bottom.
***************************************************/
/* PNG file format implementation */
import std.zlib;
import std.math;
/// All PNG files are supposed to open with these bytes according to the spec
enum immutable(ubyte[]) PNG_MAGIC_NUMBER = [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a];
/// A PNG file consists of the magic number then a stream of chunks. This
/// struct represents those chunks.
struct Chunk {
uint size;
ubyte[4] type;
ubyte[] payload;
uint checksum;
/// returns the type as a string for easier comparison with literals
string stype() const {
return cast(string) type;
}
static Chunk* create(string type, ubyte[] payload)
in {
assert(type.length == 4);
}
body {
Chunk* c = new Chunk;
c.size = payload.length;
c.type = cast(ubyte[]) type;
c.payload = payload;
c.checksum = crcPng(type, payload);
return c;
}
/// Puts it into the format for outputting to a file
ubyte[] toArray() {
ubyte[] a;
a.length = size + 12;
int pos = 0;
a[pos++] = (size & 0xff000000) >> 24;
a[pos++] = (size & 0x00ff0000) >> 16;
a[pos++] = (size & 0x0000ff00) >> 8;
a[pos++] = (size & 0x000000ff) >> 0;
a[pos .. pos + 4] = type[0 .. 4];
pos += 4;
a[pos .. pos + size] = payload[0 .. size];
pos += size;
assert(checksum);
a[pos++] = (checksum & 0xff000000) >> 24;
a[pos++] = (checksum & 0x00ff0000) >> 16;
a[pos++] = (checksum & 0x0000ff00) >> 8;
a[pos++] = (checksum & 0x000000ff) >> 0;
return a;
}
}
/// The first chunk in a PNG file is a header that contains this info
struct PngHeader {
/// Width of the image, in pixels.
uint width;
/// Height of the image, in pixels.
uint height;
/**
This is bits per channel - per color for truecolor or grey
and per pixel for palette.
Indexed ones can have depth of 1,2,4, or 8,
Greyscale can be 1,2,4,8,16
Everything else must be 8 or 16.
*/
ubyte depth = 8;
/** Types from the PNG spec:
0 - greyscale
2 - truecolor
3 - indexed color
4 - grey with alpha
6 - true with alpha
1, 5, and 7 are invalid.
There's a kind of bitmask going on here:
If type&1, it has a palette.
If type&2, it is in color.
If type&4, it has an alpha channel in the datastream.
*/
ubyte type = 6;
ubyte compressionMethod = 0; /// should be zero
ubyte filterMethod = 0; /// should be zero
/// 0 is non interlaced, 1 if Adam7. No more are defined in the spec
ubyte interlaceMethod = 0;
static PngHeader fromChunk(in Chunk c) {
enforce(c.stype == "IHDR",
"The chunk is not an image header");
PngHeader h;
auto data = c.payload;
int pos = 0;
enforce(data.length == 13,
"Malformed PNG file - the IHDR is the wrong size");
h.width |= data[pos++] << 24;
h.width |= data[pos++] << 16;
h.width |= data[pos++] << 8;
h.width |= data[pos++] << 0;
h.height |= data[pos++] << 24;
h.height |= data[pos++] << 16;
h.height |= data[pos++] << 8;
h.height |= data[pos++] << 0;
h.depth = data[pos++];
h.type = data[pos++];
h.compressionMethod = data[pos++];
h.filterMethod = data[pos++];
h.interlaceMethod = data[pos++];
return h;
}
Chunk* toChunk() {
ubyte[] data;
data.length = 13;
int pos = 0;
data[pos++] = width >> 24;
data[pos++] = (width >> 16) & 0xff;
data[pos++] = (width >> 8) & 0xff;
data[pos++] = width & 0xff;
data[pos++] = height >> 24;
data[pos++] = (height >> 16) & 0xff;
data[pos++] = (height >> 8) & 0xff;
data[pos++] = height & 0xff;
data[pos++] = depth;
data[pos++] = type;
data[pos++] = compressionMethod;
data[pos++] = filterMethod;
data[pos++] = interlaceMethod;
assert(pos == 13);
return Chunk.create("IHDR", data);
}
}
void writePng(OutputRange, InputRange)(OutputRange where, InputRange image)
if(
isOutputRange!(OutputRange, ubyte[]) &&
isInputRange!(InputRange) &&
is(ElementType!InputRange == RgbaScanline))
{
where.put(PNG_MAGIC_NUMBER);
PngHeader header;
assert(!image.empty());
// using the default values for header here... FIXME not super clear
header.width = image.front.pixels.length;
header.height = image.length;
enforce(header.width > 0, "Image width <= 0");
enforce(header.height > 0, "Image height <= 0");
where.put(header.toChunk().toArray());
auto compressor = new std.zlib.Compress();
const(void)[] compressedData;
int cnt;
foreach(line; image) {
// YOU'VE GOT TO BE FUCKING KIDDING ME!
// I have to /cast/ to void[]!??!?
ubyte[] data;
data.length = 1 + header.width * 4;
data[0] = 0; // filter type
int offset = 1;
foreach(pixel; line.pixels) {
data[offset++] = pixel.r;
data[offset++] = pixel.g;
data[offset++] = pixel.b;
data[offset++] = pixel.a;
}
compressedData ~= compressor.compress(cast(void[])
data);
if(compressedData.length > 2_000) {
where.put(Chunk.create("IDAT", cast(ubyte[])
compressedData).toArray());
compressedData = null;
}
cnt++;
}
assert(cnt == header.height, format("Got %d lines instead of %d", cnt, header.height));
compressedData ~= compressor.flush();
if(compressedData.length)
where.put(Chunk.create("IDAT", cast(ubyte[])
compressedData).toArray());
where.put(Chunk.create("IEND", null).toArray());
}
// bKGD - palette entry for background or the RGB (16 bits each) for that. or 16 bits of grey
// Private: used for checking/updating PNG checksums
uint update_crc(in uint crc, in ubyte[] buf){
static const uint[256] crc_table = [0, 1996959894, 3993919788, 2567524794, 124634137, 1886057615, 3915621685, 2657392035, 249268274, 2044508324, 3772115230, 2547177864, 162941995, 2125561021, 3887607047, 2428444049, 498536548, 1789927666, 4089016648, 2227061214, 450548861, 1843258603, 4107580753, 2211677639, 325883990, 1684777152, 4251122042, 2321926636, 335633487, 1661365465, 4195302755, 2366115317, 997073096, 1281953886, 3579855332, 2724688242, 1006888145, 1258607687, 3524101629, 2768942443, 901097722, 1119000684, 3686517206, 2898065728, 853044451, 1172266101, 3705015759, 2882616665, 651767980, 1373503546, 3369554304, 3218104598, 565507253, 1454621731, 3485111705, 3099436303, 671266974, 1594198024, 3322730930, 2970347812, 795835527, 1483230225, 3244367275, 3060149565, 1994146192, 31158534, 2563907772, 4023717930, 1907459465, 112637215, 2680153253, 3904427059, 2013776290, 251722036, 2517215374, 3775830040, 2137656763, 141376813, 2439277719, 3865271297, 1802195444, 476864866, 2238001368, 4066508878, 1812370925, 453092731, 2181625025, 4111451223, 1706088902, 314042704, 2344532202, 4240017532, 1658658271, 366619977, 2362670323, 4224994405, 1303535960, 984961486, 2747007092, 3569037538, 1256170817, 1037604311, 2765210733, 3554079995, 1131014506, 879679996, 2909243462, 3663771856, 1141124467, 855842277, 2852801631, 3708648649, 1342533948, 654459306, 3188396048, 3373015174, 1466479909, 544179635, 3110523913, 3462522015, 1591671054, 702138776, 2966460450, 3352799412, 1504918807, 783551873, 3082640443, 3233442989, 3988292384, 2596254646, 62317068, 1957810842, 3939845945, 2647816111, 81470997, 1943803523, 3814918930, 2489596804, 225274430, 2053790376, 3826175755, 2466906013, 167816743, 2097651377, 4027552580, 2265490386, 503444072, 1762050814, 4150417245, 2154129355, 426522225, 1852507879, 4275313526, 2312317920, 282753626, 1742555852, 4189708143, 2394877945, 397917763, 1622183637, 3604390888, 2714866558, 953729732, 1340076626, 3518719985, 2797360999, 1068828381, 1219638859, 3624741850, 2936675148, 906185462, 1090812512, 3747672003, 2825379669, 829329135, 1181335161, 3412177804, 3160834842, 628085408, 1382605366, 3423369109, 3138078467, 570562233, 1426400815, 3317316542, 2998733608, 733239954, 1555261956, 3268935591, 3050360625, 752459403, 1541320221, 2607071920, 3965973030, 1969922972, 40735498, 2617837225, 3943577151, 1913087877, 83908371, 2512341634, 3803740692, 2075208622, 213261112, 2463272603, 3855990285, 2094854071, 198958881, 2262029012, 4057260610, 1759359992, 534414190, 2176718541, 4139329115, 1873836001, 414664567, 2282248934, 4279200368, 1711684554, 285281116, 2405801727, 4167216745, 1634467795, 376229701, 2685067896, 3608007406, 1308918612, 956543938, 2808555105, 3495958263, 1231636301, 1047427035, 2932959818, 3654703836, 1088359270, 936918000, 2847714899, 3736837829, 1202900863, 817233897, 3183342108, 3401237130, 1404277552, 615818150, 3134207493, 3453421203, 1423857449, 601450431, 3009837614, 3294710456, 1567103746, 711928724, 3020668471, 3272380065, 1510334235, 755167117];
uint c = crc;
foreach(b; buf)
c = crc_table[(c ^ b) & 0xff] ^ (c >> 8);
return c;
}
uint crcPng(in string chunkName, in ubyte[] buf){
uint c = update_crc(0xffffffffL, cast(ubyte[]) chunkName);
return update_crc(c, buf) ^ 0xffffffffL;
}
immutable(ubyte)[] unfilter(ubyte filterType, in ubyte[] data, in ubyte[] previousLine, int bpp) {
// Note: the overflow arithmetic on the ubytes in here is intentional
switch(filterType) {
case 0:
return data.idup; // FIXME is copying really necessary?
case 1:
auto arr = data.dup;
// first byte gets zero added to it so nothing special
foreach(i; bpp .. arr.length) {
arr[i] += arr[i - bpp];
}
return assumeUnique(arr);
case 2:
auto arr = data.dup;
foreach(i; 0 .. arr.length) {
arr[i] += previousLine[i];
}
return assumeUnique(arr);
case 3:
auto arr = data.dup;
foreach(i; 0 .. arr.length) {
auto prev = i < bpp ? 0 : arr[i - bpp];
arr[i] += cast(ubyte)
std.math.floor( cast(int) (prev + previousLine[i]) / 2);
}
return assumeUnique(arr);
case 4:
auto arr = data.dup;
foreach(i; 0 .. arr.length) {
ubyte prev = i < bpp ? 0 : arr[i - bpp];
ubyte prevLL = i < bpp ? 0 : previousLine[i - bpp];
arr[i] += PaethPredictor(prev, previousLine[i], prevLL);
}
return assumeUnique(arr);
default:
throw new Exception("invalid PNG file, bad filter type");
}
}
ubyte PaethPredictor(ubyte a, ubyte b, ubyte c) {
int p = cast(int) a + b - c;
auto pa = abs(p - a);
auto pb = abs(p - b);
auto pc = abs(p - c);
if(pa <= pb && pa <= pc)
return a;
if(pb <= pc)
return b;
return c;
}
static assert(0, "This file is now obsolete. Use png.d instead. The only difference on the user side is the old lazypng.writePng is now png.writePngLazy");

1032
png.d
View File

File diff suppressed because it is too large Load Diff

167
simpledisplay.d
View File

@ -141,8 +141,9 @@ final class Image {
putPixel(x, y, c);
}
// if you pass in a buffer, it will put it right there. length must be width*height*4 already
// if you pass null, it will allocate a new one.
/// this is here for interop with arsd.image. where can be a TrueColorImage's data member
/// if you pass in a buffer, it will put it right there. length must be width*height*4 already
/// if you pass null, it will allocate a new one.
ubyte[] getRgbaBytes(ubyte[] where = null) {
if(where is null)
where = new ubyte[this.width*this.height*4];
@ -150,6 +151,12 @@ final class Image {
return where;
}
/// this is here for interop with arsd.image. from can be a TrueColorImage's data member
void setRgbaBytes(in ubyte[] from ) {
assert(from.length == this.width * this.height * 4);
setFromRgbaBytes(from);
}
// FIXME: make properly cross platform by getting rgba right
/// warning: this is not portable across platforms because the data format can change
@ -431,8 +438,8 @@ class SimpleWindow {
/// width and height is equal to the image. (A window's client area
/// is the drawable space inside; it excludes the title bar, etc.)
this(Image image, string title = null) {
this.backingImage = image;
this(image.width, image.height, title);
this.image = image;
}
this(Size size, string title = null) {
@ -445,8 +452,6 @@ class SimpleWindow {
impl.createWindow(width, height, title is null ? "D Application" : title);
}
Image backingImage;
~this() {
impl.dispose();
}
@ -485,17 +490,30 @@ class SimpleWindow {
}
@property void image(Image i) {
backingImage = i;
version(Windows) {
BITMAP bm;
HDC hdc = GetDC(hwnd);
HDC hdcMem = CreateCompatibleDC(hdc);
HBITMAP hbmOld = SelectObject(hdcMem, i.handle);
GetObject(i.handle, bm.sizeof, &bm);
BitBlt(hdc, 0, 0, bm.bmWidth, bm.bmHeight, hdcMem, 0, 0, SRCCOPY);
SelectObject(hdcMem, hbmOld);
DeleteDC(hdcMem);
DeleteDC(hwnd);
/*
RECT r;
r.right = i.width;
r.bottom = i.height;
InvalidateRect(hwnd, &r, false);
*/
} else
version(X11) {
if(!destroyed)
XPutImage(display, cast(Drawable) window, gc, backingImage.handle, 0, 0, 0, 0, backingImage.width, backingImage.height);
XPutImage(display, cast(Drawable) window, gc, i.handle, 0, 0, 0, 0, i.width, i.height);
} else
version(OSXCocoa) {
draw().drawImage(Point(0, 0), i);
@ -540,55 +558,7 @@ import std.conv;
import std.math;
Color fromHsl(real h, real s, real l) {
h = h % 360;
real C = (1 - abs(2 * l - 1)) * s;
real hPrime = h / 60;
real X = C * (1 - abs(hPrime % 2 - 1));
real r, g, b;
if(std.math.isNaN(h))
r = g = b = 0;
else if (hPrime >= 0 && hPrime < 1) {
r = C;
g = X;
b = 0;
} else if (hPrime >= 1 && hPrime < 2) {
r = X;
g = C;
b = 0;
} else if (hPrime >= 2 && hPrime < 3) {
r = 0;
g = C;
b = X;
} else if (hPrime >= 3 && hPrime < 4) {
r = 0;
g = X;
b = C;
} else if (hPrime >= 4 && hPrime < 5) {
r = X;
g = 0;
b = C;
} else if (hPrime >= 5 && hPrime < 6) {
r = C;
g = 0;
b = X;
}
real m = l - C / 2;
r += m;
g += m;
b += m;
return Color(
cast(ubyte)(r * 255),
cast(ubyte)(g * 255),
cast(ubyte)(b * 255),
255);
return arsd.color.fromHsl([h,s,l]);
}
@ -902,19 +872,6 @@ version(Windows) {
HDC hdc = BeginPaint(hwnd, &ps);
/*
if(backingImage !is null) {
HDC hdcMem = CreateCompatibleDC(hdc);
HBITMAP hbmOld = SelectObject(hdcMem, backingImage.handle);
GetObject(backingImage.handle, bm.sizeof, &bm);
BitBlt(hdc, 0, 0, bm.bmWidth, bm.bmHeight, hdcMem, 0, 0, SRCCOPY);
SelectObject(hdcMem, hbmOld);
DeleteDC(hdcMem);
}
*/
HDC hdcMem = CreateCompatibleDC(hdc);
HBITMAP hbmOld = SelectObject(hdcMem, buffer);
@ -1004,6 +961,29 @@ version(Windows) {
}
}
void setFromRgbaBytes(in ubyte[] what) {
assert(what.length == this.width * this.height * 4);
auto itemsPerLine = ((cast(int) width * 3 + 3) / 4) * 4;
int idx = 0;
int offset = itemsPerLine * (height - 1);
// remember, bmps are upside down
for(int y = height - 1; y >= 0; y--) {
auto offsetStart = offset;
for(int x = 0; x < width; x++) {
rawData[offset + 2] = what[idx + 0]; // r
rawData[offset + 1] = what[idx + 1]; // g
rawData[offset + 0] = what[idx + 2]; // b
//where[idx + 3] = 255; // a
idx += 4;
offset += 3;
}
offset = offsetStart - itemsPerLine;
}
}
void createImage(int width, int height) {
BITMAPINFO infoheader;
infoheader.bmiHeader.biSize = infoheader.bmiHeader.sizeof;
@ -1280,6 +1260,20 @@ version(X11) {
where[idx + 3] = 255; // a
}
}
void setFromRgbaBytes(in ubyte[] where) {
assert(where.length == this.width * this.height * 4);
// if rawData had a length....
//assert(rawData.length == where.length);
for(int idx = 0; idx < where.length; idx += 4) {
rawData[idx + 2] = where[idx + 0]; // r
rawData[idx + 1] = where[idx + 1]; // g
rawData[idx + 0] = where[idx + 2]; // b
//rawData[idx + 3] = 255; // a
}
}
}
mixin template NativeSimpleWindowImplementation() {
@ -1384,8 +1378,6 @@ version(X11) {
switch(e.type) {
case EventType.Expose:
//if(backingImage !is null)
// XPutImage(display, cast(Drawable) window, gc, backingImage.handle, 0, 0, 0, 0, backingImage.width, backingImage.height);
XCopyArea(t.display, cast(Drawable) t.buffer, cast(Drawable) t.window, t.gc, 0, 0, t.width, t.height, 0, 0);
break;
case EventType.ClientMessage: // User clicked the close button
@ -2790,6 +2782,29 @@ version(OSXCocoa) {
}
}
void setFromRgbaBytes(in ubyte[] where) {
// FIXME: this is probably wrong
assert(where.length == this.width * this.height * 4);
// if rawData had a length....
//assert(rawData.length == where.length);
for(int idx = 0; idx < where.length; idx += 4) {
auto alpha = rawData[idx + 3];
if(alpha == 255) {
rawData[idx + 0] = where[idx + 0]; // r
rawData[idx + 1] = where[idx + 1]; // g
rawData[idx + 2] = where[idx + 2]; // b
rawData[idx + 3] = where[idx + 3]; // a
} else {
rawData[idx + 0] = cast(ubyte)(where[idx + 0] * 255 / alpha); // r
rawData[idx + 1] = cast(ubyte)(where[idx + 1] * 255 / alpha); // g
rawData[idx + 2] = cast(ubyte)(where[idx + 2] * 255 / alpha); // b
rawData[idx + 3] = where[idx + 3]; // a
}
}
}
void createImage(int width, int height) {
auto colorSpace = CGColorSpaceCreateDeviceRGB();
@ -3163,6 +3178,14 @@ version(html5) {
where[] = handle.data[];
}
void setFromRgbaBytes(in ubyte[] where) {
if(where is handle.data)
return;
assert(where.length == this.width * this.height * 4);
handle.data[] = where[];
}
}
mixin template NativeScreenPainterImplementation() {

4
terminal.d
View File

@ -580,7 +580,7 @@ struct Terminal {
import std.string;
if(force == ForceOption.alwaysSend || foreground != _currentForeground || background != _currentBackground) {
writeStringRaw(xformat("\033[%dm\033[3%dm\033[4%dm",
writeStringRaw(format("\033[%dm\033[3%dm\033[4%dm",
(foreground & Bright) ? 1 : 0,
cast(int) foreground & ~Bright,
cast(int) background & ~Bright));
@ -649,7 +649,7 @@ struct Terminal {
} else {
import std.string;
if(terminalInFamily("xterm", "rxvt", "screen"))
writeStringRaw(xformat("\033]0;%s\007", t));
writeStringRaw(format("\033]0;%s\007", t));
}
}

11
web.d
View File

@ -2056,11 +2056,12 @@ string toHtml(T)(T a) {
ret = a.toString();
} else
static if(isArray!(T) && !isSomeString!(T)) {
static if(__traits(compiles, typeof(T[0]).makeHtmlArray(a)))
ret = to!string(typeof(T[0]).makeHtmlArray(a));
else
foreach(v; a)
ret ~= toHtml(v);
static if(__traits(compiles, typeof(a[0]).makeHtmlArray(a))) {
ret = to!string(typeof(a[0]).makeHtmlArray(a));
} else {
foreach(v; a)
ret ~= toHtml(v);
}
} else static if(is(T : Element))
ret = a.toString();
else static if(__traits(compiles, a.makeHtmlElement().toString()))