[pcsx_rearmed.git] / deps / libretro-common / streams / chd_stream.c

/* Copyright  (C) 2010-2020 The RetroArch team
 *
 * ---------------------------------------------------------------------------------------
 * The following license statement only applies to this file (chd_stream.c).
 * ---------------------------------------------------------------------------------------
 *
 * Permission is hereby granted, free of charge,
 * to any person obtaining a copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation the rights to
 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
 * and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
 * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <boolean.h>

#include <streams/chd_stream.h>
#include <retro_endianness.h>
#include <libchdr/chd.h>
#include <string/stdstring.h>

#define SECTOR_SIZE 2352
#define SUBCODE_SIZE 96
#define TRACK_PAD 4

struct chdstream
{
   chd_file *chd;
   /* Loaded hunk */
   uint8_t *hunkmem;
   /* Byte offset where track data starts (after pregap) */
   size_t track_start;
   /* Byte offset where track data ends */
   size_t track_end;
   /* Byte offset of read cursor */
   size_t offset;
   /* Loaded hunk number */
   int32_t hunknum;
   /* Size of frame taken from each hunk */
   uint32_t frame_size;
   /* Offset of data within frame */
   uint32_t frame_offset;
   /* Number of frames per hunk */
   uint32_t frames_per_hunk;
   /* First frame of track in chd */
   uint32_t track_frame;
   /* Should we swap bytes? */
   bool swab;
};

typedef struct metadata
{
   uint32_t frame_offset;
   uint32_t frames;
   uint32_t pad;
   uint32_t extra;
   uint32_t pregap;
   uint32_t postgap;
   uint32_t track;
   char type[64];
   char subtype[32];
   char pgtype[32];
   char pgsub[32];
} metadata_t;

static uint32_t padding_frames(uint32_t frames)
{
   return ((frames + TRACK_PAD - 1) & ~(TRACK_PAD - 1)) - frames;
}

static bool
chdstream_get_meta(chd_file *chd, int idx, metadata_t *md)
{
   char meta[256];
   uint32_t meta_size = 0;
   chd_error err;

   meta[0] = '\0';

   memset(md, 0, sizeof(*md));

   err = chd_get_metadata(chd, CDROM_TRACK_METADATA2_TAG, idx, meta,
         sizeof(meta), &meta_size, NULL, NULL);

   if (err == CHDERR_NONE)
   {
      sscanf(meta, CDROM_TRACK_METADATA2_FORMAT,
            &md->track, md->type,
            md->subtype, &md->frames, &md->pregap,
            md->pgtype, md->pgsub,
            &md->postgap);
      md->extra = padding_frames(md->frames);
      return true;
   }

   err = chd_get_metadata(chd, CDROM_TRACK_METADATA_TAG, idx, meta,
         sizeof(meta), &meta_size, NULL, NULL);

   if (err == CHDERR_NONE)
   {
      sscanf(meta, CDROM_TRACK_METADATA_FORMAT, &md->track, md->type,
             md->subtype, &md->frames);
      md->extra = padding_frames(md->frames);
      return true;
   }

   err = chd_get_metadata(chd, GDROM_TRACK_METADATA_TAG, idx, meta,
         sizeof(meta), &meta_size, NULL, NULL);

   if (err == CHDERR_NONE)
   {
      sscanf(meta, GDROM_TRACK_METADATA_FORMAT, &md->track, md->type,
             md->subtype, &md->frames, &md->pad, &md->pregap, md->pgtype,
             md->pgsub, &md->postgap);
      md->extra = padding_frames(md->frames);
      return true;
   }

   return false;
}

static bool
chdstream_find_track_number(chd_file *fd, int32_t track, metadata_t *meta)
{
   uint32_t i;
   uint32_t frame_offset = 0;

   for (i = 0; true; ++i)
   {
      if (!chdstream_get_meta(fd, i, meta))
         return false;

      if (track == (int)meta->track)
      {
         meta->frame_offset = frame_offset;
         return true;
      }

      frame_offset += meta->frames + meta->extra;
   }
}

