[picodrive.git] / pico / cd / cue.c

/*
 * cuefile handling
 * (C) notaz, 2008
 *
 * This work is licensed under the terms of MAME license.
 * See COPYING file in the top-level directory.
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "cue.h"

#include "../pico_int.h"
// #define elprintf(w,f,...) printf(f "\n",##__VA_ARGS__);

#ifdef _MSC_VER
#define snprintf _snprintf
#endif
#ifdef __EPOC32__
#define snprintf(b,s,...) sprintf(b,##__VA_ARGS__)
#endif

static char *mystrip(char *str)
{
	int i, len;

	len = strlen(str);
	for (i = 0; i < len; i++)
		if (str[i] != ' ') break;
	if (i > 0) memmove(str, str + i, len - i + 1);

	len = strlen(str);
	for (i = len - 1; i >= 0; i--)
		if (str[i] != ' ' && str[i] != '\r' && str[i] != '\n') break;
	str[i+1] = 0;

	return str;
}

static int get_token(const char *buff, char *dest, int len)
{
	const char *p = buff;
	char sep = ' ';
	int d = 0, skip = 0;

	while (*p && *p == ' ') {
		skip++;
		p++;
	}

	if (*p == '\"') {
		sep = '\"';
		p++;
	}
	while (*p && *p != sep && d < len-1)
		dest[d++] = *p++;
	dest[d] = 0;

	if (sep == '\"' && *p != sep)
		elprintf(EL_STATUS, "cue: bad token: \"%s\"", buff);

	return d + skip;
}

static int get_ext(const char *fname, char ext[4],
	char *base, size_t base_size)
{
	int len, pos = 0;
	
	len = strlen(fname);
	if (len >= 3)
		pos = len - 3;

	strcpy(ext, fname + pos);

	if (base != NULL) {
		len = pos;
		if (len + 1 < base_size)
			len = base_size - 1;
		memcpy(base, fname, len);
		base[len] = 0;
	}
	return pos;
}

static void change_case(char *p, int to_upper)
{
	for (; *p != 0; p++) {
		if (to_upper && 'a' <= *p && *p <= 'z')
			*p += 'A' - 'a';
		else if (!to_upper && 'A' <= *p && *p <= 'Z')
			*p += 'a' - 'A';
	}
}

static int file_openable(const char *fname)
{
	FILE *f = fopen(fname, "rb");
	if (f == NULL)
		return 0;
	fclose(f);
	return 1;
}

#define BEGINS(buff,str) (strncmp(buff,str,sizeof(str)-1) == 0)

/* note: tracks[0] is not used */
cue_data_t *cue_parse(const char *fname)
{
	char current_file[256], *current_filep, cue_base[256];
	char buff[256], buff2[32], ext[4], *p;
	int ret, count = 0, count_alloc = 2, pending_pregap = 0;
	size_t current_filep_size, fname_len;
	cue_data_t *data = NULL;
	FILE *f = NULL;
	void *tmp;

	if (fname == NULL || (fname_len = strlen(fname)) == 0)
		return NULL;

	ret = get_ext(fname, ext, cue_base, sizeof(cue_base));
	if (strcasecmp(ext, "cue") == 0) {
		f = fopen(fname, "r");
	}
	else {
		// not a .cue, try one with the same base name
		if (ret + 3 < sizeof(cue_base)) {
			strcpy(cue_base + ret, "cue");
			f = fopen(cue_base, "r");
			if (f == NULL) {
				strcpy(cue_base + ret, "CUE");
				f = fopen(cue_base, "r");
			}
		}
	}

	if (f == NULL)
		return NULL;

	snprintf(current_file, sizeof(current_file), "%s", fname);
	current_filep = current_file + strlen(current_file);
	for (; current_filep > current_file; current_filep--)
		if (current_filep[-1] == '/' || current_filep[-1] == '\\')
			break;

	current_filep_size = sizeof(current_file) - (current_filep - current_file);

	// the basename of cuefile, no path
	snprintf(cue_base, sizeof(cue_base), "%s", current_filep);
	p = cue_base + strlen(cue_base);
	if (p - 3 >= cue_base)
		p[-3] = 0;

	data = calloc(1, sizeof(*data) + count_alloc * sizeof(cue_track));
	if (data == NULL)
		goto out;

	while (!feof(f))
	{
		tmp = fgets(buff, sizeof(buff), f);
		if (tmp == NULL)
			break;

		mystrip(buff);
		if (buff[0] == 0)
			continue;
		if      (BEGINS(buff, "TITLE ") || BEGINS(buff, "PERFORMER ") || BEGINS(buff, "SONGWRITER "))
			continue;	/* who would put those here? Ignore! */
		else if (BEGINS(buff, "FILE "))
		{
			get_token(buff + 5, current_filep, current_filep_size);
		}
		else if (BEGINS(buff, "TRACK "))
		{
			count++;
			if (count >= count_alloc) {
				count_alloc *= 2;
				tmp = realloc(data, sizeof(*data) + count_alloc * sizeof(cue_track));
				if (tmp == NULL) {
					count--;
					break;
				}
				data = tmp;
			}
			memset(&data->tracks[count], 0, sizeof(data->tracks[0]));

			if (count == 1 || strcmp(data->tracks[1].fname, current_file) != 0)
			{
				if (file_openable(current_file))
					goto file_ok;

				elprintf(EL_STATUS, "cue: bad/missing file: \"%s\"", current_file);
				if (count == 1) {
					int cue_ucase;
					char v;

					get_ext(current_file, ext, NULL, 0);
					snprintf(current_filep, current_filep_size,
						"%s%s", cue_base, ext);
					if (file_openable(current_file))
						goto file_ok;

					// try with the same case (for unix)
					v = fname[fname_len - 1];
					cue_ucase = ('A' <= v && v <= 'Z');
					change_case(ext, cue_ucase);

					snprintf(current_filep, current_filep_size,
						"%s%s", cue_base, ext);
					if (file_openable(current_file))
						goto file_ok;
				}

				count--;
				break;

file_ok:
				data->tracks[count].fname = strdup(current_file);
				if (data->tracks[count].fname == NULL)
					break;
			}
			data->tracks[count].pregap = pending_pregap;
			pending_pregap = 0;
			// track number
			ret = get_token(buff+6, buff2, sizeof(buff2));
			if (count != atoi(buff2))
				elprintf(EL_STATUS, "cue: track index mismatch: track %i is track %i in cue",
					count, atoi(buff2));
			// check type
			get_token(buff+6+ret, buff2, sizeof(buff2));
			if      (strcmp(buff2, "MODE1/2352") == 0)
				data->tracks[count].type = CT_BIN;
			else if (strcmp(buff2, "MODE1/2048") == 0)
				data->tracks[count].type = CT_ISO;
			else if (strcmp(buff2, "AUDIO") == 0)
			{
				if (data->tracks[count].fname != NULL)
				{
					// rely on extension, not type in cue..
					get_ext(data->tracks[count].fname, ext, NULL, 0);
					if      (strcasecmp(ext, "mp3") == 0)
						data->tracks[count].type = CT_MP3;
					else if (strcasecmp(ext, "wav") == 0)
						data->tracks[count].type = CT_WAV;
					else {
						elprintf(EL_STATUS, "unhandled audio format: \"%s\"",
							data->tracks[count].fname);
					}
				}
				else
				{
					// propagate previous
					data->tracks[count].type = data->tracks[count-1].type;
				}
			}
			else {
				elprintf(EL_STATUS, "unhandled track type: \"%s\"", buff2);
			}
		}
		else if (BEGINS(buff, "INDEX "))
		{
			int m, s, f;
			// type
			ret = get_token(buff+6, buff2, sizeof(buff2));
			if (atoi(buff2) == 0) continue;
			if (atoi(buff2) != 1) {
				elprintf(EL_STATUS, "cue: don't know how to handle: \"%s\"", buff);
				count--; break;
			}
			// offset in file
			get_token(buff+6+ret, buff2, sizeof(buff2));
			ret = sscanf(buff2, "%d:%d:%d", &m, &s, &f);
			if (ret != 3) {
				elprintf(EL_STATUS, "cue: failed to parse: \"%s\"", buff);
				count--; break;
			}
			data->tracks[count].sector_offset = m*60*75 + s*75 + f;
			// some strange .cues may need this
			if (data->tracks[count].fname != NULL && strcmp(data->tracks[count].fname, current_file) != 0)
			{
				free(data->tracks[count].fname);
				data->tracks[count].fname = strdup(current_file);
			}
			if (data->tracks[count].fname == NULL && strcmp(data->tracks[1].fname, current_file) != 0)
			{
				data->tracks[count].fname = strdup(current_file);
			}
		}
		else if (BEGINS(buff, "PREGAP ") || BEGINS(buff, "POSTGAP "))
		{
			int m, s, f;
			get_token(buff+7, buff2, sizeof(buff2));
			ret = sscanf(buff2, "%d:%d:%d", &m, &s, &f);
			if (ret != 3) {
				elprintf(EL_STATUS, "cue: failed to parse: \"%s\"", buff);
				continue;
			}
			// pregap overrides previous postgap?
			// by looking at some .cues produced by some programs I've decided that..
			if (BEGINS(buff, "PREGAP "))
				data->tracks[count].pregap = m*60*75 + s*75 + f;
			else
				pending_pregap = m*60*75 + s*75 + f;
		}
		else if (BEGINS(buff, "REM LENGTH ")) // custom "extension"
		{
			int m, s, f;
			get_token(buff+11, buff2, sizeof(buff2));
			ret = sscanf(buff2, "%d:%d:%d", &m, &s, &f);
			if (ret != 3) continue;
			data->tracks[count].sector_xlength = m*60*75 + s*75 + f;
		}
		else if (BEGINS(buff, "REM"))
			continue;
		else
		{
			elprintf(EL_STATUS, "cue: unhandled line: \"%s\"", buff);
		}
	}

	if (count < 1 || data->tracks[1].fname == NULL) {
		// failed..
		for (; count > 0; count--)
			if (data->tracks[count].fname != NULL)
				free(data->tracks[count].fname);
		free(data);
		data = NULL;
		goto out;
	}

	data->track_count = count;

out:
	if (f != NULL)
		fclose(f);
	return data;
}


