honey

ppmtoc.c (6052B)

---

 #include <stdlib.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <unistd.h>
 #include <fcntl.h>
 
 typedef struct
 {
 	uint32_t x, y;
 } vec2;
 
 typedef struct
 {
 	vec2 dimensions;
 	uint32_t datasize, bitdepth;
 	uint8_t *start;
 } imginfo;
 
 typedef struct
 {
 	uint32_t columns;
 	uint8_t *start;
 } palinfo;
 
 vec2 ParseDimensions(uint8_t *begin, uint32_t length)
 {
 	vec2 ret;
 	ret.x = ret.y = 0;
 	uint8_t xd = 0;
 	for (uint8_t i = 0; i < length; ++i)
 	{
 		if (*(begin + i) == ' ')
 		{
 			xd = 1;
 			continue;
 		}
 
 		if (xd)
 		{
 			ret.y = ret.y * 10;
 			ret.y += *(begin + i) - '0';
 		}
 		else
 		{
 			ret.x = ret.x * 10;
 			ret.x += *(begin + i) - '0';
 		}
 	}
 	return ret;
 }
 
 uint32_t ParseBitDepth(uint8_t *begin, uint32_t length)
 {
 	uint32_t depth = 0;
 	for (uint32_t i = 0; i < length; ++i)
 	{
 		depth = depth * 10;
 		depth += *(begin + i) - '0';
 	}
 	return depth;
 }
 
 
 /*	Parse the image header
 	ppm files begin with the identifying string P6
 	Next is the image dimensions on one line separated by a space
 	And finally the bit depth
 	We need all of this for error handling
 	Comments can appear at any point
 */
 imginfo ParseImgInfo(uint8_t *filedata, uint32_t size)
 {
 	imginfo ret;
 	ret.dimensions.x = 0;
 	ret.dimensions.y = 0;
 	ret.datasize = size;
 	uint32_t curs = 0;
 
 	uint8_t *line_start;
 	uint8_t pmode;
 	line_start = filedata;
 
 	//chop it up into lines and parse
 	while (1)
 	{
 		while (*(line_start + curs) != '\n')
 		{
 			curs++;
 			ret.datasize--;
 		}
 
 		if (*line_start == '#')
 		{
 			line_start += (curs + 1);
 			curs = 0;
 			continue;
 		}
 
 		if (pmode == 0) //first line, file identifier
 		{
 			if (!(*line_start == 'P' && *(line_start + 1) == '6'))
 			{
 				//ain't no ppm!
 				fprintf(stdout, "Invalid image file\n");
 				exit(0);
 			}
 			pmode = 1;
 		}
 		else if (pmode == 1) //second line, dimensions
 		{
 			ret.dimensions = ParseDimensions(line_start, curs);
 			pmode = 2;
 		}
 		else if (pmode == 2) //third line, bit depth
 		{
 			ret.bitdepth = ParseBitDepth(line_start, curs);
 			if (ret.bitdepth != 255)
 			{
 				fprintf(stdout, "Can't support bitdepth other than 255\n");
 				exit(0);
 			}
 
 			//24 bit colors, datasize can be determined by dimensions
 			ret.datasize = ret.dimensions.x * ret.dimensions.y * 3; //3 bytes
 			ret.start = (line_start + curs + 1);
 			return ret;
 		}
 		else
 		{
 			break;
 		}
 
 		line_start += (curs + 1);	
 		curs = 0;
 	}
 	fprintf(stdout, "Error loading image file");
 	exit(0);
 }
 
 void ParseImgData(uint32_t* clist, imginfo finfo)
 {
 	uint32_t curs = 0;
 	for (uint32_t i = 0; i < (finfo.datasize / 3); ++i)
 	{
 		*(clist + i) = 0;
 		for (int i2 = 0; i2 < 3; i2++)
 		{
 			*(clist + i) |= *(finfo.start + curs) << ((2 - i2) * 8);
 			curs++;
 		}
 	}
 }
 
 //TODO: write the function lol
 //Just need to do this and fix the ParsePalette function
 //to use the incoming info struct
 /* Parse the palette header
 begins with identifying string "GIMP Palette"
 Next is the name of the palette ("Name: thename")
 then the amount of columns ("Columns: number")
 the column amount is the only real important data */
 palinfo ParsePalHeader(uint8_t *filedata)
 {
 	palinfo ret;
 	ret.columns = 0;
 	ret.start = filedata;
 	ret.datasize = 0;
 	return ret;
 }
 
 //can only parse 16 column palettes for now
 void ParsePalette(uint32_t *clist, uint8_t *filedata, palinfo info)
 {
 	uint32_t curs = 0;
 	for (int i = 0; i < 16; ++i) 
 	{
 		*(clist + i) = 0;
 		uint8_t offs = 16;
 		uint8_t num = 0;
 		//parse line by line
 		while(1)
 		{
 			if (*(filedata + curs) == '\n')
 			{
 				*(clist + i) |= num;
 				break;
 			}
 			else if (*(filedata + curs) == ' ' && num)
 			{
 				*(clist + i) |= num << offs;
 				num = 0;
 				offs = 8;
 			}
 			else if (*(filedata + curs) != ' ')
 			{
 				num *= 10;
 				num += *(filedata + curs) - '0';	
 			}
 			curs++;
 		}
 		curs++;
 //		fprintf (stdout, "%x | curs: %d\n", *(clist + i), curs);
 	}
 }
 
 //print the image to stdout as an indexed .c array 
 void OutputIndexed(uint32_t *colors, uint32_t *pixels, imginfo *finfo)
 {
 	fprintf(stdout, "#include <stdint.h>\n");
 	fprintf(stdout, "static const uint8_t spritedata[%d] = \n{\n    ", (finfo->datasize / 3));
 
 	for (uint32_t i = 0; i < (finfo->datasize / 3); ++i)
 	{
 		uint8_t index = 0;
 		for (int i2 = 0; i2 < 11; ++i2)
 		{
 			if (*(pixels + i) == *(colors + i2))
 			{
 				index = i2;
 			}
 		}
 		fprintf(stdout, "%d", index);
 		if ( i != (finfo->datasize / 3) - 1)
 		{
 			fprintf(stdout, ", ");
 		}
 		if ( !((i + 1) % 10))
 		{
 			fprintf(stdout, "\n    ");
 		}
 	}
 	fprintf(stdout, "\n};\n");
 }
 
 
 int main(int argc, char *argv[])
 {
 	if (argc != 3)
 	{
 		fprintf(stdout, "Wrong number of arguments (%d).\n", argc);
 		fprintf(stdout, "Usage: ppmtoc image palette\n");
 		return -1;
 	}
 
 	char *fname_img = argv[1];
 //	char *fname_pal = argv[2];
 //	fprintf(stdout, "Arg 1: %s\n", (argv[1]));
 //	fprintf(stdout, "Arg 2: %s\n", (argv[2]));
 
 	int img = 0;
 	img = open(fname_img, O_RDONLY, 700);
 	if (img < 0)
 	{
 		fprintf(stdout, "%s : Couldn't open file\n", fname_img);
 		return -1;
 	}
 
 	uint8_t buffer[64000]; //this oughta be big enough!!
 	uint32_t pal_columns = 0;
 	int size;
 	size = read(img, &buffer, 64000);
 	close(img);
 
 	//parse image header
 	imginfo info = ParseImgInfo(&buffer[0], size);
 
 	fprintf(stdout, "// Width: %d\n", info.dimensions.x);
 	fprintf(stdout, "// Height: %d\n", info.dimensions.y);
 	fprintf(stdout, "// Datasize: %d\n", info.datasize);
 	fprintf(stdout, "// BitDepth: %d\n", info.bitdepth);
 
 /*
 	//load the image into an array of 32bit colors
 	uint32_t pixels[info.datasize / 3];
 	ParseImgData(&pixels[0], info);
 
 	//now open the palette file
 	int pal = 0;
 	pal = open(fname_pal, O_RDONLY, 700);
 	if (pal < 0)
 	{
 		fprintf(stdout, "%s : Couldn't open file\n", fname_pal);
 		return -1;
 	}
 	size = read(pal, &buffer, 64000);
 	close(pal);
 
 	//parse palette header
 	palinfo pinfo = ParsePalHeader(&buffer[0]);
 	uint32_t colors[pinfo.columns];
 
 	//now parse palette file
 	ParsePalette(&colors[0], &buffer[0], pinfo);
 
 	//compare the image data to the palette file and output
 	//an indexed image in a c array
 	OutputIndexed(&colors[0], &pixels[0], &info);
 */
 
 }