static bool
chdstream_find_special_track(chd_file *fd, int32_t track, metadata_t *meta)
{
   int32_t i;
   metadata_t iter;
   int32_t largest_track = 0;
   uint32_t largest_size = 0;

   for (i = 1; true; ++i)
   {
      if (!chdstream_find_track_number(fd, i, &iter))
      {
         if (track == CHDSTREAM_TRACK_LAST && i > 1)
            return chdstream_find_track_number(fd, i - 1, meta);

         if (track == CHDSTREAM_TRACK_PRIMARY && largest_track != 0)
            return chdstream_find_track_number(fd, largest_track, meta);

         return false;
      }

      switch (track)
      {
         case CHDSTREAM_TRACK_FIRST_DATA:
            if (strcmp(iter.type, "AUDIO"))
            {
               *meta = iter;
               return true;
            }
            break;
         case CHDSTREAM_TRACK_PRIMARY:
            if (strcmp(iter.type, "AUDIO") && iter.frames > largest_size)
            {
               largest_size  = iter.frames;
               largest_track = iter.track;
            }
            break;
         default:
            break;
      }
   }
}

static bool
chdstream_find_track(chd_file *fd, int32_t track, metadata_t *meta)
{
   if (track < 0)
      return chdstream_find_special_track(fd, track, meta);
   return chdstream_find_track_number(fd, track, meta);
}

chdstream_t *chdstream_open(const char *path, int32_t track)
{
   metadata_t meta;
   uint32_t pregap         = 0;
   uint8_t *hunkmem        = NULL;
   const chd_header *hd    = NULL;
   chdstream_t *stream     = NULL;
   chd_file *chd           = NULL;
   chd_error err           = chd_open(path, CHD_OPEN_READ, NULL, &chd);

   if (err != CHDERR_NONE)
      return NULL;

   if (!chdstream_find_track(chd, track, &meta))
      goto error;

   stream                  = (chdstream_t*)malloc(sizeof(*stream));
   if (!stream)
      goto error;

   stream->chd             = NULL;
   stream->swab            = false;
   stream->frame_size      = 0;
   stream->frame_offset    = 0;
   stream->frames_per_hunk = 0;
   stream->track_frame     = 0;
   stream->track_start     = 0;
   stream->track_end       = 0;
   stream->offset          = 0;
   stream->hunkmem         = NULL;
   stream->hunknum         = -1;

   hd                      = chd_get_header(chd);
   hunkmem                 = (uint8_t*)malloc(hd->hunkbytes);
   if (!hunkmem)
      goto error;

   stream->hunkmem         = hunkmem;

   if (string_is_equal(meta.type, "MODE1_RAW"))
      stream->frame_size   = SECTOR_SIZE;
   else if (string_is_equal(meta.type, "MODE2_RAW"))
      stream->frame_size   = SECTOR_SIZE;
   else if (string_is_equal(meta.type, "AUDIO"))
   {
      stream->frame_size   = SECTOR_SIZE;
      stream->swab         = true;
   }
   else
      stream->frame_size   = hd->unitbytes;

   /* Only include pregap data if it was in the track file */
   if (meta.pgtype[0] != 'V')
      pregap               = meta.pregap;

   stream->chd             = chd;
   stream->frames_per_hunk = hd->hunkbytes / hd->unitbytes;
   stream->track_frame     = meta.frame_offset;
   stream->track_start     = (size_t)pregap * stream->frame_size;
   stream->track_end       = stream->track_start + 
                             (size_t)meta.frames * stream->frame_size;

   return stream;

error:

   chdstream_close(stream);

   if (chd)
      chd_close(chd);

   return NULL;
}

void chdstream_close(chdstream_t *stream)
{
   if (!stream)
      return;

   if (stream->hunkmem)
      free(stream->hunkmem);
   if (stream->chd)
      chd_close(stream->chd);
   free(stream);
}

static bool
chdstream_load_hunk(chdstream_t *stream, uint32_t hunknum)
{
   uint16_t *array;

   if ((int)hunknum == stream->hunknum)
      return true;

   if (chd_read(stream->chd, hunknum, stream->hunkmem) != CHDERR_NONE)
      return false;

   if (stream->swab)
   {
      uint32_t i;
      uint32_t count = chd_get_header(stream->chd)->hunkbytes / 2;
      array          = (uint16_t*)stream->hunkmem;
      for (i = 0; i < count; ++i)
         array[i] = SWAP16(array[i]);
   }

   stream->hunknum = hunknum;
   return true;
}