void cue_destroy(cue_data_t *data)
{
	int c;

	if (data == NULL) return;

	for (c = data->track_count; c > 0; c--)
		if (data->tracks[c].fname != NULL)
			free(data->tracks[c].fname);
	free(data);
}


#if 0
int main(int argc, char *argv[])
{
	cue_data_t *data = cue_parse(argv[1]);
	int c;

	if (data == NULL) return 1;

	for (c = 1; c <= data->track_count; c++)
		printf("%2i: %i %9i %02i:%02i:%02i %9i %s\n", c, data->tracks[c].type, data->tracks[c].sector_offset,
			data->tracks[c].sector_offset / (75*60), data->tracks[c].sector_offset / 75 % 60,
			data->tracks[c].sector_offset % 75, data->tracks[c].pregap, data->tracks[c].fname);

	cue_destroy(data);

	return 0;
}
#endif
Commit	Line	Data
cff531af	1	/*
	2	* cuefile handling
	3	* (C) notaz, 2008
	4	*
	5	* This work is licensed under the terms of MAME license.
	6	* See COPYING file in the top-level directory.
	7	*/
b923ecbe	8	#include <stdio.h>
	9	#include <stdlib.h>
	10	#include <string.h>
	11	#include "cue.h"
	12
efcba75f	13	#include "../pico_int.h"
9037e45d	14	// #define elprintf(w,f,...) printf(f "\n",##__VA_ARGS__);
b923ecbe	15
67c81ee2	16	#ifdef _MSC_VER
	17	#define snprintf _snprintf
	18	#endif
