wiretap 0.1 → 0.1.2

data/ext/image_io.cpp

@@ -0,0 +1,466 @@
+#include "wiretap.h"
+#include <sys/types.h>
+#include <sys/stat.h>
+
+/************ Memstream writers *****************/
+charstream::charstream() {}
+void charstream::write_char(unsigned char channel) {}
+charstream::~charstream() {}
+
+
+void charstream::write_int32_le(int value) {
+	write_char(value >> 0 & 0xFF);  
+	write_char(value >> 8 & 0xFF);  
+	write_char(value >> 16& 0xFF);  
+	write_char(value >> 24& 0xFF);
+}
+
+void charstream::write_int32_be(int value) {
+	write_char(value >> 24& 0xFF);  
+	write_char(value >> 16& 0xFF);  
+	write_char(value >> 8 & 0xFF);  
+	write_char(value >> 0 & 0xFF);  
+}
+
+void charstream::write_int16_le(short value) {
+	write_char(value >> 0 & 0xFF);  
+	write_char(value >> 8 & 0xFF);  
+}
+
+void charstream::write_int16_be(short value) {
+	write_char(value >> 8 & 0xFF);  
+	write_char(value >> 0 & 0xFF);  
+}
+
+void charstream::write_string(char* value) {
+	while(value && *value) {
+		write_char(*value);
+		value++;
+	}
+}
+
+
+memstream::memstream(unsigned char* _ptr) { ptr = _ptr; }
+void memstream::write_char(unsigned char channel) {
+	*ptr++ = channel;
+}
+
+filestream::filestream(FILE* _f) { f = _f; }
+void filestream::write_char(unsigned char channel) {
+	fwrite(&channel, sizeof(channel), 1, f);
+}
+
+filestream_bgr::filestream_bgr(FILE* _f){ f = _f; count = 0; memset(buffer, 0, sizeof(buffer)); }
+void filestream_bgr::write_char(unsigned char channel) {
+	buffer[2 - count] = channel;
+	count++;
+	if(count == 3) {
+		fwrite(buffer, sizeof(buffer), 1, f);
+		count = 0;
+	}
+}
+
+
+/************ ImageIO *************/
+
+ImageIO* ImageIO::open(const char* filename, WireTapClipFormat& format, bool read_only) {
+	FILE* infile = fopen(filename, read_only ? "r" : "w+");
+	if(!infile) {
+		THROW("Couldn't open file %s for %s", filename, read_only ? "reading" : "writing");
+	}
+	char *extension = 0;
+	for(extension = const_cast<char *>(filename) + strlen(filename); extension > filename; extension--) {
+		if(*extension == '.') {
+			extension++;
+			break;
+		}
+	}
+	if(!strcmp(extension, "ppm")) return new ImageIO_PPM(filename, infile, format);
+	if(!strcmp(extension, "sgi")) return new ImageIO_SGI(filename, infile, format);
+	if(!strcmp(extension, "bmp")) return new ImageIO_BMP(filename, infile, format);
+	if(!strcmp(extension, "stoneimage")) return new ImageIO_RAW(filename, infile, format);
+	return NULL;
+}
+
+
+int ImageIO::extract_int() {
+	char buffer[256];
+	int pos = 0;
+	char c;
+	while(!feof(this->f)) {
+		c = fgetc(this->f);
+		if(!isalnum(c)) {
+			break;
+		}
+		buffer[pos++] = c;
+		if(pos == sizeof(buffer)) break;
+	}
+	buffer[pos] = '\0';
+	return atoi(buffer);
+}
+
+int ImageIO::read_int32_be() {
+	unsigned char bytes[4];
+	fread(bytes, sizeof(bytes), 1, f);
+	return (bytes[0] << 24) + (bytes[1] << 16) + (bytes[2] << 8) + (bytes[3]);
+}
+
+short ImageIO::read_int16_be() {
+	unsigned char bytes[2];
+	fread(bytes, sizeof(bytes), 1, f);
+	return (bytes[0] << 8) + (bytes[1]);
+}
+
+unsigned char ImageIO::read_int8() {
+	unsigned char byte;
+	fread(&byte, 1, 1, f);
+	return byte;
+}
+
+
+
+ImageIO::ImageIO(const char* _filename, FILE* _f, WireTapClipFormat& _format) : format(_format) {
+	filename = _filename;
+	f = _f;
+}
+
+
+ImageIO::~ImageIO() {
+	if(f) {
+		fclose(f);
+	}
+}
+
+
+void ImageIO::decode_image_data(unsigned char* frame, charstream& writer) {
+	std::auto_ptr<FrameIO> frame_io(FrameIO::decoder(frame, format.width(), format.height(), format.bitsPerPixel()));
+	if(!frame_io.get()) {
+		THROW("Unsupported color depth for dumping image: %d", format.bitsPerPixel());
+	}
+	frame_io->decode(writer);
+}
+
+/**************  PPM format *****************/
+
+ImageIO_PPM::ImageIO_PPM(const char* _filename, FILE* _f, WireTapClipFormat& _format) : ImageIO(_filename, _f, _format) {
+}
+
+void ImageIO_PPM::read_format() {
+	extract_int();
+	
+	format.setWidth(extract_int());
+	format.setHeight(extract_int());
+	
+	int maxval = extract_int();
+	if(maxval > 255) {
+		//FIXME: possible memory leak in using function.
+		THROW("Decoding 16bit PPM files is not supported");
+	}
+	
+	format.setBitsPerPixel(24);
+	format.setNumChannels(3);
+	format.setFrameBufferSize((format.bitsPerPixel()/8)*format.width()*format.height());
+	format.setFrameRate(25);
+	format.setScanFormat(format.strToScanFormat("progressive"));
+	format.setFormatTag("rgb");
+	format.setMetaDataTag("IFFFS_XML");
+	format.setMetaData("<IFFFS_XML Version=\"1.0\"><ClipData></ClipData></IFFFS_XML>");
+}
+
+
+unsigned char* ImageIO_PPM::read_data() {
+	unsigned char* frame = new unsigned char[format.frameBufferSize()];
+	
+	size_t row_size = format.width()*3;
+  
+	for(int i = 0; i < format.height(); i++) {
+		size_t read_bytes = fread(frame + (format.height() - 1 - i)*row_size, 1, row_size, f);
+		if(read_bytes != row_size) {
+			rb_warn("Read %d bytes, expected %d. Step: %d", read_bytes, row_size, i);
+			return 0;
+		}
+	}
+
+	return frame;
+}
+
+void ImageIO_PPM::write_data(unsigned char* frame) {
+	
+}
+
+
+/**************  SGI format *****************/
+
+
+ImageIO_SGI::ImageIO_SGI(const char* _filename, FILE* _f, WireTapClipFormat& _format) : ImageIO(_filename, _f, _format) {
+	compressed = false;
+	bit16 = false;
+}
+
+void ImageIO_SGI::read_format() {
+	const int header_padding = 404;
+	const int magic = 474;
+	
+	short _magic = read_int16_be();
+	if(_magic != magic) {
+		rb_warn("Warning: %s has a broken file format: %d", filename, _magic);
+	}
+
+	compressed = read_int8() ? true : false;
+	switch(read_int8()) { // 1 for 1 byte per channel. 24 bit picture
+		case 1: format.setBitsPerPixel(24);
+		break;
+		case 2: format.setBitsPerPixel(48);
+		bit16 = true;
+		break;
+	}
+	
+	format.setFrameBufferSize((format.bitsPerPixel()/8)*format.width()*format.height());
+	format.setFrameRate(25);
+	format.setScanFormat(format.strToScanFormat("progressive"));
+	format.setFormatTag("rgb");
+	format.setMetaDataTag("IFFFS_XML");
+	format.setMetaData("<IFFFS_XML Version=\"1.0\"><ClipData></ClipData></IFFFS_XML>");
+	
+	short d;
+	if((d = read_int16_be()) != 3) {
+		rb_warn("Unknown number of dimensions: %d. Cannot read", d);
+	}
+	format.setWidth(read_int16_be());
+	format.setHeight(read_int16_be());
+	format.setNumChannels(read_int16_be());
+	/*int pix_min = */read_int32_be();
+	/*int pix_max = */read_int32_be();
+	read_int32_be(); // dummy
+	
+	char image_name[80];
+	fread(image_name, sizeof(image_name), 1, f);
+	
+	int cl;
+	if((cl = read_int32_be()) != 0) {
+		rb_warn("Unkwnown colormap: %d", cl);
+	}
+	char padding[header_padding];
+	fread(padding, sizeof(padding), 1, f);
+	if(compressed) {
+		int tablen = format.height()*3; //Only for colour pictures
+		
+		start_table = std::auto_ptr<unsigned long>(new unsigned long[tablen]);
+		for(int i = 0; i < tablen; i++) {
+			start_table.get()[i] = read_int32_be();
+		}
+
+		length_table = std::auto_ptr<unsigned long>(new unsigned long[tablen]);
+		for(int i = 0; i < tablen; i++) {
+			length_table.get()[i] = read_int32_be();
+		}
+	}
+}
+
+unsigned char* ImageIO_SGI::read_channel(int channel) {
+	return compressed ? read_compressed(channel) : read_uncompressed(channel);
+}
+
+/*
+ * Decoding as here: http://www.martinreddy.net/gfx/2d/RGB.txt
+ */
+unsigned char* ImageIO_SGI::read_compressed(int channel) {
+	int row_size = format.width()*format.bitsPerPixel()/24;
+	int line_size = row_size*format.height();
+	unsigned char* line = new unsigned char[line_size];
+	for(int rowno = 0; rowno < format.height(); rowno++) {
+		int compressed_row_length = length_table.get()[rowno + channel*format.height()];
+		std::auto_ptr<unsigned char> row_in(new unsigned char[compressed_row_length]);
+		fseek(f, start_table.get()[rowno + channel*format.height()], SEEK_SET);
+		fread(row_in.get(), compressed_row_length, 1, f);
+		expand_row(line + row_size*rowno, row_in.get());
+	}
+	return line;
+}
+
+void ImageIO_SGI::expand_row(unsigned char* optr, unsigned char* iptr) {
+	unsigned char pixel, count, pixel_high = 0;
+	while(1) {
+		pixel = *iptr++;
+		if(bit16) pixel = *iptr++;
+		if ( !(count = (pixel & 0x7f)) ) {
+			return;
+		}
+	 	if(pixel & 0x80) {
+			while(count--) {
+				*optr = *iptr++;
+				optr++;
+				if(bit16) {
+					*optr = *iptr++;	
+					optr++;
+				}
+			}
+		} else {
+			pixel = *iptr++;
+			if(bit16) {
+				pixel_high = pixel;
+				pixel = *iptr++;
+			}
+			while(count--) {
+				if(bit16) {
+					*optr = pixel_high;
+					optr++;
+				}
+				*optr = pixel;
+				optr++;
+			}
+		}
+	}	
+}
+
+
+unsigned char* ImageIO_SGI::read_uncompressed(int channel) {
+	int line_size = format.width()*format.height()*format.bitsPerPixel()/24;
+	unsigned char* line = new unsigned char[line_size];
+	fread(line, line_size, 1, f);
+	return line;
+}
+
+unsigned char* ImageIO_SGI::read_data() {
+	int pixel_count = format.width()*format.height()*format.bitsPerPixel()/8;
+	unsigned char* frame = new unsigned char[pixel_count];
+	std::auto_ptr<unsigned char> line_r(read_channel(0));
+	std::auto_ptr<unsigned char> line_g(read_channel(1));
+	std::auto_ptr<unsigned char> line_b(read_channel(2));
+	
+	int frame_ptr = 0;
+	int line_ptr = 0;
+	for(int i = 0; i < format.height(); i++) {
+		for(int j = 0; j < format.width(); j++) {
+			frame[frame_ptr++] = line_r.get()[line_ptr];
+			if(bit16) frame[frame_ptr++] = line_r.get()[line_ptr+1];
+			frame[frame_ptr++] = line_g.get()[line_ptr];
+			if(bit16) frame[frame_ptr++] = line_g.get()[line_ptr+1];
+			frame[frame_ptr++] = line_b.get()[line_ptr];
+			if(bit16) frame[frame_ptr++] = line_b.get()[line_ptr+1];
+			line_ptr++;
+			if(bit16) line_ptr++;
+		}
+	}
+	return frame;
+}
+
+
+
+static void write_channel(int width, int height, int number, unsigned char* frame, FILE* f) {
+	std::auto_ptr<unsigned char> buffer(new unsigned char[width*height]);
+	for(int i = 0; i < width*height; i++) {
+		buffer.get()[i] = frame[3*i + number];
+	}
+	fwrite(buffer.get(), width*height, 1, f);
+}
+
+
+static int wiretap_write_sgi_header(int width, int height, charstream& writer) {
+	//const int header_size = 512;
+	const int header_padding = 404;
+	const int magic = 474;
+	
+	writer.write_int16_be(magic);  // Magic 474
+	writer.write_char(0); // 0 for uncompressed
+	writer.write_char(1); // 1 for 1 byte per channel. 24 bit picture
+	writer.write_int16_be(3); // 3 dimensions - one plain image with multiple channels
+	writer.write_int16_be(width); 
+	writer.write_int16_be(height); 
+	writer.write_int16_be(3); // 3 for RGB mode: 3 channels
+	writer.write_int32_be(0); // minimum pixel value
+	writer.write_int32_be(0xFF); // maximum pixel value
+	writer.write_int32_be(0); // dummy
+	
+	char image_name[80] = "Ruby wiretap encoded";
+	for(size_t i = 0; i < sizeof(image_name); i++) {
+		writer.write_char(image_name[i]);
+	}
+	
+	writer.write_int32_be(0); // colormap is in normal mode (0)
+	for(int i = 0; i < header_padding; i++) {
+		writer.write_char(0);
+	}
+	return 0;
+}
+
+
+
+void ImageIO_SGI::write_data(unsigned char* frame) {
+	std::auto_ptr<unsigned char> buffer(new unsigned char[format.width()*format.height()*3]);
+	filestream stream(f);
+	memstream mem(buffer.get());
+
+	wiretap_write_sgi_header(format.width(), format.height(), stream);
+	decode_image_data(frame, mem);	
+
+	write_channel(format.width(), format.height(), 0, buffer.get(), f);
+	write_channel(format.width(), format.height(), 1, buffer.get(), f);
+	write_channel(format.width(), format.height(), 2, buffer.get(), f);
+}
+
+
+
+/**************  BMP format *****************/
+
+ImageIO_BMP::ImageIO_BMP(const char* _filename, FILE* _f, WireTapClipFormat& _format) : ImageIO(_filename, _f, _format) {
+}
+
+void ImageIO_BMP::read_format() {
+}
+unsigned char* ImageIO_BMP::read_data() {
+	return NULL;
+}
+
+void ImageIO_BMP::write_header() {
+	filestream writer(f);
+	const int header_size = 54;
+	int size = header_size + format.width() * format.height() * 3;
+	writer.write_string("BM"); //  0,1 
+	writer.write_int32_le(size); // 2,3,4,5
+	writer.write_int32_le(0); // 6,7,8,9: reserved data
+	writer.write_int32_le(header_size); // 10,11,12,13: Image header ends.
+	writer.write_int32_le(40); // 14,15,16,17: Image information size
+	writer.write_int32_le(format.width()); // 18,19,20,21: Width
+	writer.write_int32_le(format.height()); // 22,23,24,25: Height
+	writer.write_int16_le(1); // 26,27: Number of color planes
+    writer.write_int16_le(24); // 28,29: Bits per pixel. We write only 24 bit images
+    writer.write_int32_le(0); // 30,31,32,33: Compression schema. None
+    writer.write_int32_le(format.width()*format.height()*3); // 34,35,36,37: raw data size. 3 bytes per pixel.
+	writer.write_int32_le(2834); // 38,39,40,41: horisontal resolution. Perhaprs 72 dpi. I don't know
+	writer.write_int32_le(2834); // 42,43,44,45: vertical resolution
+	writer.write_int32_le(0); // 46,47,48,49: number of colors
+	writer.write_int32_le(0); // 50,51,52,53: number of important colors
+}
+
+
+void ImageIO_BMP::write_data(unsigned char* frame) {
+	filestream_bgr stream_bgr(f);
+	
+	write_header();
+	decode_image_data(frame, stream_bgr);
+}
+
+
+/**************  RAW format *****************/
+ImageIO_RAW::ImageIO_RAW(const char* _filename, FILE* _f, WireTapClipFormat& _format) : ImageIO(_filename, _f, _format) {
+}
+
+void ImageIO_RAW::read_format() {}
+unsigned char* ImageIO_RAW::read_data() {
+	struct stat sb;
+	if(!stat(filename, &sb)) {
+		return NULL;
+	}
+	unsigned char* frame = new unsigned char[sb.st_size];
+	if(!fread(frame, sb.st_size, 1, f)) {
+		delete frame;
+		return NULL;
+	}
+	return frame;
+}
+
+void ImageIO_RAW::write_data(unsigned char* frame) {
+	fwrite(frame, format.frameBufferSize(), 1, f);
+}
+