ssize_t chdstream_read(chdstream_t *stream, void *data, size_t bytes)
{
   size_t end;
   size_t data_offset   = 0;
   const chd_header *hd = chd_get_header(stream->chd);
   uint8_t         *out = (uint8_t*)data;

   if (stream->track_end - stream->offset < bytes)
      bytes             = stream->track_end - stream->offset;

   end                  = stream->offset + bytes;

   while (stream->offset < end)
   {
      uint32_t frame_offset = stream->offset % stream->frame_size;
      uint32_t amount       = stream->frame_size - frame_offset;

      if (amount > end - stream->offset)
         amount = (uint32_t)(end - stream->offset);

      /* In pregap */
      if (stream->offset < stream->track_start)
         memset(out + data_offset, 0, amount);
      else
      {
         uint32_t chd_frame   = (uint32_t)(stream->track_frame +
            (stream->offset - stream->track_start) / stream->frame_size);
         uint32_t hunk        = chd_frame / stream->frames_per_hunk;
         uint32_t hunk_offset = (chd_frame % stream->frames_per_hunk) 
            * hd->unitbytes;

         if (!chdstream_load_hunk(stream, hunk))
            return -1;

         memcpy(out + data_offset,
                stream->hunkmem + frame_offset
                + hunk_offset + stream->frame_offset, amount);
      }

      data_offset    += amount;
      stream->offset += amount;
   }

   return bytes;
}

int chdstream_getc(chdstream_t *stream)
{
   char c = 0;

   if (chdstream_read(stream, &c, sizeof(c) != sizeof(c)))
      return EOF;

   return c;
}

char *chdstream_gets(chdstream_t *stream, char *buffer, size_t len)
{
   int c;

   size_t offset = 0;

   while (offset < len && (c = chdstream_getc(stream)) != EOF)
      buffer[offset++] = c;

   if (offset < len)
      buffer[offset]   = '\0';

   return buffer;
}

uint64_t chdstream_tell(chdstream_t *stream)
{
   return stream->offset;
}

void chdstream_rewind(chdstream_t *stream)
{
   stream->offset = 0;
}

int64_t chdstream_seek(chdstream_t *stream, int64_t offset, int whence)
{
   int64_t new_offset;

   switch (whence)
   {
      case SEEK_SET:
         new_offset = offset;
         break;
      case SEEK_CUR:
         new_offset = stream->offset + offset;
         break;
      case SEEK_END:
         new_offset = stream->track_end + offset;
         break;
      default:
         return -1;
   }

   if (new_offset < 0)
      return -1;

   if ((size_t)new_offset > stream->track_end)
      new_offset = stream->track_end;

   stream->offset = new_offset;
   return 0;
}

ssize_t chdstream_get_size(chdstream_t *stream)
{
   return stream->track_end - stream->track_start;
}

uint32_t chdstream_get_track_start(chdstream_t *stream)
{
   uint32_t i;
   metadata_t meta;
   uint32_t frame_offset = 0;

   for (i = 0; chdstream_get_meta(stream->chd, i, &meta); ++i)
   {
      if (stream->track_frame == frame_offset)
         return meta.pregap * stream->frame_size;

      frame_offset += meta.frames + meta.extra;
   }

   return 0;
}

uint32_t chdstream_get_frame_size(chdstream_t *stream)
{
   return stream->frame_size;
}

