/*
    This file is part of "psdparse"
    Copyright (C) 2004-2010 Toby Thain, toby@telegraphics.com.au

    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 2 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, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#include "psdparse.h"

static void ir_resolution(psd_file_t f, int level, int len, struct dictentry *parent){
	double hresd, vresd;
	extern uint32_t hres, vres; // fixed point values

	hresd = FIXEDPT(hres = get4B(f));
	get2B(f);
	get2B(f);
	vresd = FIXEDPT(vres = get4B(f));
	if(xml) fprintf(xml, " <H>%g</H> <V>%g</V> ", hresd, vresd);
	UNQUIET("    Resolution %g x %g pixels per inch\n", hresd, vresd);
}

#define BYTESPERLINE 16

void dumphex(unsigned char *data, long size){
	unsigned char *p;
	long j, n;

	for(p = data; size; p += BYTESPERLINE, size -= n){
		fputs("    ", stdout);
		n = size > BYTESPERLINE ? BYTESPERLINE : size;
		for(j = 0; j < n; ++j)
			printf("%02x ", p[j]);
		for(; j < BYTESPERLINE+1; ++j)
			fputs("   ", stdout);
		for(j = 0; j < n; ++j)
			printf("%c", isprint(p[j]) ? p[j] : '.');
		putchar('\n');
	}
}

void ir_dump(psd_file_t f, int level, int len, struct dictentry *parent){
	unsigned char row[BYTESPERLINE];
	int n;

	if(verbose)
		for(; len; len -= n){
			n = len < BYTESPERLINE ? len : BYTESPERLINE;
			fread(row, 1, n, f);
			dumphex(row, n);
		}
	else
		fseeko(f, len, SEEK_CUR);
}

void ir_string(psd_file_t f, int level, int len, struct dictentry *parent){
	if(xml)
		while(len--)
			fputcxml(fgetc(f), xml);
}

// this should be used if the content is known to be valid XML.
// (does not check for invalid characters)
void ir_cdata(psd_file_t f, int level, int len, struct dictentry *parent){
	if(xml){
		fputs("<![CDATA[", xml);
		while(len--)
			fputc(fgetc(f), xml);
		fputs("]]>\n", xml);
	}
}

static void ir_pstring(psd_file_t f, int level, int len, struct dictentry *parent){
	if(xml)
		fputsxml(getpstr(f), xml);
}

static void ir_pstrings(psd_file_t f, int level, int len, struct dictentry *parent){
	char *s;

	for(; len > 1; len -= strlen(s)+1){
		// this loop will do the wrong thing
		// if any string contains NUL byte
		s = getpstr(f);
		if(xml){
			fprintf(xml, "%s<NAME>", tabs(level));
			fputsxml(s, xml);
			fputs("</NAME>\n", xml);
		}
		VERBOSE("    %s\n", s);
	}
}

static void ir_1byte(psd_file_t f, int level, int len, struct dictentry *parent){
	if(xml) fprintf(xml, "%d", fgetc(f));
}

static void ir_2byte(psd_file_t f, int level, int len, struct dictentry *parent){
	if(xml) fprintf(xml, "%d", get2B(f));
}

static void ir_4byte(psd_file_t f, int level, int len, struct dictentry *parent){
	if(xml) fprintf(xml, "%d", get4B(f));
}

static void ir_alphaids(psd_file_t f, int level, int len, struct dictentry *parent){
	if(xml){
		fprintf(xml, "%s<LENGTH>%d</LENGTH>\n", tabs(level), get4B(f));
		len -= 4;
		for(; len >= 4; len -= 4)
			fprintf(xml, "%s<ID>%d</ID>\n", tabs(level), get4B(f));
	}
}

static void ir_digest(psd_file_t f, int level, int len, struct dictentry *parent){
	if(xml)
		while(len--)
			fprintf(xml, "%02x", fgetc(f));
}

static void ir_pixelaspect(psd_file_t f, int level, int len, struct dictentry *parent){
	int v = get4B(f);
	double ratio = getdoubleB(f);
	if(xml) fprintf(xml, " <VERSION>%d</VERSION> <RATIO>%g</RATIO> ", v, ratio);
	UNQUIET("    (Version = %d, Ratio = %g)\n", v, ratio);
}

static void ir_unicodestr(psd_file_t f, int level, int len, struct dictentry *parent){
	if(xml) xml_unicodestr(f, get4B(f));
}

static void ir_unicodestrings(psd_file_t f, int level, int len, struct dictentry *parent){
	if(xml){
		int count;
		for(; len >= 4; len -= 4 + 2*count){
			count = get4B(f);
			fprintf(xml, "%s<NAME>", tabs(level));
			xml_unicodestr(f, count);
			fputs("</NAME>\n", xml);
		}
	}
}

static void ir_gridguides(psd_file_t f, int level, int len, struct dictentry *parent){
	const char *indent = tabs(level);
	long v = get4B(f), gv = get4B(f), gh = get4B(f), i, n = get4B(f);

	if(xml){
		fprintf(xml, "%s<VERSION>%ld</VERSION>\n", indent, v);
		// Note that these quantities are "document coordinates".
		// This is not documented, but appears to mean fixed point with 5 fraction bits,
		// so we divide by 32 to obtain pixel position.
		fprintf(xml, "%s<GRIDCYCLE> <V>%g</V> <H>%g</H> </GRIDCYCLE>\n",
				indent, gv/32., gh/32.);
		fprintf(xml, "%s<GUIDES>\n", indent);
		for(i = n; i--;){
			long ord = get4B(f);
			char c = fgetc(f) ? 'H' : 'V';
			fprintf(xml, "%s\t<%cGUIDE>%g</%cGUIDE>\n", indent, c, ord/32., c);
		}
		fprintf(xml, "%s</GUIDES>\n", indent);
	}
}

static void ir_layersgroup(psd_file_t f, int level, int len, struct dictentry *parent){
	if(xml)
		for(; len >= 2; len -= 2)
			fprintf(xml, "%s<GROUPID>%d</GROUPID>\n", tabs(level), get2B(f));
}

static void ir_layerselectionids(psd_file_t f, int level, int len, struct dictentry *parent){
	int count = get2B(f);
	if(xml)
		while(count--)
			fprintf(xml, "%s<ID>%d</ID>\n", tabs(level), get4B(f));
}

static void ir_printflags(psd_file_t f, int level, int len, struct dictentry *parent){
	const char *indent = tabs(level), **p, *flags[] = {
		"LABELS", "CROPMARKS", "COLORBARS", "REGMARKS", "NEGATIVE",
		"FLIP", "INTERPOLATE", "CAPTION", "PRINTFLAGS", NULL
	};
	if(xml){
		for(p = flags; *p; ++p)
			fprintf(xml, "%s<%s>%d</%s>\n", indent, *p, fgetc(f), *p);
	}
}

static void ir_printflags10k(psd_file_t f, int level, int len, struct dictentry *parent){
	const char *indent = tabs(level);
	if(xml){
		fprintf(xml, "%s<VERSION>%d</VERSION>\n", indent, get2B(f));
		fprintf(xml, "%s<CENTERCROPMARKS>%d</CENTERCROPMARKS>\n", indent, fgetc(f));
		fgetc(f);
		fprintf(xml, "%s<BLEEDWIDTH>%d</BLEEDWIDTH>\n", indent, get4B(f));
		fprintf(xml, "%s<BLEEDWIDTHSCALE>%d</BLEEDWIDTHSCALE>\n", indent, get2B(f));
	}
}

static void ir_colorsamplers(psd_file_t f, int level, int len, struct dictentry *parent){
	const char *indent = tabs(level);
	long v = get4B(f), n = get4B(f);
	union { float f; int32_t i; } x, y;
	int space;
	struct colour_space *sp;

	if(xml){
		fprintf(xml, "%s<VERSION>%ld</VERSION>\n", indent, v);
		while(n--){
			fprintf(xml, "%s<SAMPLER>\n", indent);
			if(v >= 3)
				fprintf(xml, "\t%s<VERSION>%d</VERSION>\n", indent, get2B(f)); // doc incorrectly says 4 byte
			y.i = get4B(f);
			x.i = get4B(f);
			if(v == 1)
				fprintf(xml, "\t%s<X>%g</X> <Y>%g</Y>\n", indent, x.i/32., y.i/32.); // undocumented fixed point factor
			else
				fprintf(xml, "\t%s<X>%g</X> <Y>%g</Y>\n", indent, x.f, y.f);
			space = get2B(f);
			if( (sp = find_colour_space(space)) )
				fprintf(xml, "\t%s<COLORSPACE> <%s/> </COLORSPACE>\n", indent, sp->name);
			else
				fprintf(xml, "\t%s<COLORSPACE>%d</COLORSPACE>\n", indent, space);
			if(v >= 2)
				fprintf(xml, "\t%s<DEPTH>%d</DEPTH>\n", indent, get2B(f));
			fprintf(xml, "%s</SAMPLER>\n", indent);
		}
	}
}

// Print XML for a DisplayInfo structure (see Photoshop API doc, Appendix A).

static void displayinfo(int level, unsigned char data[]){
	static const char *kind[] = {"ALPHACOLORSELECTED", "ALPHACOLORMASKED", "SPOTCHANNEL"};
	const char *indent = tabs(level);

	if(xml){
		fprintf(xml, "%s<%s>\n", indent, kind[data[12]]);
		colorspace(level+1, peek2B(data), data+2);
		fprintf(xml, "\t%s<OPACITY>%d</OPACITY>\n", indent, peek2B(data+10));
		// kind values seem to be:
		// 0 = alpha channel, colour indicates selected areas
		// 1 = alpha channel, colour indicates masked areas
		// 2 = spot colour channel
		//fprintf(xml, "\t%s<KIND>%d</KIND>\n", indent, data[12]);
		fprintf(xml, "%s</%s>\n", indent, kind[data[12]]);
	}
}

static void ir_displayinfo(psd_file_t f, int level, int len, struct dictentry *parent){
	if(xml){
		for(; len >= 14; len -= 14){
			unsigned char data[14];
			fread(data, 1, 14, f);
			displayinfo(level, data);
		}
	}
}

static void ir_displayinfocs3(psd_file_t f, int level, int len, struct dictentry *parent){
	if(xml){
		fprintf(xml, "%s<VERSION>%d</VERSION>\n", tabs(level), get4B(f));
		len -= 4;
		for(; len >= 13; len -= 13){
			unsigned char data[13];
			// it seems as if this resource doesn't use DisplayInfo padding
			// (this divergence from API description isn't mentioned in File Format doc)
			fread(data, 1, 13, f);
			displayinfo(level, data);
		}
	}
}

static void ir_altduotonecolors(psd_file_t f, int level, int len, struct dictentry *parent){
	const char *indent = tabs(level);
	unsigned i;

	if(xml){
		fprintf(xml, "%s<VERSION>%d</VERSION>\n", indent, get2B(f));
		for(i = get2B(f); i--;)
			ed_colorspace(f, level, len, parent);
		for(i = get2B(f); i--;){
			int L = fgetc(f), a = fgetc(f), b = fgetc(f);
			fprintf(xml, "%s<kLabSpace> <L>%d</L> <a>%d</a> <b>%d</b> </kLabSpace>\n",
					indent, L, a, b);
		}
	}
}

static void ir_altspotcolors(psd_file_t f, int level, int len, struct dictentry *parent){
	const char *indent = tabs(level);
	unsigned i;

	if(xml){
		fprintf(xml, "%s<VERSION>%d</VERSION>\n", indent, get2B(f));
		for(i = get2B(f); i--;){
			fprintf(xml, "%s<CHANNEL>\n", indent);
			fprintf(xml, "\t%s<ID>%d</ID>\n", indent, get4B(f));
			ed_colorspace(f, level+1, len, parent);
			fprintf(xml, "%s</CHANNEL>\n", indent);
		}
	}
}

static void ir_slices(psd_file_t f, int level, int len, struct dictentry *parent){
	const char *indent = tabs(level);
	unsigned i, origin, version;

	if(xml){
		fprintf(xml, "%s<VERSION>%d</VERSION>\n", indent, version = get4B(f));

		if(version == 6){
			// TODO: Not tested, needs PS6...
			fprintf(xml, "%s<BOUNDS>\n", indent);
			fprintf(xml, "\t%s<TOP>%d</TOP>\n", indent, get4B(f));
			fprintf(xml, "\t%s<LEFT>%d</LEFT>\n", indent, get4B(f));
			fprintf(xml, "\t%s<BOTTOM>%d</BOTTOM>\n", indent, get4B(f));
			fprintf(xml, "\t%s<RIGHT>%d</RIGHT>\n", indent, get4B(f));
			fprintf(xml, "%s</BOUNDS>\n", indent);

			fprintf(xml, "%s<NAME>", indent);
			xml_unicodestr(f, get4B(f));
			fputs("</NAME>\n", xml);

			for(i = get4B(f); i--;){
				fprintf(xml, "%s<SLICE>\n", indent);
				fprintf(xml, "\t%s<ID>%d</ID>\n", indent, get4B(f));
				fprintf(xml, "\t%s<GROUPID>%d</GROUPID>\n", indent, get4B(f));
				fprintf(xml, "\t%s<ORIGIN>%d</ORIGIN>\n", indent, origin = get4B(f));
				if(origin == 1)
					fprintf(xml, "\t%s<ASSOCLAYERID>%d</ASSOCLAYERID>\n", indent, get4B(f));
				fprintf(xml, "\t%s<NAME>", indent);
				xml_unicodestr(f, get4B(f));
				fputs("</NAME>\n", xml);
				fprintf(xml, "\t%s<TYPE>%d</TYPE>\n", indent, get4B(f));
				fprintf(xml, "\t%s<LEFT>%d</LEFT>\n", indent, get4B(f));
				fprintf(xml, "\t%s<TOP>%d</TOP>\n", indent, get4B(f));
				fprintf(xml, "\t%s<RIGHT>%d</RIGHT>\n", indent, get4B(f));
				fprintf(xml, "\t%s<BOTTOM>%d</BOTTOM>\n", indent, get4B(f));
				fprintf(xml, "\t%s<URL>", indent);
				xml_unicodestr(f, get4B(f));
				fputs("</URL>\n", xml);
				fprintf(xml, "\t%s<TARGET>", indent);
				xml_unicodestr(f, get4B(f));
				fputs("</TARGET>\n", xml);
				fprintf(xml, "\t%s<MESSAGE>", indent);
				xml_unicodestr(f, get4B(f));
				fputs("</MESSAGE>\n", xml);
				fprintf(xml, "\t%s<ALT>", indent);
				xml_unicodestr(f, get4B(f));
				fputs("</ALT>\n", xml);
				fprintf(xml, "\t%s<CELLTEXTISHTML>%d</CELLTEXTISHTML>\n", indent, fgetc(f));
				fprintf(xml, "\t%s<CELLTEXT>", indent);
				xml_unicodestr(f, get4B(f));
				fputs("</CELLTEXT>\n", xml);
				fprintf(xml, "\t%s<HALIGN>%d</HALIGN>\n", indent, get4B(f));
				fprintf(xml, "\t%s<VALIGN>%d</VALIGN>\n", indent, get4B(f));
				fprintf(xml, "\t%s<ALPHACOLOR>%d</ALPHACOLOR>\n", indent, fgetc(f));
				fprintf(xml, "\t%s<RED>%d</RED>\n", indent, fgetc(f));
				fprintf(xml, "\t%s<GREEN>%d</GREEN>\n", indent, fgetc(f));
				fprintf(xml, "\t%s<BLUE>%d</BLUE>\n", indent, fgetc(f));
				fprintf(xml, "%s</SLICE>\n", indent);
			}
		}
		else{
			// at least version 8 looks like a Descriptor
			ed_versdesc(f, level, len-4, parent);
		}
	}
}

#define PATHFIX(f) ((double)(f)/0x1000000)

void ir_path(psd_file_t f, int level, int len, struct dictentry *parent){
	const char *indent = tabs(level);
	int subpath_count = 0;

	if(xml)
		for(; len >= 26; len -= 26){
			int i, sel = get2B(f), skip = 24;
			double p[6];

			switch (sel){
			case 0: // closed subpath length record
			case 3: // open subpath length record
				if(!subpath_count){
					subpath_count = get2B(f);
					skip -= 2;
					fprintf(xml, "%s<SUBPATH>\n", indent);
					fprintf(xml, "%s\t<%s/>\n", indent, sel ? "OPEN" : "CLOSED");
				}else
					warn_msg("path resource: unexpected subpath record");
				break;
			case 1: // closed subpath Bezier knot, linked
			case 2: //    "      "       "     "   unlinked
			case 4: // open subpath Bezier knot, linked
			case 5: //  "      "       "     "   unlinked
				if(subpath_count){
					for(i = 0; i < 6; ++i)
						p[i] = PATHFIX(get4B(f));
					skip -= 24;
					fprintf(xml, "%s\t<KNOT>\n", indent);
					fprintf(xml, "%s\t\t<%sLINKED/>\n", indent,
							sel == 1 || sel == 4 ? "" : "UN");
					fprintf(xml, "%s\t\t<IN><V>%.9f</V><H>%.9f</H></IN>\n",
							indent, p[0], p[1]);
					fprintf(xml, "%s\t\t<ANCHOR><V>%.9f</V><H>%.9f</H></ANCHOR>\n",
							indent, p[2], p[3]);
					fprintf(xml, "%s\t\t<OUT><V>%.9f</V><H>%.9f</H></OUT>\n",
							indent, p[4], p[5]);
					fprintf(xml, "%s\t</KNOT>\n", indent);
					--subpath_count;
					if(!subpath_count)
						fprintf(xml, "%s</SUBPATH>\n", indent);
				}else
					warn_msg("path resource: unexpected knot record");
				break;
			case 6: // path fill rule record
				fprintf(xml, "%s<PATHFILLRULE/>\n", indent);
				break;
			case 7: // clipboard record
				fprintf(xml, "%s<CLIPBOARD>\n", indent);
				fprintf(xml, "%s\t<BOUNDS>\n", indent);
				fprintf(xml, "%s\t\t<TOP>%.9f</TOP>\n", indent, PATHFIX(get4B(f)));
				fprintf(xml, "%s\t\t<LEFT>%.9f</LEFT>\n", indent, PATHFIX(get4B(f)));
				fprintf(xml, "%s\t\t<BOTTOM>%.9f</BOTTOM>\n", indent, PATHFIX(get4B(f)));
				fprintf(xml, "%s\t\t<RIGHT>%.9f</RIGHT>\n", indent, PATHFIX(get4B(f)));
				fprintf(xml, "%s\t</BOUNDS>\n", indent);
				fprintf(xml, "%s\t<RESOLUTION>%.9f</RESOLUTION>\n", indent, PATHFIX(get4B(f)));
				fprintf(xml, "%s</CLIPBOARD>\n", indent);
				skip -= 20;
				break;
			case 8: // initial fill rule record
				fprintf(xml, "%s<INITIALFILL>%d</INITIALFILL>\n", indent, get2B(f));
				skip -= 2;
				break;
			default:
				warn_msg("path resource: unexpected record selector");
			}
			if(skip)
				fseeko(f, skip, SEEK_CUR);
		}
}

// id, key, tag, desc, func
static struct dictentry rdesc[] = {
	{1000, NULL, NULL, "PS2.0 mode data", NULL},
	{1001, NULL, NULL, "Macintosh print record", NULL},
	{1003, NULL, NULL, "PS2.0 indexed color table", NULL},
	{1005, NULL, "-RESOLUTION", "ResolutionInfo", ir_resolution},
	{1006, NULL, "ALPHANAMES", "Alpha names", ir_pstrings},
	{1007, NULL, "DISPLAYINFO", "DisplayInfo", ir_displayinfo},
	{1008, NULL, "-CAPTION", "Caption", ir_pstring},
	{1009, NULL, NULL, "Border information", NULL},
	{1010, NULL, "BGCOLOR", "Background color", ed_colorspace},
	{1011, NULL, "PRINTFLAGS", "Print flags", ir_printflags},
	{1012, NULL, NULL, "Grayscale/multichannel halftoning info", NULL},
	{1013, NULL, NULL, "Color halftoning info", NULL},
	{1014, NULL, NULL, "Duotone halftoning info", NULL},
	{1015, NULL, NULL, "Grayscale/multichannel transfer function", NULL},
	{1016, NULL, NULL, "Color transfer functions", NULL},
	{1017, NULL, NULL, "Duotone transfer functions", NULL},
	{1018, NULL, NULL, "Duotone image info", NULL},
	{1019, NULL, NULL, "B&W values for the dot range", NULL},
	{1021, NULL, NULL, "EPS options", NULL},
	{1022, NULL, NULL, "Quick Mask info", NULL},
	{1024, NULL, "-TARGETLAYER", "Layer state info", ir_2byte},
	{1025, NULL, "WORKINGPATH", "Working path", ir_path},
	{1026, NULL, "LAYERSGROUP", "Layers group info", ir_layersgroup},
	{1028, NULL, NULL, "IPTC-NAA record (File Info)", NULL},
	{1029, NULL, NULL, "Image mode for raw format files", NULL},
	{1030, NULL, NULL, "JPEG quality", NULL},
	// v4.0
	{1032, NULL, "GRIDGUIDES", "Grid and guides info", ir_gridguides},
	{1033, NULL, NULL, "Thumbnail resource", NULL},
	{1034, NULL, "-COPYRIGHTFLAG", "Copyright flag", ir_1byte},
	{1035, NULL, "-URL", "URL", ir_string}, // incorrectly documented as Pascal string
	// v5.0
	{1036, NULL, NULL, "Thumbnail resource (5.0)", NULL},
	{1037, NULL, "-GLOBALANGLE", "Global Angle", ir_4byte},
	{1038, NULL, "COLORSAMPLERS", "Color samplers resource", ir_colorsamplers},
	{1039, NULL, "ICC34", "ICC Profile", ir_icc34profile},
	{1040, NULL, "-WATERMARK", "Watermark", ir_1byte},
	{1041, NULL, "-ICCUNTAGGED", "ICC Untagged Profile", ir_1byte},
	{1042, NULL, "-EFFECTSVISIBLE", "Effects visible", ir_1byte},
	{1043, NULL, NULL, "Spot Halftone", NULL},
	{1044, NULL, "-DOCUMENTIDSEED", "Document specific IDs", ir_4byte},
	{1045, NULL, "ALPHANAMESUNICODE", "Unicode Alpha Names", ir_unicodestrings},
	// v6.0
	{1046, NULL, "-COLORTABLECOUNT", "Indexed Color Table Count", ir_2byte},
	{1047, NULL, "-TRANSPARENTINDEX", "Transparent Index", ir_2byte},
	{1049, NULL, "-GLOBALALTITUDE", "Global Altitude", ir_4byte},
	{1050, NULL, "SLICES", "Slices", ir_slices},
	{1051, NULL, "-WORKFLOWURL", "Workflow URL", ir_unicodestr},
	{1052, NULL, NULL, "Jump To XPEP", NULL},
	{1053, NULL, "ALPHAIDS", "Alpha Identifiers", ir_alphaids},
	{1054, NULL, NULL, "URL List", NULL},
	{1057, NULL, NULL, "Version Info", NULL},
	// v7.0 - from CS doc
	{1058, NULL, NULL, "EXIF data 1", NULL},
	{1059, NULL, NULL, "EXIF data 3", NULL},
	{1060, NULL, "XMP", "XMP metadata", ir_cdata},
	{1061, NULL, "-CAPTIONDIGEST", "Caption digest (RSA MD5)", ir_digest},
	{1062, NULL, NULL, "Print scale", NULL},
	// CS
	{1064, NULL, "-PIXELASPECTRATIO", "Pixel aspect ratio", ir_pixelaspect},
	{1065, NULL, "LAYERCOMPS", "Layer comps", ed_versdesc},
	{1066, NULL, "ALTDUOTONECOLORS", "Alternate duotone colors", ir_altduotonecolors},
	{1067, NULL, "ALTSPOTCOLORS", "Alternate spot colors", ir_altspotcolors},

	// CS2 - July 2010 document
	{1069, NULL, "LAYERSELECTIONIDS", "Layer Selection ID(s)", ir_layerselectionids},
	{1070, NULL, NULL, "HDR Toning information", NULL},
	{1071, NULL, NULL, "Print info", NULL},
	{1072, NULL, NULL, "Layer Group(s) Enabled ID", NULL},

	// CS3 - July 2010 document
	{1073, NULL, "COLORSAMPLERSCS3", "Color samplers resource (CS3)", ir_colorsamplers},
	{1074, NULL, "MEASUREMENTSCALE", "Measurement Scale", ed_versdesc},
	{1075, NULL, "TIMELINE", "Timeline Information", ed_versdesc},
	{1076, NULL, "SHEETDISCLOSURE", "Sheet Disclosure", ed_versdesc},
	{1077, NULL, "DISPLAYINFOCS3", "DisplayInfo (CS3)", ir_displayinfocs3},
	{1078, NULL, "ONIONSKINS", "Onion Skins", ed_versdesc},

	// CS4 - July 2010 document
	{1080, NULL, "COUNT", "Count Information", ed_versdesc},

	// CS5 - July 2010 document
	{1082, NULL, "PRINTSETTINGS", "Print Information", ed_versdesc},
	{1083, NULL, "PRINTSTYLE", "Print Style", ed_versdesc},
	{1084, NULL, NULL, "Macintosh NSPrintInfo", NULL},
	{1085, NULL, NULL, "Windows DEVMODE", NULL},

	{7000, NULL, "IMAGEREADYVARS", "ImageReady variables", ir_cdata},
	{7001, NULL, NULL, "ImageReady data sets", NULL},

	{8000, NULL, NULL, "Lightroom workflow", NULL}, // CS3 per July 2010 document

	{2999, NULL, "-CLIPPINGPATH", "Name of clipping path", ir_pstring},
	{10000,NULL, "PRINTFLAGS10K", "Print flags info", ir_printflags10k},
	{-1, NULL, NULL, NULL, NULL}
};

static struct dictentry *findbyid(int id){
	static struct dictentry path = {0, NULL, "PATH", "Path", ir_path};
	struct dictentry *d;

	/* dumb linear lookup of description string from resource id */
	/* assumes array ends with a NULL desc pointer */
	if(id >= 2000 && id <= 2998)
		return &path; // special case
	for(d = rdesc; d->desc; ++d)
		if(d->id == id)
			return d;
	return NULL;
}