data/ext/image_io.h

@@ -0,0 +1,73 @@
+#ifndef _IMAGE_IO_H_
+#define _IMAGE_IO_H_
+#include <string.h>
+#include "charstream.h"
+
+
+
+
+class ImageIO {
+public:
+	virtual void read_format() = 0;
+	virtual unsigned char* read_data() = 0;
+	virtual void write_data(unsigned char* frame) = 0;
+	
+	static ImageIO* open(const char* filename, WireTapClipFormat& format, bool read_only = true);
+	ImageIO(const char* _filename, FILE* _f, WireTapClipFormat& _format);
+	virtual ~ImageIO();
+protected:
+	FILE* f;
+	const char* filename;
+	WireTapClipFormat& format;
+	int extract_int();
+	int read_int32_be();
+	short read_int16_be();
+	unsigned char read_int8();
+	void decode_image_data(unsigned char* frame, charstream& writer);
+};
+
+class ImageIO_SGI : public ImageIO {
+public:
+	ImageIO_SGI(const char* filename, FILE* f, WireTapClipFormat& _format);
+	virtual void read_format();
+	virtual unsigned char* read_data();
+	virtual void write_data(unsigned char* frame);
+protected:
+	bool compressed;
+	bool bit16;
+	std::auto_ptr<unsigned long> length_table;
+	std::auto_ptr<unsigned long> start_table;
+	unsigned char* read_channel(int channel);
+	unsigned char* read_uncompressed(int channel);
+	unsigned char* read_compressed(int channel);
+	void expand_row(unsigned char* optr, unsigned char* iptr);
+};
+
+class ImageIO_PPM : public ImageIO {
+public:
+	ImageIO_PPM(const char* filename, FILE* f, WireTapClipFormat& _format);
+	virtual void read_format();
+	virtual unsigned char* read_data();
+	virtual void write_data(unsigned char* frame);
+};
+
+class ImageIO_BMP : public ImageIO {
+public:
+	ImageIO_BMP(const char* filename, FILE* f, WireTapClipFormat& _format);
+	virtual void read_format();
+	virtual unsigned char* read_data();
+	virtual void write_data(unsigned char* frame);
+protected:
+	void write_header();
+};
+
+class ImageIO_RAW : public ImageIO {
+public:
+	ImageIO_RAW(const char* filename, FILE* f, WireTapClipFormat& _format);
+	virtual void read_format();
+	virtual unsigned char* read_data();
+	virtual void write_data(unsigned char* frame);
+};
+
+#endif /* _IMAGE_IO_H_ */
+