[apple/xnu.git] / osfmk / console / panic_ui / setupdialog.c

/* setupdialog : converts a RAW image file into the c structure that the
 * kernel panic ui system expects.
 *
 * to build: cc -o setupdialog setupdialog.c
*/

#include <stdio.h>
#include <sys/types.h>
#include <fcntl.h>

#define RUN_MAX 32767

void create_numbers_file( FILE *stream, char *outfile );
unsigned int encode_rle(unsigned char * fileArr, unsigned int filePos, unsigned int quantity, unsigned char value);

void
usage(void) {
    printf("\nusage: setupdialog -i <image file> -oi <image output> -n <numbers file> -on <numbers output>\n");
    
    printf("\nYou can supply a panic image file, a numbers file, or both. Input files\n");
    printf("must be in RAW format where each pixel is represented by an index into the\n");
    printf("MacOS X system CLUT. The first %d bytes must be the width, height, and depth\n", 3 * sizeof(short));
    printf("(in that order, %d bytes each).\n", sizeof(short));

    printf("\nThe output files are generated C structures in the format the panic ui code\n");
    printf("expects (default output files are panic_image.c and rendered_numbers.c).\n\n");
}

int 
main( int argc, char *argv[] )
{
    int		next;
    char 	*file = NULL, *ptr, *out = NULL, *numsfile = NULL, *numsout = NULL;
    FILE *	stream, *out_stream;
    int *	data;
    short 	width = 0, height = 0, depth = 0;
    char	word[2];
    char	byte;
    unsigned int i, pixels, filePos;
    int		err;
    unsigned char *fileArr;
    unsigned char nextP;
    unsigned int count;
    int currP;
    int fd;
    int pairs_this_line;


    // pull apart the arguments
    for( next = 1; next < argc; next++ )
    {
        if (strcmp(argv[next], "-i") == 0) // image file (RAW/PICT?)
            file = argv[++next];
        else if (strcmp(argv[next], "-n") == 0) // numbers/chars image file (RAW)
            numsfile = argv[++next];
        else if (strcmp(argv[next], "-oi") == 0) // output file for image
            out = argv[++next];
        else if (strcmp(argv[next], "-on") == 0) // output file for numbers
            numsout = argv[++next];
	
	/* perhaps we should just let the user specify the W/H rather than require the header */
	/*
        else if (strcmp(argv[next], "-w") == 0) // image width (pixels)
            width = strtoul(argv[++next], &ptr, 0);
        else if (strcmp(argv[next], "-h") == 0) // image height (pixels)
            width = strtoul(argv[++next], &ptr, 0);
	*/
    }
    
    if (!(numsfile || file)) {
	usage();
	exit(1);
    }

    if (!numsfile) {
	printf("\nNo numbers file to process\n");
    } else {
        stream = fopen(numsfile, "r");
        if (!stream) {
            printf("bad nums infile.. bailing.\n");
            exit(1);
        }
        create_numbers_file( stream, numsout );
        fclose(stream);
    }
    
    if( file == NULL) {
        printf("\nNo image file to process\n");
        exit(1);
    }
    
    stream = fopen(file, "r");
    if (!stream) {
        printf("bad infile.. bailing.\n");
        exit(1);
    }
    
    printf("\nReading image file...\n");

    fread((void *) &width, sizeof(short), 1, stream);
    printf("got width: %d\n", width);
    fread((void *) &height, sizeof(short), 1, stream);
    printf("got height: %d\n", height);
    fread((void *) &depth, sizeof(short), 1, stream);
    printf("got depth: %d\n", depth);
    
    if (!(width && height && depth)) {
	printf("Invalid image file header (width, height, or depth is 0)\n");
	exit(1);
    }

    pixels = width * height;

    if (!(fileArr = (unsigned char *) malloc(pixels))) {
	printf("couldn't malloc fileArr (%d pixels)... bailing.\n", pixels);
	exit(1);
    }
    
    currP = -1;
    count = 0;
    filePos = 0; // position in the file we're writing out
    
    for (i=0; i < pixels; i++) {
        nextP = fgetc(stream);
        count++;
        if (nextP == currP) {
            if (count >= RUN_MAX) {
                    filePos += encode_rle(fileArr, filePos, count, (unsigned char) currP);
                    count = 0;
                    currP = -1;
            } 
        } else {
            if (currP != -1) {
                filePos += encode_rle(fileArr, filePos, count-1, (unsigned char) currP);
            }
            currP = nextP; // start a new run
            count = 1;
        }
    }
    
    // write out any run that was in progress
    if (count > 0) {
        filePos += encode_rle(fileArr, filePos, count, (unsigned char) currP);
    }	
    
    fclose( stream ); 

    // now, generate the c file
    
    if ( out == NULL)
        out = "panic_image.c";
    out_stream = fopen(out, "w");
    
    if(out_stream == NULL) {
        printf("couldn't open out file.. bailing\n");
        exit(1);
    }
    
    pairs_this_line = 0;
    
    fprintf( out_stream, "/* generated c file */\n\n");
    fprintf( out_stream, "static const struct {\n");
    fprintf( out_stream, "  unsigned int 	 pd_width;\n");
    fprintf( out_stream, "  unsigned int 	 pd_height;\n");
    fprintf( out_stream, "  unsigned int 	 bytes_per_pixel; /* 1: CLUT, 3:RGB, 4:RGBA */\n");
    fprintf( out_stream, "  unsigned char	 image_pixel_data[%#4.2x];\n", (filePos));

    fprintf( out_stream, "} panic_dialog = {\n");
    fprintf( out_stream, "\t%d, ", width);		/* panic dialog x */
    fprintf( out_stream, "%d, ", height);		/* panic dialog y */
    fprintf( out_stream, "1,\n");			/* bytes per pixel */
   
    for( i=0; i < filePos;) {
    	fprintf( out_stream, "0x%.2x,0x%.2x", fileArr[i], fileArr[i+1]);
	i+=2;
        pairs_this_line++;
        
        // if the first byte had a leading 1, this is a 3-byte encoding
        if ((fileArr[i-2] >> 7) == 1) {
            fprintf( out_stream, ",0x%.2x", fileArr[i++]);
	    pairs_this_line++;
        }
        
        if (i >= filePos) // this is the last element
            fprintf( out_stream, "\n};");
        else fprintf( out_stream, ", ");
       
        if(pairs_this_line > 8) {
            fprintf( out_stream, "\n");
            pairs_this_line = 0;
        }
    }
    
  
  fclose( out_stream );

  return 0;
}