uint32_t chdstream_get_first_track_sector(chdstream_t* stream)
{
   uint32_t i;
   metadata_t meta;
   uint32_t frame_offset = 0;
   uint32_t sector_offset = 0;

   for (i = 0; chdstream_get_meta(stream->chd, i, &meta); ++i)
   {
      if (stream->track_frame == frame_offset)
         return sector_offset;

      sector_offset += meta.frames;
      frame_offset += meta.frames + meta.extra;
   }

   return 0;
}
Commit	Line	Data
3719602c PC	1	/* Copyright (C) 2010-2020 The RetroArch team
	2	*
	3	* ---------------------------------------------------------------------------------------
	4	* The following license statement only applies to this file (chd_stream.c).
	5	* ---------------------------------------------------------------------------------------
	6	*
	7	* Permission is hereby granted, free of charge,
	8	* to any person obtaining a copy of this software and associated documentation files (the "Software"),
	9	* to deal in the Software without restriction, including without limitation the rights to
	10	* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
	11	* and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
	12	*
	13	* The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
	14	*
	15	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
	16	* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	17	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
	18	* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
	19	* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	20	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
	21	*/
	22
	23	#include <stdio.h>
	24	#include <stdlib.h>
	25	#include <string.h>
	26
	27	#include <boolean.h>
	28
	29	#include <streams/chd_stream.h>
	30	#include <retro_endianness.h>
	31	#include <libchdr/chd.h>
	32	#include <string/stdstring.h>
	33
	34	#define SECTOR_SIZE 2352
	35	#define SUBCODE_SIZE 96
	36	#define TRACK_PAD 4
	37
	38	struct chdstream
	39	{
	40	chd_file *chd;
	41	/* Loaded hunk */
	42	uint8_t *hunkmem;
	43	/* Byte offset where track data starts (after pregap) */
	44	size_t track_start;
	45	/* Byte offset where track data ends */
	46	size_t track_end;
	47	/* Byte offset of read cursor */
	48	size_t offset;
	49	/* Loaded hunk number */
	50	int32_t hunknum;
	51	/* Size of frame taken from each hunk */
	52	uint32_t frame_size;
	53	/* Offset of data within frame */
	54	uint32_t frame_offset;
	55	/* Number of frames per hunk */
	56	uint32_t frames_per_hunk;
	57	/* First frame of track in chd */
	58	uint32_t track_frame;
	59	/* Should we swap bytes? */
	60	bool swab;
	61	};
	62
	63	typedef struct metadata
	64	{
65	uint32_t frame_offset;
66	uint32_t frames;
67	uint32_t pad;
68	uint32_t extra;
69	uint32_t pregap;
70	uint32_t postgap;
71	uint32_t track;
72	char type[64];
73	char subtype[32];
74	char pgtype[32];
75	char pgsub[32];
76	} metadata_t;
77
78	static uint32_t padding_frames(uint32_t frames)
79	{
80	return ((frames + TRACK_PAD - 1) & ~(TRACK_PAD - 1)) - frames;
81	}
82
83	static bool
84	chdstream_get_meta(chd_file chd, int idx, metadata_t md)
85	{
86	char meta[256];
87	uint32_t meta_size = 0;
88	chd_error err;
89
90	meta[0] = '\0';
91
92	memset(md, 0, sizeof(*md));
93
94	err = chd_get_metadata(chd, CDROM_TRACK_METADATA2_TAG, idx, meta,
95	sizeof(meta), &meta_size, NULL, NULL);
96
97	if (err == CHDERR_NONE)
98	{
99	sscanf(meta, CDROM_TRACK_METADATA2_FORMAT,
100	&md->track, md->type,
101	md->subtype, &md->frames, &md->pregap,
102	md->pgtype, md->pgsub,
103	&md->postgap);
104	md->extra = padding_frames(md->frames);
105	return true;
106	}
107
108	err = chd_get_metadata(chd, CDROM_TRACK_METADATA_TAG, idx, meta,
109	sizeof(meta), &meta_size, NULL, NULL);
110
111	if (err == CHDERR_NONE)
112	{
113	sscanf(meta, CDROM_TRACK_METADATA_FORMAT, &md->track, md->type,
114	md->subtype, &md->frames);
115	md->extra = padding_frames(md->frames);
116	return true;
117	}
118
119	err = chd_get_metadata(chd, GDROM_TRACK_METADATA_TAG, idx, meta,
120	sizeof(meta), &meta_size, NULL, NULL);
121
122	if (err == CHDERR_NONE)
123	{
124	sscanf(meta, GDROM_TRACK_METADATA_FORMAT, &md->track, md->type,
125	md->subtype, &md->frames, &md->pad, &md->pregap, md->pgtype,
126	md->pgsub, &md->postgap);
127	md->extra = padding_frames(md->frames);
128	return true;
129	}
130
131	return false;
132	}
133
134	static bool
135	chdstream_find_track_number(chd_file fd, int32_t track, metadata_t meta)
136	{
137	uint32_t i;
138	uint32_t frame_offset = 0;
139
140	for (i = 0; true; ++i)
141	{
142	if (!chdstream_get_meta(fd, i, meta))
143	return false;
144
145	if (track == (int)meta->track)
146	{
147	meta->frame_offset = frame_offset;
148	return true;
149	}
150
151	frame_offset += meta->frames + meta->extra;
152	}
153	}
154
155	static bool
156	chdstream_find_special_track(chd_file fd, int32_t track, metadata_t meta)
157	{
158	int32_t i;
159	metadata_t iter;
160	int32_t largest_track = 0;
161	uint32_t largest_size = 0;
162
163	for (i = 1; true; ++i)
164	{
165	if (!chdstream_find_track_number(fd, i, &iter))
166	{
167	if (track == CHDSTREAM_TRACK_LAST && i > 1)
168	return chdstream_find_track_number(fd, i - 1, meta);
169
170	if (track == CHDSTREAM_TRACK_PRIMARY && largest_track != 0)
171	return chdstream_find_track_number(fd, largest_track, meta);
172
173	return false;
174	}
175
176	switch (track)
177	{
178	case CHDSTREAM_TRACK_FIRST_DATA:
179	if (strcmp(iter.type, "AUDIO"))
180	{
181	*meta = iter;
182	return true;
183	}
184	break;
185	case CHDSTREAM_TRACK_PRIMARY:
186	if (strcmp(iter.type, "AUDIO") && iter.frames > largest_size)
187	{
188	largest_size = iter.frames;
189	largest_track = iter.track;
190	}
191	break;
192	default:
193	break;
194	}
195	}
196	}
197
198	static bool
199	chdstream_find_track(chd_file fd, int32_t track, metadata_t meta)
200	{
201	if (track < 0)
202	return chdstream_find_special_track(fd, track, meta);
203	return chdstream_find_track_number(fd, track, meta);
204	}
205
206	chdstream_t chdstream_open(const char path, int32_t track)
207	{
208	metadata_t meta;
209	uint32_t pregap = 0;
210	uint8_t *hunkmem = NULL;
211	const chd_header *hd = NULL;
212	chdstream_t *stream = NULL;
213	chd_file *chd = NULL;
214	chd_error err = chd_open(path, CHD_OPEN_READ, NULL, &chd);
215
216	if (err != CHDERR_NONE)
217	return NULL;
218
219	if (!chdstream_find_track(chd, track, &meta))
220	goto error;
221
222	stream = (chdstream_t)malloc(sizeof(stream));
223	if (!stream)
224	goto error;
225
226	stream->chd = NULL;
227	stream->swab = false;
228	stream->frame_size = 0;
229	stream->frame_offset = 0;
230	stream->frames_per_hunk = 0;
231	stream->track_frame = 0;
232	stream->track_start = 0;
233	stream->track_end = 0;
234	stream->offset = 0;
235	stream->hunkmem = NULL;
236	stream->hunknum = -1;
237
238	hd = chd_get_header(chd);
239	hunkmem = (uint8_t*)malloc(hd->hunkbytes);
240	if (!hunkmem)
241	goto error;
242
243	stream->hunkmem = hunkmem;
244
245	if (string_is_equal(meta.type, "MODE1_RAW"))
246	stream->frame_size = SECTOR_SIZE;
247	else if (string_is_equal(meta.type, "MODE2_RAW"))
248	stream->frame_size = SECTOR_SIZE;
249	else if (string_is_equal(meta.type, "AUDIO"))
250	{
251	stream->frame_size = SECTOR_SIZE;
252	stream->swab = true;
253	}
254	else
255	stream->frame_size = hd->unitbytes;
256
257	/* Only include pregap data if it was in the track file */
258	if (meta.pgtype[0] != 'V')
259	pregap = meta.pregap;
260
261	stream->chd = chd;
262	stream->frames_per_hunk = hd->hunkbytes / hd->unitbytes;
263	stream->track_frame = meta.frame_offset;
264	stream->track_start = (size_t)pregap * stream->frame_size;
265	stream->track_end = stream->track_start +
266	(size_t)meta.frames * stream->frame_size;
267
268	return stream;
269
270	error:
271
272	chdstream_close(stream);
273
274	if (chd)
275	chd_close(chd);
276
277	return NULL;
278	}
279
280	void chdstream_close(chdstream_t *stream)
281	{
282	if (!stream)
283	return;
284
285	if (stream->hunkmem)
286	free(stream->hunkmem);
287	if (stream->chd)
288	chd_close(stream->chd);
289	free(stream);
290	}
291
292	static bool
293	chdstream_load_hunk(chdstream_t *stream, uint32_t hunknum)
294	{
295	uint16_t *array;
296
297	if ((int)hunknum == stream->hunknum)
298	return true;
299
300	if (chd_read(stream->chd, hunknum, stream->hunkmem) != CHDERR_NONE)
301	return false;
302
303	if (stream->swab)
304	{
305	uint32_t i;
306	uint32_t count = chd_get_header(stream->chd)->hunkbytes / 2;
307	array = (uint16_t*)stream->hunkmem;
308	for (i = 0; i < count; ++i)
309	array[i] = SWAP16(array[i]);
310	}
311
312	stream->hunknum = hunknum;
313	return true;
314	}
315
316	ssize_t chdstream_read(chdstream_t stream, void data, size_t bytes)
317	{
318	size_t end;
319	size_t data_offset = 0;
320	const chd_header *hd = chd_get_header(stream->chd);
321	uint8_t out = (uint8_t)data;
322
323	if (stream->track_end - stream->offset < bytes)
324	bytes = stream->track_end - stream->offset;
325
326	end = stream->offset + bytes;
327
328	while (stream->offset < end)
329	{
330	uint32_t frame_offset = stream->offset % stream->frame_size;
331	uint32_t amount = stream->frame_size - frame_offset;
332
333	if (amount > end - stream->offset)
334	amount = (uint32_t)(end - stream->offset);
335
336	/* In pregap */
337	if (stream->offset < stream->track_start)
338	memset(out + data_offset, 0, amount);
339	else
340	{
341	uint32_t chd_frame = (uint32_t)(stream->track_frame +
342	(stream->offset - stream->track_start) / stream->frame_size);
343	uint32_t hunk = chd_frame / stream->frames_per_hunk;
344	uint32_t hunk_offset = (chd_frame % stream->frames_per_hunk)
345	* hd->unitbytes;
346
347	if (!chdstream_load_hunk(stream, hunk))
348	return -1;
349
350	memcpy(out + data_offset,
351	stream->hunkmem + frame_offset
352	+ hunk_offset + stream->frame_offset, amount);
353	}
354
355	data_offset += amount;
356	stream->offset += amount;
357	}
358
359	return bytes;
360	}
361
362	int chdstream_getc(chdstream_t *stream)
363	{
364	char c = 0;
365
366	if (chdstream_read(stream, &c, sizeof(c) != sizeof(c)))
367	return EOF;
368
369	return c;
370	}
371
372	char chdstream_gets(chdstream_t stream, char *buffer, size_t len)
373	{
374	int c;
375
376	size_t offset = 0;
377
378	while (offset < len && (c = chdstream_getc(stream)) != EOF)
379	buffer[offset++] = c;
380
381	if (offset < len)
382	buffer[offset] = '\0';
383
384	return buffer;
385	}
386
387	uint64_t chdstream_tell(chdstream_t *stream)
388	{
389	return stream->offset;
390	}
391
392	void chdstream_rewind(chdstream_t *stream)
393	{
394	stream->offset = 0;
395	}
396
397	int64_t chdstream_seek(chdstream_t *stream, int64_t offset, int whence)
398	{
399	int64_t new_offset;
400
401	switch (whence)
402	{
403	case SEEK_SET:
404	new_offset = offset;
405	break;
406	case SEEK_CUR:
407	new_offset = stream->offset + offset;
408	break;
409	case SEEK_END:
410	new_offset = stream->track_end + offset;
411	break;
412	default:
413	return -1;
414	}
415
416	if (new_offset < 0)
417	return -1;
418
419	if ((size_t)new_offset > stream->track_end)
420	new_offset = stream->track_end;
421
422	stream->offset = new_offset;
423	return 0;
424	}
425
426	ssize_t chdstream_get_size(chdstream_t *stream)
427	{
428	return stream->track_end - stream->track_start;
429	}
430
431	uint32_t chdstream_get_track_start(chdstream_t *stream)
432	{
433	uint32_t i;
434	metadata_t meta;
435	uint32_t frame_offset = 0;
436
437	for (i = 0; chdstream_get_meta(stream->chd, i, &meta); ++i)
438	{
439	if (stream->track_frame == frame_offset)
440	return meta.pregap * stream->frame_size;
441
442	frame_offset += meta.frames + meta.extra;
443	}
444
445	return 0;
446	}
447
448	uint32_t chdstream_get_frame_size(chdstream_t *stream)
449	{
450	return stream->frame_size;
451	}
452
453	uint32_t chdstream_get_first_track_sector(chdstream_t* stream)
454	{
455	uint32_t i;
456	metadata_t meta;
457	uint32_t frame_offset = 0;
458	uint32_t sector_offset = 0;
459
460	for (i = 0; chdstream_get_meta(stream->chd, i, &meta); ++i)
461	{
462	if (stream->track_frame == frame_offset)
463	return sector_offset;
464
465	sector_offset += meta.frames;
466	frame_offset += meta.frames + meta.extra;
467	}
468
469	return 0;
470	}