f8af9634	19	#ifdef __EPOC32__
ca482e5d	20	#define snprintf(b,s,...) sprintf(b,##__VA_ARGS__)
ca482e5d	21	#endif
67c81ee2	22
b923ecbe	23	static char mystrip(char str)
	24	{
	25	int i, len;
	26
	27	len = strlen(str);
	28	for (i = 0; i < len; i++)
	29	if (str[i] != ' ') break;
	30	if (i > 0) memmove(str, str + i, len - i + 1);
	31
	32	len = strlen(str);
	33	for (i = len - 1; i >= 0; i--)
	34	if (str[i] != ' ' && str[i] != '\r' && str[i] != '\n') break;
	35	str[i+1] = 0;
	36
	37	return str;
	38	}
	39
	40	static int get_token(const char buff, char dest, int len)
	41	{
	42	const char *p = buff;
	43	char sep = ' ';
	44	int d = 0, skip = 0;
	45
	46	while (p && p == ' ') {
	47	skip++;
	48	p++;
	49	}
	50
	51	if (*p == '\"') {
	52	sep = '\"';
	53	p++;
	54	}
	55	while (p && p != sep && d < len-1)
	56	dest[d++] = *p++;
	57	dest[d] = 0;
	58
9037e45d	59	if (sep == '\"' && *p != sep)
b923ecbe	60	elprintf(EL_STATUS, "cue: bad token: \"%s\"", buff);
	61
	62	return d + skip;
	63	}
	64