/* Each number/char (0-f) has its own row in the pixmap array.
    When done, these rows each contain an RLE character.
    The image file is read row by row, so the individual characters
    must be constructed in the same way. The numPos array tracks the
    current position in each character's RLE array.
    */
void
create_numbers_file( FILE *stream, char *outfile )
{
    int		err;
    short	height, depth, totalwidth;
    int		numbers = 17;
    int         width[17] = {9,7,8,6,9,7,8,7,8,7,10,7,9,10,7,6,4};
    int		numPos[17] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; 
    
    int **pixmap;
    int		row, col, item, line=0, currWidth;
    int nextP, currP;
    int count, currNum;
    
    FILE	*out_stream;

    printf("\nReading numbers file...\n");
    fread((void *) &totalwidth, sizeof(short), 1, stream);
    printf("got width: %d\n", totalwidth);
    fread((void *) &height, sizeof(short), 1, stream);
    printf("got height: %d\n", height);
    fread((void *) &depth, sizeof(short), 1, stream);
    printf("got depth: %d\n", depth);
    
    if (!(width && height && depth)) {
	printf("Invalid numbers file header (width, height, or depth is 0)\n");
	return;
    }

    // allocate array to hold each number's RLE encoding (20 = 2xwidest width[i] value, 17 = num chars)
    pixmap = (int **) malloc( 17 * sizeof(int *) );
    for( item=0; item<17; item++)
        pixmap[item] = (int *) malloc( 2*width[item]*height*sizeof(int) );
    
    currP = -1;
    count = 0;
    currWidth = 0;
    currNum = 0;
    
    for( row=0; row < height; row++) {
        for( item=0; item < numbers; item++) {
            count = 0;
            currP = -1; // start each character fresh
            for( col=0; col < width[item]; col++) {
                nextP = fgetc( stream );
                if( nextP == currP) {
                    if( count == 127) { // probably never executed given the small widths
                        pixmap[item][numPos[item]] = count;
                        pixmap[item][numPos[item]+1] = currP;
                        numPos[item]+=2;
                        count = 0;
                        currP = -1;
                    } else count++; // add one to the current run
                } else {
                    if( currP != -1) {
                        pixmap[item][numPos[item]] = count; // currP was the end of the run
                        pixmap[item][numPos[item]+1] = currP;
                        numPos[item]+=2;
                    }
                    currP = nextP; // start a new run
                    count = 1;
                }
            }	
            // write out any run that was in progress
            if( count > 0) {
                pixmap[item][numPos[item]] = count;
                pixmap[item][numPos[item]+1] = currP;
                numPos[item]+=2;
            }
        }
    }
    
    // now, generate the c file
    
    if ( outfile == NULL)
        outfile = "rendered_numbers.c";
    out_stream = fopen(outfile, "w");
    
    if(out_stream == NULL) {
        printf("couldn't open numbers outfile.. bailing\n");
        exit(1);
    }
    
    fprintf( out_stream, " /* generated c file */\n\n");
    
    // iterate through all the numbers/chars
    for( item=0; item<numbers; item++)
    {
        fprintf( out_stream, "static const struct {\n");
        fprintf( out_stream, "  unsigned int 	 num_w;\n");
        fprintf( out_stream, "  unsigned int 	 num_h;\n");			
        fprintf( out_stream, "  unsigned char	 num_pixel_data[%#4.2x];\n", numPos[item]); // num elems
        item == 16 ? fprintf( out_stream, "} num_colon = {\n") : fprintf( out_stream, "} num_%x = {\n", item);
        fprintf( out_stream, "/* w */ %d,\n", width[item]);
        fprintf( out_stream, "/* h */ %d,\n", height);
        fprintf( out_stream, "/* pixel_data */ \n");
            
        for( col = 0; col < numPos[item];)
        {
            fprintf( out_stream, "0x%.2x,0x%.2x", pixmap[item][col], pixmap[item][col+1]);
            if (col == (numPos[item] - 2)) // this is the last element
                fprintf( out_stream, "\n};\n\n");
            else fprintf( out_stream, ", ");
            
            line+=pixmap[item][col];
            if( line >= width[item]) {
                fprintf( out_stream, "\n");
                line = 0;
            }
            col+=2;
        }
    }
    
  fclose( out_stream );
}