static long doirb(psd_file_t f){
	static struct dictentry resource = {0, NULL, "RESOURCE", "dummy", NULL};
	char type[4], name[0x100];
	int id, namelen;
	long size;
	size_t padded_size;
	struct dictentry *d;

	fread(type, 1, 4, f);
	id = get2B(f);
	namelen = fgetc(f);
	fread(name, 1, PAD2(1+namelen)-1, f);
	name[namelen] = 0;
	size = get4B(f);
	padded_size = PAD2(size);

	d = findbyid(id);
	if((verbose || print_rsrc || resdump) && !xmlout){
		printf("  resource '%c%c%c%c' (%5d,\"%s\"):%5ld bytes",
			   type[0],type[1],type[2],type[3], id, name, size);
		if(d)
			printf(" [%s]", d->desc);
		putchar('\n');
	}

	if(d && d->tag){
		if(xml){
			fprintf(xml, "\t<RESOURCE TYPE='%c%c%c%c' ID='%d'",
					type[0],type[1],type[2],type[3], id);
			if(namelen)
				fprintf(xml, " NAME='%s'", name);
		}
		if(d->func){
			if(xml) fputs(">\n", xml);

			entertag(f, 2, size, &resource, d, 1);

			if(xml) fputs("\t</RESOURCE>\n\n", xml);
		}
		else if(xml){
			fputs(" /> <!-- not parsed -->\n", xml);
		}
	}

	if(resdump){
		char *temp_buf = checkmalloc(padded_size);
		if(fread(temp_buf, 1, padded_size, f) < padded_size)
			fatal("did not read expected bytes in image resource\n");
		dumphex((unsigned char*)temp_buf, size);
		putchar('\n');
		free(temp_buf);
	}
	else
		fseeko(f, padded_size, SEEK_CUR); // skip resource block data

	return 4+2+PAD2(1+namelen)+4+padded_size; /* returns total bytes in block */
}

void doimageresources(psd_file_t f){
	long len = get4B(f);
	VERBOSE("\nImage resources (%ld bytes):\n", len);
	while(len > 0)
		len -= doirb(f);
	if(len != 0)
		warn_msg("image resources overran expected size by %d bytes\n", -len);
}