e71fae1f	65	static int get_ext(const char *fname, char ext[4],
e71fae1f	66	char *base, size_t base_size)
b923ecbe	67	{
e71fae1f	68	int len, pos = 0;
	69
	70	len = strlen(fname);
	71	if (len >= 3)
	72	pos = len - 3;
	73
	74	strcpy(ext, fname + pos);
	75
	76	if (base != NULL) {
	77	len = pos;
	78	if (len + 1 < base_size)
	79	len = base_size - 1;
	80	memcpy(base, fname, len);
	81	base[len] = 0;
	82	}
	83	return pos;
	84	}
	85
	86	static void change_case(char *p, int to_upper)
	87	{
	88	for (; *p != 0; p++) {
	89	if (to_upper && 'a' <= p && p <= 'z')
	90	*p += 'A' - 'a';
	91	else if (!to_upper && 'A' <= p && p <= 'Z')
	92	*p += 'a' - 'A';
	93	}
b923ecbe	94	}
b923ecbe	95
e71fae1f	96	static int file_openable(const char *fname)
	97	{
	98	FILE *f = fopen(fname, "rb");
	99	if (f == NULL)
	100	return 0;
	101	fclose(f);
	102	return 1;
	103	}
b923ecbe	104
	105	#define BEGINS(buff,str) (strncmp(buff,str,sizeof(str)-1) == 0)
	106
	107	/* note: tracks[0] is not used */