/* 	encode_rle applies a "modified-RLE encoding to a given image. The encoding works as follows:
        
        The quantity and value will be described by either two or three bytes. If the
        most significant bit of the first byte is a 0, then the next seven bits are
        the quantity (run-length) and the following 8 bits are the value (index into
        a clut, in this case). If the msb of the first byte is a 1, then the next 15 bits
        are the quantity and the following 8 are the value. Visually, the two possible
        encodings are: (q = quantity, v = value)
        
          Byte 1			   Byte 2		        Byte 3
  case 1: [ 0 q6 q5 q4 q3 q2 q1 q0 ]       [ v7 v6 v5 v4 v3 v2 v1 v0 ]  [ ]
  case 2: [ 1 q14 q13 q12 a11 q10 q9 q8 ]  [ q7 q6 q5 q4 q3 q2 q1 q0 ]  [ v7 v6 v5 v4 v3 v2 v1 v0 ]
*/


unsigned int
encode_rle(unsigned char * fileArr, unsigned int filePos, unsigned int quantity, unsigned char value)
{
    unsigned char single_mask = 0x00;
    unsigned char double_mask = 0x80;
    unsigned char slots_used = 0;
    
    if (quantity < 128) {
        fileArr[filePos] = single_mask | quantity;
        slots_used = 1;
    } else {
        fileArr[filePos] = double_mask | (quantity >> 8); // high 7 bits (plus mask)
        fileArr[filePos+1] = (unsigned char) quantity; // low 8 bits
        slots_used = 2;
    }
    
    fileArr[filePos+slots_used] = value;
    slots_used++;
    
    return slots_used;
}
Commit	Line	Data
91447636 A	1	/* setupdialog : converts a RAW image file into the c structure that the
	2	* kernel panic ui system expects.
	3	*
	4	* to build: cc -o setupdialog setupdialog.c
	5	*/
	6
	7	#include <stdio.h>
	8	#include <sys/types.h>
	9	#include <fcntl.h>
	10
	11	#define RUN_MAX 32767
	12
	13	void create_numbers_file( FILE stream, char outfile );
	14	unsigned int encode_rle(unsigned char * fileArr, unsigned int filePos, unsigned int quantity, unsigned char value);
	15
	16	void
	17	usage(void) {
	18	printf("\nusage: setupdialog -i <image file> -oi <image output> -n <numbers file> -on <numbers output>\n");
	19
	20	printf("\nYou can supply a panic image file, a numbers file, or both. Input files\n");
	21	printf("must be in RAW format where each pixel is represented by an index into the\n");
	22	printf("MacOS X system CLUT. The first %d bytes must be the width, height, and depth\n", 3 * sizeof(short));
	23	printf("(in that order, %d bytes each).\n", sizeof(short));
	24
	25	printf("\nThe output files are generated C structures in the format the panic ui code\n");
	26	printf("expects (default output files are panic_image.c and rendered_numbers.c).\n\n");
	27	}
	28
	29	int
	30	main( int argc, char *argv[] )
	31	{
	32	int next;
	33	char file = NULL, ptr, out = NULL, numsfile = NULL, *numsout = NULL;
	34	FILE * stream, *out_stream;
	35	int * data;
	36	short width = 0, height = 0, depth = 0;
	37	char word[2];
	38	char byte;
	39	unsigned int i, pixels, filePos;
	40	int err;
	41	unsigned char *fileArr;
	42	unsigned char nextP;
	43	unsigned int count;
	44	int currP;
	45	int fd;
	46	int pairs_this_line;
	47
	48
	49	// pull apart the arguments
	50	for( next = 1; next < argc; next++ )
	51	{
	52	if (strcmp(argv[next], "-i") == 0) // image file (RAW/PICT?)
	53	file = argv[++next];
	54	else if (strcmp(argv[next], "-n") == 0) // numbers/chars image file (RAW)
	55	numsfile = argv[++next];
	56	else if (strcmp(argv[next], "-oi") == 0) // output file for image
	57	out = argv[++next];
	58	else if (strcmp(argv[next], "-on") == 0) // output file for numbers
	59	numsout = argv[++next];
	60
	61	/* perhaps we should just let the user specify the W/H rather than require the header */
	62	/*
	63	else if (strcmp(argv[next], "-w") == 0) // image width (pixels)
	64	width = strtoul(argv[++next], &ptr, 0);
65	else if (strcmp(argv[next], "-h") == 0) // image height (pixels)
66	width = strtoul(argv[++next], &ptr, 0);
67	*/
68	}
69
70	if (!(numsfile \|\| file)) {
71	usage();
72	exit(1);
73	}
74
75	if (!numsfile) {
76	printf("\nNo numbers file to process\n");
77	} else {
78	stream = fopen(numsfile, "r");
79	if (!stream) {
80	printf("bad nums infile.. bailing.\n");
81	exit(1);
82	}
83	create_numbers_file( stream, numsout );
84	fclose(stream);
85	}
86
87	if( file == NULL) {
88	printf("\nNo image file to process\n");
89	exit(1);
90	}
91
92	stream = fopen(file, "r");
93	if (!stream) {
94	printf("bad infile.. bailing.\n");
95	exit(1);
96	}
97
98	printf("\nReading image file...\n");
99
100	fread((void *) &width, sizeof(short), 1, stream);
101	printf("got width: %d\n", width);
102	fread((void *) &height, sizeof(short), 1, stream);
103	printf("got height: %d\n", height);
104	fread((void *) &depth, sizeof(short), 1, stream);
105	printf("got depth: %d\n", depth);
106
107	if (!(width && height && depth)) {
108	printf("Invalid image file header (width, height, or depth is 0)\n");
109	exit(1);
110	}
111
112	pixels = width * height;
113
114	if (!(fileArr = (unsigned char *) malloc(pixels))) {
115	printf("couldn't malloc fileArr (%d pixels)... bailing.\n", pixels);
116	exit(1);
117	}
118
119	currP = -1;
120	count = 0;
121	filePos = 0; // position in the file we're writing out
122
123	for (i=0; i < pixels; i++) {
124	nextP = fgetc(stream);
125	count++;
126	if (nextP == currP) {
127	if (count >= RUN_MAX) {
128	filePos += encode_rle(fileArr, filePos, count, (unsigned char) currP);
129	count = 0;
130	currP = -1;
131	}
132	} else {
133	if (currP != -1) {
134	filePos += encode_rle(fileArr, filePos, count-1, (unsigned char) currP);
135	}
136	currP = nextP; // start a new run
137	count = 1;
138	}
139	}
140
141	// write out any run that was in progress
142	if (count > 0) {
143	filePos += encode_rle(fileArr, filePos, count, (unsigned char) currP);
144	}
145
146	fclose( stream );
147
148	// now, generate the c file
149
150	if ( out == NULL)
151	out = "panic_image.c";
152	out_stream = fopen(out, "w");
153
154	if(out_stream == NULL) {
155	printf("couldn't open out file.. bailing\n");
156	exit(1);
157	}
158
159	pairs_this_line = 0;
160
161	fprintf( out_stream, "/* generated c file */\n\n");
162	fprintf( out_stream, "static const struct {\n");
163	fprintf( out_stream, " unsigned int pd_width;\n");
164	fprintf( out_stream, " unsigned int pd_height;\n");
165	fprintf( out_stream, " unsigned int bytes_per_pixel; /* 1: CLUT, 3:RGB, 4:RGBA */\n");
166	fprintf( out_stream, " unsigned char image_pixel_data[%#4.2x];\n", (filePos));
167
168	fprintf( out_stream, "} panic_dialog = {\n");
169	fprintf( out_stream, "\t%d, ", width); /* panic dialog x */
170	fprintf( out_stream, "%d, ", height); /* panic dialog y */
171	fprintf( out_stream, "1,\n"); /* bytes per pixel */
172
173	for( i=0; i < filePos;) {
174	fprintf( out_stream, "0x%.2x,0x%.2x", fileArr[i], fileArr[i+1]);
175	i+=2;
176	pairs_this_line++;
177
178	// if the first byte had a leading 1, this is a 3-byte encoding
179	if ((fileArr[i-2] >> 7) == 1) {
180	fprintf( out_stream, ",0x%.2x", fileArr[i++]);
181	pairs_this_line++;
182	}
183
184	if (i >= filePos) // this is the last element
185	fprintf( out_stream, "\n};");
186	else fprintf( out_stream, ", ");
187
188	if(pairs_this_line > 8) {
189	fprintf( out_stream, "\n");
190	pairs_this_line = 0;
191	}
192	}
193
194
195	fclose( out_stream );
196
197	return 0;
198	}
199
200
201	/* Each number/char (0-f) has its own row in the pixmap array.
202	When done, these rows each contain an RLE character.
203	The image file is read row by row, so the individual characters
204	must be constructed in the same way. The numPos array tracks the
205	current position in each character's RLE array.
206	*/
207	void
208	create_numbers_file( FILE stream, char outfile )
209	{
210	int err;
211	short height, depth, totalwidth;
212	int numbers = 17;
213	int width[17] = {9,7,8,6,9,7,8,7,8,7,10,7,9,10,7,6,4};
214	int numPos[17] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
215
216	int **pixmap;
217	int row, col, item, line=0, currWidth;
218	int nextP, currP;
219	int count, currNum;
220
221	FILE *out_stream;
222
223	printf("\nReading numbers file...\n");
224	fread((void *) &totalwidth, sizeof(short), 1, stream);
225	printf("got width: %d\n", totalwidth);
226	fread((void *) &height, sizeof(short), 1, stream);
227	printf("got height: %d\n", height);
228	fread((void *) &depth, sizeof(short), 1, stream);
229	printf("got depth: %d\n", depth);
230
231	if (!(width && height && depth)) {
232	printf("Invalid numbers file header (width, height, or depth is 0)\n");
233	return;
234	}
235
236	// allocate array to hold each number's RLE encoding (20 = 2xwidest width[i] value, 17 = num chars)
237	pixmap = (int *) malloc( 17 sizeof(int *) );
238	for( item=0; item<17; item++)
239	pixmap[item] = (int ) malloc( 2width[item]heightsizeof(int) );
240
241	currP = -1;
242	count = 0;
243	currWidth = 0;
244	currNum = 0;
245
246	for( row=0; row < height; row++) {
247	for( item=0; item < numbers; item++) {
248	count = 0;
249	currP = -1; // start each character fresh
250	for( col=0; col < width[item]; col++) {
251	nextP = fgetc( stream );
252	if( nextP == currP) {
253	if( count == 127) { // probably never executed given the small widths
254	pixmap[item][numPos[item]] = count;
255	pixmap[item][numPos[item]+1] = currP;
256	numPos[item]+=2;
257	count = 0;
258	currP = -1;
259	} else count++; // add one to the current run
260	} else {
261	if( currP != -1) {
262	pixmap[item][numPos[item]] = count; // currP was the end of the run
263	pixmap[item][numPos[item]+1] = currP;
264	numPos[item]+=2;
265	}
266	currP = nextP; // start a new run
267	count = 1;
268	}
269	}
270	// write out any run that was in progress
271	if( count > 0) {
272	pixmap[item][numPos[item]] = count;
273	pixmap[item][numPos[item]+1] = currP;
274	numPos[item]+=2;
275	}
276	}
277	}
278
279	// now, generate the c file
280
281	if ( outfile == NULL)
282	outfile = "rendered_numbers.c";
283	out_stream = fopen(outfile, "w");
284
285	if(out_stream == NULL) {
286	printf("couldn't open numbers outfile.. bailing\n");
287	exit(1);
288	}
289
290	fprintf( out_stream, " /* generated c file */\n\n");
291
292	// iterate through all the numbers/chars
293	for( item=0; item<numbers; item++)
294	{
295	fprintf( out_stream, "static const struct {\n");
296	fprintf( out_stream, " unsigned int num_w;\n");
297	fprintf( out_stream, " unsigned int num_h;\n");
298	fprintf( out_stream, " unsigned char num_pixel_data[%#4.2x];\n", numPos[item]); // num elems
299	item == 16 ? fprintf( out_stream, "} num_colon = {\n") : fprintf( out_stream, "} num_%x = {\n", item);
300	fprintf( out_stream, "/* w */ %d,\n", width[item]);
301	fprintf( out_stream, "/* h */ %d,\n", height);
302	fprintf( out_stream, "/* pixel_data */ \n");
303
304	for( col = 0; col < numPos[item];)
305	{
306	fprintf( out_stream, "0x%.2x,0x%.2x", pixmap[item][col], pixmap[item][col+1]);
307	if (col == (numPos[item] - 2)) // this is the last element
308	fprintf( out_stream, "\n};\n\n");
309	else fprintf( out_stream, ", ");
310
311	line+=pixmap[item][col];
312	if( line >= width[item]) {
313	fprintf( out_stream, "\n");
314	line = 0;
315	}
316	col+=2;
317	}
318	}
319
320	fclose( out_stream );
321	}
322
323
324	/* encode_rle applies a "modified-RLE encoding to a given image. The encoding works as follows:
325
326	The quantity and value will be described by either two or three bytes. If the
327	most significant bit of the first byte is a 0, then the next seven bits are
328	the quantity (run-length) and the following 8 bits are the value (index into
329	a clut, in this case). If the msb of the first byte is a 1, then the next 15 bits
330	are the quantity and the following 8 are the value. Visually, the two possible
331	encodings are: (q = quantity, v = value)
332
333	Byte 1 Byte 2 Byte 3
334	case 1: [ 0 q6 q5 q4 q3 q2 q1 q0 ] [ v7 v6 v5 v4 v3 v2 v1 v0 ] [ ]
335	case 2: [ 1 q14 q13 q12 a11 q10 q9 q8 ] [ q7 q6 q5 q4 q3 q2 q1 q0 ] [ v7 v6 v5 v4 v3 v2 v1 v0 ]
336	*/
337
338
339	unsigned int
340	encode_rle(unsigned char * fileArr, unsigned int filePos, unsigned int quantity, unsigned char value)
341	{
342	unsigned char single_mask = 0x00;
343	unsigned char double_mask = 0x80;
344	unsigned char slots_used = 0;
345
346	if (quantity < 128) {
347	fileArr[filePos] = single_mask \| quantity;
348	slots_used = 1;
349	} else {
350	fileArr[filePos] = double_mask \| (quantity >> 8); // high 7 bits (plus mask)
351	fileArr[filePos+1] = (unsigned char) quantity; // low 8 bits
352	slots_used = 2;
353	}
354
355	fileArr[filePos+slots_used] = value;
356	slots_used++;
357
358	return slots_used;
359	}