9037e45d	108	cue_data_t cue_parse(const char fname)
b923ecbe	109	{
e71fae1f	110	char current_file[256], *current_filep, cue_base[256];
e71fae1f	111	char buff[256], buff2[32], ext[4], *p;
c9e1affc	112	int ret, count = 0, count_alloc = 2, pending_pregap = 0;
e71fae1f	113	size_t current_filep_size, fname_len;
	114	cue_data_t *data = NULL;
	115	FILE *f = NULL;
b923ecbe	116	void *tmp;
b923ecbe	117
e71fae1f	118	if (fname == NULL \|\| (fname_len = strlen(fname)) == 0)
	119	return NULL;
	120
	121	ret = get_ext(fname, ext, cue_base, sizeof(cue_base));
	122	if (strcasecmp(ext, "cue") == 0) {
	123	f = fopen(fname, "r");
	124	}
	125	else {
	126	// not a .cue, try one with the same base name
	127	if (ret + 3 < sizeof(cue_base)) {
	128	strcpy(cue_base + ret, "cue");
	129	f = fopen(cue_base, "r");
	130	if (f == NULL) {
	131	strcpy(cue_base + ret, "CUE");
	132	f = fopen(cue_base, "r");
	133	}
	134	}
	135	}
	136
	137	if (f == NULL)
	138	return NULL;
b923ecbe	139
c9e1affc	140	snprintf(current_file, sizeof(current_file), "%s", fname);
e71fae1f	141	current_filep = current_file + strlen(current_file);
	142	for (; current_filep > current_file; current_filep--)
	143	if (current_filep[-1] == '/' \|\| current_filep[-1] == '\\')
	144	break;
	145
	146	current_filep_size = sizeof(current_file) - (current_filep - current_file);
	147
	148	// the basename of cuefile, no path
	149	snprintf(cue_base, sizeof(cue_base), "%s", current_filep);
	150	p = cue_base + strlen(cue_base);
	151	if (p - 3 >= cue_base)
	152	p[-3] = 0;
c9e1affc	153
b923ecbe	154	data = calloc(1, sizeof(data) + count_alloc sizeof(cue_track));
e71fae1f	155	if (data == NULL)
e71fae1f	156	goto out;
b923ecbe	157
	158	while (!feof(f))
	159	{
	160	tmp = fgets(buff, sizeof(buff), f);
e71fae1f	161	if (tmp == NULL)
e71fae1f	162	break;
b923ecbe	163
b923ecbe	164	mystrip(buff);
e71fae1f	165	if (buff[0] == 0)
e71fae1f	166	continue;
0bccafeb	167	if (BEGINS(buff, "TITLE ") \|\| BEGINS(buff, "PERFORMER ") \|\| BEGINS(buff, "SONGWRITER "))
b923ecbe	168	continue; /* who would put those here? Ignore! */
	169	else if (BEGINS(buff, "FILE "))
	170	{
e71fae1f	171	get_token(buff + 5, current_filep, current_filep_size);
b923ecbe	172	}
	173	else if (BEGINS(buff, "TRACK "))
	174	{
	175	count++;
	176	if (count >= count_alloc) {
	177	count_alloc *= 2;
	178	tmp = realloc(data, sizeof(data) + count_alloc sizeof(cue_track));
e71fae1f	179	if (tmp == NULL) {
	180	count--;
	181	break;
	182	}
9037e45d	183	data = tmp;
b923ecbe	184	}
b923ecbe	185	memset(&data->tracks[count], 0, sizeof(data->tracks[0]));
e71fae1f	186
b923ecbe	187	if (count == 1 \|\| strcmp(data->tracks[1].fname, current_file) != 0)
b923ecbe	188	{
e71fae1f	189	if (file_openable(current_file))
	190	goto file_ok;
	191
	192	elprintf(EL_STATUS, "cue: bad/missing file: \"%s\"", current_file);
	193	if (count == 1) {
	194	int cue_ucase;
	195	char v;
	196
	197	get_ext(current_file, ext, NULL, 0);
	198	snprintf(current_filep, current_filep_size,
	199	"%s%s", cue_base, ext);
	200	if (file_openable(current_file))
	201	goto file_ok;
	202
	203	// try with the same case (for unix)
	204	v = fname[fname_len - 1];
	205	cue_ucase = ('A' <= v && v <= 'Z');
	206	change_case(ext, cue_ucase);
	207
	208	snprintf(current_filep, current_filep_size,
	209	"%s%s", cue_base, ext);
	210	if (file_openable(current_file))
	211	goto file_ok;
b923ecbe	212	}
e71fae1f	213
	214	count--;
	215	break;
	216
	217	file_ok:
	218	data->tracks[count].fname = strdup(current_file);
	219	if (data->tracks[count].fname == NULL)
	220	break;
b923ecbe	221	}
c9e1affc	222	data->tracks[count].pregap = pending_pregap;
c9e1affc	223	pending_pregap = 0;
b923ecbe	224	// track number
	225	ret = get_token(buff+6, buff2, sizeof(buff2));
	226	if (count != atoi(buff2))
	227	elprintf(EL_STATUS, "cue: track index mismatch: track %i is track %i in cue",
	228	count, atoi(buff2));
	229	// check type
	230	get_token(buff+6+ret, buff2, sizeof(buff2));
9037e45d	231	if (strcmp(buff2, "MODE1/2352") == 0)
b923ecbe	232	data->tracks[count].type = CT_BIN;
9037e45d	233	else if (strcmp(buff2, "MODE1/2048") == 0)
b923ecbe	234	data->tracks[count].type = CT_ISO;
9037e45d	235	else if (strcmp(buff2, "AUDIO") == 0)
b923ecbe	236	{
	237	if (data->tracks[count].fname != NULL)
	238	{
	239	// rely on extension, not type in cue..
e71fae1f	240	get_ext(data->tracks[count].fname, ext, NULL, 0);
b923ecbe	241	if (strcasecmp(ext, "mp3") == 0)
	242	data->tracks[count].type = CT_MP3;
	243	else if (strcasecmp(ext, "wav") == 0)
	244	data->tracks[count].type = CT_WAV;
	245	else {
	246	elprintf(EL_STATUS, "unhandled audio format: \"%s\"",
	247	data->tracks[count].fname);
	248	}
	249	}
9037e45d	250	else
	251	{
	252	// propagate previous
	253	data->tracks[count].type = data->tracks[count-1].type;
	254	}
b923ecbe	255	}
	256	else {
	257	elprintf(EL_STATUS, "unhandled track type: \"%s\"", buff2);
	258	}
	259	}
	260	else if (BEGINS(buff, "INDEX "))
	261	{
	262	int m, s, f;
	263	// type
	264	ret = get_token(buff+6, buff2, sizeof(buff2));
	265	if (atoi(buff2) == 0) continue;
	266	if (atoi(buff2) != 1) {
	267	elprintf(EL_STATUS, "cue: don't know how to handle: \"%s\"", buff);
	268	count--; break;
	269	}
	270	// offset in file
	271	get_token(buff+6+ret, buff2, sizeof(buff2));
9037e45d	272	ret = sscanf(buff2, "%d:%d:%d", &m, &s, &f);
b923ecbe	273	if (ret != 3) {
	274	elprintf(EL_STATUS, "cue: failed to parse: \"%s\"", buff);
	275	count--; break;
	276	}
	277	data->tracks[count].sector_offset = m6075 + s*75 + f;
9037e45d	278	// some strange .cues may need this
	279	if (data->tracks[count].fname != NULL && strcmp(data->tracks[count].fname, current_file) != 0)
	280	{
	281	free(data->tracks[count].fname);
	282	data->tracks[count].fname = strdup(current_file);
	283	}
	284	if (data->tracks[count].fname == NULL && strcmp(data->tracks[1].fname, current_file) != 0)
	285	{
	286	data->tracks[count].fname = strdup(current_file);
	287	}
b923ecbe	288	}
c9e1affc	289	else if (BEGINS(buff, "PREGAP ") \|\| BEGINS(buff, "POSTGAP "))
b923ecbe	290	{
	291	int m, s, f;
	292	get_token(buff+7, buff2, sizeof(buff2));
9037e45d	293	ret = sscanf(buff2, "%d:%d:%d", &m, &s, &f);
b923ecbe	294	if (ret != 3) {
	295	elprintf(EL_STATUS, "cue: failed to parse: \"%s\"", buff);
	296	continue;
	297	}
c9e1affc	298	// pregap overrides previous postgap?
	299	// by looking at some .cues produced by some programs I've decided that..
	300	if (BEGINS(buff, "PREGAP "))
	301	data->tracks[count].pregap = m6075 + s*75 + f;
	302	else
	303	pending_pregap = m6075 + s*75 + f;
b923ecbe	304	}
0bccafeb	305	else if (BEGINS(buff, "REM LENGTH ")) // custom "extension"
	306	{
	307	int m, s, f;
	308	get_token(buff+11, buff2, sizeof(buff2));
	309	ret = sscanf(buff2, "%d:%d:%d", &m, &s, &f);
	310	if (ret != 3) continue;
	311	data->tracks[count].sector_xlength = m6075 + s*75 + f;
	312	}
	313	else if (BEGINS(buff, "REM"))
	314	continue;
b923ecbe	315	else
b923ecbe	316	{
9037e45d	317	elprintf(EL_STATUS, "cue: unhandled line: \"%s\"", buff);
b923ecbe	318	}
	319	}
	320
	321	if (count < 1 \|\| data->tracks[1].fname == NULL) {
	322	// failed..
	323	for (; count > 0; count--)
	324	if (data->tracks[count].fname != NULL)
	325	free(data->tracks[count].fname);
	326	free(data);
e71fae1f	327	data = NULL;
e71fae1f	328	goto out;
b923ecbe	329	}
	330
	331	data->track_count = count;
e71fae1f	332
	333	out:
	334	if (f != NULL)
	335	fclose(f);
b923ecbe	336	return data;
	337	}
	338
	339
9037e45d	340	void cue_destroy(cue_data_t *data)
b923ecbe	341	{
	342	int c;
	343
	344	if (data == NULL) return;
	345
	346	for (c = data->track_count; c > 0; c--)
	347	if (data->tracks[c].fname != NULL)
	348	free(data->tracks[c].fname);
	349	free(data);
	350	}
	351
	352
9037e45d	353	#if 0
b923ecbe	354	int main(int argc, char *argv[])
b923ecbe	355	{
9037e45d	356	cue_data_t *data = cue_parse(argv[1]);
b923ecbe	357	int c;
	358
	359	if (data == NULL) return 1;
	360
	361	for (c = 1; c <= data->track_count; c++)
9037e45d	362	printf("%2i: %i %9i %02i:%02i:%02i %9i %s\n", c, data->tracks[c].type, data->tracks[c].sector_offset,
	363	data->tracks[c].sector_offset / (75*60), data->tracks[c].sector_offset / 75 % 60,
	364	data->tracks[c].sector_offset % 75, data->tracks[c].pregap, data->tracks[c].fname);
b923ecbe	365
	366	cue_destroy(data);
	367
	368	return 0;
	369	}
9037e45d	370	#endif
b923ecbe	371