| 1 |
/* TODO: Check all read calls (in loops, especially!) for return value 0 (EOF)! */ |
| 2 |
/* Check if get_fileinfo should read ID3 info or not, seems a bit out of place here. */ |
| 3 |
/* #define EXTRA_DEBUG */ |
| 4 |
/* |
| 5 |
readers.c: reading input data |
| 6 |
|
| 7 |
copyright ?-2023 by the mpg123 project - free software under the terms of the LGPL 2.1 |
| 8 |
see COPYING and AUTHORS files in distribution or http://mpg123.org |
| 9 |
initially written by Michael Hipp |
| 10 |
*/ |
| 11 |
|
| 12 |
#include "mpg123lib_intern.h" |
| 13 |
|
| 14 |
#include "../common/debug.h" |
| 15 |
|
| 16 |
static int stream_init(mpg123_handle *fr); |
| 17 |
static int64_t get_fileinfo(mpg123_handle *); |
| 18 |
|
| 19 |
static ptrdiff_t plain_fullread(mpg123_handle *fr,unsigned char *buf, ptrdiff_t count); |
| 20 |
|
| 21 |
#ifndef NO_FEEDER |
| 22 |
/* Bufferchain methods. */ |
| 23 |
static void bc_init(struct bufferchain *bc); |
| 24 |
static void bc_reset(struct bufferchain *bc); |
| 25 |
static int bc_append(struct bufferchain *bc, ptrdiff_t size); |
| 26 |
#if 0 |
| 27 |
static void bc_drop(struct bufferchain *bc); |
| 28 |
#endif |
| 29 |
static int bc_add(struct bufferchain *bc, const unsigned char *data, ptrdiff_t size); |
| 30 |
static ptrdiff_t bc_give(struct bufferchain *bc, unsigned char *out, ptrdiff_t size); |
| 31 |
static ptrdiff_t bc_skip(struct bufferchain *bc, ptrdiff_t count); |
| 32 |
static ptrdiff_t bc_seekback(struct bufferchain *bc, ptrdiff_t count); |
| 33 |
static void bc_forget(struct bufferchain *bc); |
| 34 |
#endif |
| 35 |
|
| 36 |
// This is only for streams, so READER_HANDLEIO must be set. |
| 37 |
static ptrdiff_t fdread(mpg123_handle *fr, void *buf, size_t count) |
| 38 |
{ |
| 39 |
if((fr->rdat.flags & READER_HANDLEIO) && fr->rdat.r_read64) |
| 40 |
{ |
| 41 |
size_t got = 0; |
| 42 |
int ret = fr->rdat.r_read64(fr->rdat.iohandle, buf, count, &got); |
| 43 |
if(ret<0) |
| 44 |
{ |
| 45 |
if(NOQUIET) merror("error reading %zu bytes", count); |
| 46 |
return -1; |
| 47 |
} |
| 48 |
if(VERBOSE3) mdebug("read %zu bytes of %zu", got, count); |
| 49 |
// Stupid handling, but at least some handling of never-occuring case. |
| 50 |
return (ptrdiff_t)(got > PTRDIFF_MAX ? PTRDIFF_MAX : got); |
| 51 |
} |
| 52 |
if(NOQUIET) error("no reader setup"); |
| 53 |
return -1; |
| 54 |
} |
| 55 |
|
| 56 |
static int64_t fdseek(mpg123_handle *fr, int64_t offset, int whence) |
| 57 |
{ |
| 58 |
if((fr->rdat.flags & READER_HANDLEIO) && fr->rdat.r_lseek64) |
| 59 |
return (fr->rdat.flags & READER_NOSEEK) |
| 60 |
? -1 |
| 61 |
: fr->rdat.r_lseek64(fr->rdat.iohandle, offset, whence); |
| 62 |
if(NOQUIET) error("no reader setup"); |
| 63 |
return -1; |
| 64 |
} |
| 65 |
|
| 66 |
#ifndef NO_ICY |
| 67 |
/* stream based operation with icy meta data*/ |
| 68 |
static ptrdiff_t icy_fullread(mpg123_handle *fr, unsigned char *buf, ptrdiff_t count) |
| 69 |
{ |
| 70 |
ptrdiff_t ret,cnt; |
| 71 |
cnt = 0; |
| 72 |
if(fr->rdat.flags & READER_SEEKABLE) |
| 73 |
{ |
| 74 |
if(NOQUIET) error("mpg123 programmer error: I don't do ICY on seekable streams."); |
| 75 |
return -1; |
| 76 |
} |
| 77 |
/* |
| 78 |
There used to be a check for expected file end here (length value or ID3 flag). |
| 79 |
This is not needed: |
| 80 |
1. EOF is indicated by fdread returning zero bytes anyway. |
| 81 |
2. We get false positives of EOF for either files that grew or |
| 82 |
3. ... files that have ID3v1 tags in between (stream with intro). |
| 83 |
*/ |
| 84 |
|
| 85 |
while(cnt < count) |
| 86 |
{ |
| 87 |
/* all icy code is inside this if block, everything else is the plain fullread we know */ |
| 88 |
/* debug1("read: %li left", (long) count-cnt); */ |
| 89 |
if(fr->icy.next < count-cnt) |
| 90 |
{ |
| 91 |
unsigned char temp_buff; |
| 92 |
size_t meta_size; |
| 93 |
ptrdiff_t cut_pos; |
| 94 |
|
| 95 |
/* we are near icy-metaint boundary, read up to the boundary */ |
| 96 |
if(fr->icy.next > 0) |
| 97 |
{ |
| 98 |
cut_pos = fr->icy.next; |
| 99 |
ret = fdread(fr,buf+cnt,cut_pos); |
| 100 |
if(ret < 1) |
| 101 |
{ |
| 102 |
if(ret == 0) break; /* Just EOF. */ |
| 103 |
if(NOQUIET) error("icy boundary read"); |
| 104 |
|
| 105 |
return READER_ERROR; |
| 106 |
} |
| 107 |
|
| 108 |
if(!(fr->rdat.flags & READER_BUFFERED)) |
| 109 |
SATURATE_ADD(fr->rdat.filepos, ret, INT64_MAX); |
| 110 |
cnt += ret; |
| 111 |
fr->icy.next -= ret; |
| 112 |
if(fr->icy.next > 0) |
| 113 |
{ |
| 114 |
debug1("another try... still %li left", (long)fr->icy.next); |
| 115 |
continue; |
| 116 |
} |
| 117 |
} |
| 118 |
/* now off to read icy data */ |
| 119 |
|
| 120 |
/* one byte icy-meta size (must be multiplied by 16 to get icy-meta length) */ |
| 121 |
|
| 122 |
ret = fdread(fr,&temp_buff,1); /* Getting one single byte hast to suceed. */ |
| 123 |
if(ret < 0){ if(NOQUIET) error("reading icy size"); return READER_ERROR; } |
| 124 |
if(ret == 0) break; |
| 125 |
|
| 126 |
debug2("got meta-size byte: %u, at filepos %li", temp_buff, (long)fr->rdat.filepos ); |
| 127 |
if(!(fr->rdat.flags & READER_BUFFERED)) |
| 128 |
SATURATE_ADD(fr->rdat.filepos, ret, INT64_MAX); /* 1... */ |
| 129 |
|
| 130 |
if((meta_size = ((size_t) temp_buff) * 16)) |
| 131 |
{ |
| 132 |
/* we have got some metadata */ |
| 133 |
char *meta_buff; |
| 134 |
/* TODO: Get rid of this malloc ... perhaps hooking into the reader buffer pool? */ |
| 135 |
meta_buff = malloc(meta_size+1); |
| 136 |
if(meta_buff != NULL) |
| 137 |
{ |
| 138 |
ptrdiff_t left = meta_size; |
| 139 |
while(left > 0) |
| 140 |
{ |
| 141 |
ret = fdread(fr,meta_buff+meta_size-left,left); |
| 142 |
/* 0 is error here, too... there _must_ be the ICY data, the server promised! */ |
| 143 |
if(ret < 1){ if(NOQUIET) error("reading icy-meta"); return READER_ERROR; } |
| 144 |
left -= ret; |
| 145 |
} |
| 146 |
meta_buff[meta_size] = 0; /* string paranoia */ |
| 147 |
if(!(fr->rdat.flags & READER_BUFFERED)) |
| 148 |
SATURATE_ADD(fr->rdat.filepos, ret, INT64_MAX); |
| 149 |
|
| 150 |
if(fr->icy.data) free(fr->icy.data); |
| 151 |
fr->icy.data = meta_buff; |
| 152 |
fr->metaflags |= MPG123_NEW_ICY; |
| 153 |
debug2("icy-meta: %s size: %d bytes", fr->icy.data, (int)meta_size); |
| 154 |
} |
| 155 |
else |
| 156 |
{ |
| 157 |
if(NOQUIET) error1("cannot allocate memory for meta_buff (%lu bytes) ... trying to skip the metadata!", (unsigned long)meta_size); |
| 158 |
fr->rd->skip_bytes(fr, meta_size); |
| 159 |
} |
| 160 |
} |
| 161 |
fr->icy.next = fr->icy.interval; |
| 162 |
} |
| 163 |
else |
| 164 |
{ |
| 165 |
ret = plain_fullread(fr, buf+cnt, count-cnt); |
| 166 |
if(ret < 0){ if(NOQUIET) error1("reading the rest of %li", (long)(count-cnt)); return READER_ERROR; } |
| 167 |
if(ret == 0) break; |
| 168 |
|
| 169 |
cnt += ret; |
| 170 |
fr->icy.next -= ret; |
| 171 |
} |
| 172 |
} |
| 173 |
/* debug1("done reading, got %li", (long)cnt); */ |
| 174 |
return cnt; |
| 175 |
} |
| 176 |
#else |
| 177 |
#define icy_fullread NULL |
| 178 |
#endif /* NO_ICY */ |
| 179 |
|
| 180 |
/* stream based operation */ |
| 181 |
static ptrdiff_t plain_fullread(mpg123_handle *fr,unsigned char *buf, ptrdiff_t count) |
| 182 |
{ |
| 183 |
ptrdiff_t ret,cnt=0; |
| 184 |
|
| 185 |
#ifdef EXTRA_DEBUG |
| 186 |
mdebug("plain fullread of %td", count); |
| 187 |
#endif |
| 188 |
/* |
| 189 |
There used to be a check for expected file end here (length value or ID3 flag). |
| 190 |
This is not needed: |
| 191 |
1. EOF is indicated by fdread returning zero bytes anyway. |
| 192 |
2. We get false positives of EOF for either files that grew or |
| 193 |
3. ... files that have ID3v1 tags in between (stream with intro). |
| 194 |
*/ |
| 195 |
while(cnt < count) |
| 196 |
{ |
| 197 |
ret = fdread(fr,buf+cnt,count-cnt); |
| 198 |
if(ret < 0) return READER_ERROR; |
| 199 |
if(ret == 0) break; |
| 200 |
if(!(fr->rdat.flags & READER_BUFFERED)) |
| 201 |
SATURATE_ADD(fr->rdat.filepos, ret, INT64_MAX); |
| 202 |
cnt += ret; |
| 203 |
} |
| 204 |
return cnt; |
| 205 |
} |
| 206 |
|
| 207 |
static int64_t stream_lseek(mpg123_handle *fr, int64_t pos, int whence) |
| 208 |
{ |
| 209 |
int64_t ret = fdseek(fr, pos, whence); |
| 210 |
if (ret >= 0) |
| 211 |
fr->rdat.filepos = ret; |
| 212 |
else |
| 213 |
{ |
| 214 |
fr->err = MPG123_LSEEK_FAILED; |
| 215 |
ret = READER_ERROR; /* not the original value */ |
| 216 |
} |
| 217 |
return ret; |
| 218 |
} |
| 219 |
|
| 220 |
static void stream_close(mpg123_handle *fr) |
| 221 |
{ |
| 222 |
#ifndef NO_FEEDER |
| 223 |
if(fr->rdat.flags & READER_BUFFERED) bc_reset(&fr->rdat.buffer); |
| 224 |
#endif |
| 225 |
if(fr->rdat.flags & READER_HANDLEIO) |
| 226 |
{ |
| 227 |
if(fr->rdat.cleanup_handle != NULL) |
| 228 |
fr->rdat.cleanup_handle(fr->rdat.iohandle); |
| 229 |
|
| 230 |
fr->rdat.iohandle = NULL; |
| 231 |
} |
| 232 |
} |
| 233 |
|
| 234 |
static int stream_seek_frame(mpg123_handle *fr, int64_t newframe) |
| 235 |
{ |
| 236 |
debug2("seek_frame to %"PRIi64" (from %"PRIi64")", newframe, fr->num); |
| 237 |
/* Seekable streams can go backwards and jump forwards. |
| 238 |
Non-seekable streams still can go forward, just not jump. */ |
| 239 |
if((fr->rdat.flags & READER_SEEKABLE) || (newframe >= fr->num)) |
| 240 |
{ |
| 241 |
int64_t preframe; /* a leading frame we jump to */ |
| 242 |
int64_t seek_to; /* the byte offset we want to reach */ |
| 243 |
int64_t to_skip; /* bytes to skip to get there (can be negative) */ |
| 244 |
/* |
| 245 |
now seek to nearest leading index position and read from there until newframe is reached. |
| 246 |
We use skip_bytes, which handles seekable and non-seekable streams |
| 247 |
(the latter only for positive offset, which we ensured before entering here). |
| 248 |
*/ |
| 249 |
seek_to = INT123_frame_index_find(fr, newframe, &preframe); |
| 250 |
/* No need to seek to index position if we are closer already. |
| 251 |
But I am picky about fr->num == newframe, play safe by reading the frame again. |
| 252 |
If you think that's stupid, don't call a seek to the current frame. */ |
| 253 |
if(fr->num >= newframe || fr->num < preframe) |
| 254 |
{ |
| 255 |
to_skip = seek_to - fr->rd->tell(fr); |
| 256 |
if(fr->rd->skip_bytes(fr, to_skip) != seek_to) |
| 257 |
return READER_ERROR; |
| 258 |
|
| 259 |
debug2("going to %lu; just got %lu", (long unsigned)newframe, (long unsigned)preframe); |
| 260 |
fr->num = preframe-1; /* Watch out! I am going to read preframe... fr->num should indicate the frame before! */ |
| 261 |
} |
| 262 |
while(fr->num < newframe) |
| 263 |
{ |
| 264 |
/* try to be non-fatal now... frameNum only gets advanced on success anyway */ |
| 265 |
if(!INT123_read_frame(fr)) break; |
| 266 |
} |
| 267 |
/* Now the wanted frame should be ready for decoding. */ |
| 268 |
debug1("arrived at %"PRIi64, fr->num); |
| 269 |
|
| 270 |
return MPG123_OK; |
| 271 |
} |
| 272 |
else |
| 273 |
{ |
| 274 |
fr->err = MPG123_NO_SEEK; |
| 275 |
return READER_ERROR; /* invalid, no seek happened */ |
| 276 |
} |
| 277 |
} |
| 278 |
|
| 279 |
/* return FALSE on error, TRUE on success, READER_MORE on occasion */ |
| 280 |
static int generic_head_read(mpg123_handle *fr,unsigned long *newhead) |
| 281 |
{ |
| 282 |
unsigned char hbuf[4]; |
| 283 |
int ret = fr->rd->fullread(fr,hbuf,4); |
| 284 |
if(ret == READER_MORE) return ret; |
| 285 |
if(ret != 4) return FALSE; |
| 286 |
|
| 287 |
*newhead = ((unsigned long) hbuf[0] << 24) | |
| 288 |
((unsigned long) hbuf[1] << 16) | |
| 289 |
((unsigned long) hbuf[2] << 8) | |
| 290 |
(unsigned long) hbuf[3]; |
| 291 |
|
| 292 |
return TRUE; |
| 293 |
} |
| 294 |
|
| 295 |
/* return FALSE on error, TRUE on success, READER_MORE on occasion */ |
| 296 |
static int generic_head_shift(mpg123_handle *fr,unsigned long *head) |
| 297 |
{ |
| 298 |
unsigned char hbuf; |
| 299 |
int ret = fr->rd->fullread(fr,&hbuf,1); |
| 300 |
if(ret == READER_MORE) return ret; |
| 301 |
if(ret != 1) return FALSE; |
| 302 |
|
| 303 |
*head <<= 8; |
| 304 |
*head |= hbuf; |
| 305 |
*head &= 0xffffffff; |
| 306 |
return TRUE; |
| 307 |
} |
| 308 |
|
| 309 |
/* returns reached position... negative ones are bad... */ |
| 310 |
static int64_t stream_skip_bytes(mpg123_handle *fr, int64_t len) |
| 311 |
{ |
| 312 |
if(fr->rdat.flags & READER_SEEKABLE) |
| 313 |
{ |
| 314 |
int64_t ret = stream_lseek(fr, len, SEEK_CUR); |
| 315 |
return (ret < 0) ? READER_ERROR : ret; |
| 316 |
} |
| 317 |
else if(len >= 0) |
| 318 |
{ |
| 319 |
unsigned char buf[1024]; /* ThOr: Compaq cxx complained and it makes sense to me... or should one do a cast? What for? */ |
| 320 |
ptrdiff_t ret; |
| 321 |
while (len > 0) |
| 322 |
{ |
| 323 |
ptrdiff_t num = len < (ptrdiff_t)sizeof(buf) ? (ptrdiff_t)len : (ptrdiff_t)sizeof(buf); |
| 324 |
ret = fr->rd->fullread(fr, buf, num); |
| 325 |
if (ret < 0) return ret; |
| 326 |
else if(ret == 0) break; /* EOF... an error? interface defined to tell the actual position... */ |
| 327 |
len -= ret; |
| 328 |
} |
| 329 |
return fr->rd->tell(fr); |
| 330 |
} |
| 331 |
#ifndef NO_FEEDER |
| 332 |
else if(fr->rdat.flags & READER_BUFFERED) |
| 333 |
{ /* Perhaps we _can_ go a bit back. */ |
| 334 |
if(fr->rdat.buffer.pos >= -len) |
| 335 |
{ |
| 336 |
fr->rdat.buffer.pos += len; |
| 337 |
return fr->rd->tell(fr); |
| 338 |
} |
| 339 |
else |
| 340 |
{ |
| 341 |
fr->err = MPG123_NO_SEEK; |
| 342 |
return READER_ERROR; |
| 343 |
} |
| 344 |
} |
| 345 |
#endif |
| 346 |
else |
| 347 |
{ |
| 348 |
fr->err = MPG123_NO_SEEK; |
| 349 |
return READER_ERROR; |
| 350 |
} |
| 351 |
} |
| 352 |
|
| 353 |
/* Return 0 on success... */ |
| 354 |
static int stream_back_bytes(mpg123_handle *fr, int64_t bytes) |
| 355 |
{ |
| 356 |
int64_t want = fr->rd->tell(fr)-bytes; |
| 357 |
if(want < 0) return READER_ERROR; |
| 358 |
if(stream_skip_bytes(fr,-bytes) != want) return READER_ERROR; |
| 359 |
|
| 360 |
return 0; |
| 361 |
} |
| 362 |
|
| 363 |
|
| 364 |
/* returns size on success... otherwise an error code < 0 */ |
| 365 |
static int generic_read_frame_body(mpg123_handle *fr,unsigned char *buf, int size) |
| 366 |
{ |
| 367 |
ptrdiff_t l; |
| 368 |
l=fr->rd->fullread(fr,buf,size); |
| 369 |
return (l >= 0 && l<size) ? READER_ERROR : (int)l; |
| 370 |
} |
| 371 |
|
| 372 |
static int64_t generic_tell(mpg123_handle *fr) |
| 373 |
{ |
| 374 |
#ifndef NO_FEEDER |
| 375 |
if(fr->rdat.flags & READER_BUFFERED) |
| 376 |
{ |
| 377 |
fr->rdat.filepos = fr->rdat.buffer.fileoff; |
| 378 |
SATURATE_ADD(fr->rdat.filepos, fr->rdat.buffer.pos, INT64_MAX); |
| 379 |
} |
| 380 |
#endif |
| 381 |
|
| 382 |
return fr->rdat.filepos; |
| 383 |
} |
| 384 |
|
| 385 |
/* This does not (fully) work for non-seekable streams... You have to check for that flag, pal! */ |
| 386 |
static void stream_rewind(mpg123_handle *fr) |
| 387 |
{ |
| 388 |
if(fr->rdat.flags & READER_SEEKABLE) |
| 389 |
{ |
| 390 |
fr->rdat.filepos = stream_lseek(fr,0,SEEK_SET); |
| 391 |
#ifndef NO_FEEDER |
| 392 |
fr->rdat.buffer.fileoff = fr->rdat.filepos; |
| 393 |
#endif |
| 394 |
} |
| 395 |
#ifndef NO_FEEDER |
| 396 |
if(fr->rdat.flags & READER_BUFFERED) |
| 397 |
{ |
| 398 |
fr->rdat.buffer.pos = 0; |
| 399 |
fr->rdat.buffer.firstpos = 0; |
| 400 |
fr->rdat.filepos = fr->rdat.buffer.fileoff; |
| 401 |
} |
| 402 |
#endif |
| 403 |
} |
| 404 |
|
| 405 |
/* |
| 406 |
* returns length of a file (if filept points to a file) |
| 407 |
* reads the last 128 bytes information into buffer |
| 408 |
* ... that is not totally safe... |
| 409 |
*/ |
| 410 |
static int64_t get_fileinfo(mpg123_handle *fr) |
| 411 |
{ |
| 412 |
int64_t len; |
| 413 |
|
| 414 |
if((len=fdseek(fr,0,SEEK_END)) < 0) |
| 415 |
{ |
| 416 |
debug("cannot seek to end"); |
| 417 |
return -1; |
| 418 |
} else if(len >= 128) |
| 419 |
{ |
| 420 |
if(fdseek(fr,-128,SEEK_END) < 0) |
| 421 |
{ |
| 422 |
debug("cannot seek to END-128"); |
| 423 |
return -1; |
| 424 |
} |
| 425 |
if(fr->rd->fullread(fr,(unsigned char *)fr->id3buf,128) != 128) |
| 426 |
{ |
| 427 |
debug("cannot read ID3v1?!"); |
| 428 |
return -1; |
| 429 |
} |
| 430 |
if(!strncmp((char*)fr->id3buf,"TAG",3)) len -= 128; |
| 431 |
} else |
| 432 |
{ |
| 433 |
debug("stream too short for ID3"); |
| 434 |
} |
| 435 |
|
| 436 |
if(fdseek(fr,0,SEEK_SET) < 0) |
| 437 |
{ |
| 438 |
debug("cannot seek back"); |
| 439 |
return -1; |
| 440 |
} |
| 441 |
fr->rdat.filepos = 0; // un-do our seeking here |
| 442 |
|
| 443 |
debug1("returning length: %"PRIi64, len); |
| 444 |
return len; |
| 445 |
} |
| 446 |
|
| 447 |
#ifndef NO_FEEDER |
| 448 |
/* Methods for the buffer chain, mainly used for feed reader, but not just that. */ |
| 449 |
|
| 450 |
|
| 451 |
static struct buffy* buffy_new(ptrdiff_t size, ptrdiff_t minsize) |
| 452 |
{ |
| 453 |
struct buffy *newbuf; |
| 454 |
if(size > PTRDIFF_MAX) |
| 455 |
return NULL; |
| 456 |
newbuf = malloc(sizeof(struct buffy)); |
| 457 |
if(newbuf == NULL) return NULL; |
| 458 |
|
| 459 |
newbuf->realsize = size > minsize ? size : minsize; |
| 460 |
newbuf->data = malloc((size_t)newbuf->realsize); |
| 461 |
if(newbuf->data == NULL) |
| 462 |
{ |
| 463 |
free(newbuf); |
| 464 |
return NULL; |
| 465 |
} |
| 466 |
newbuf->size = 0; |
| 467 |
newbuf->next = NULL; |
| 468 |
return newbuf; |
| 469 |
} |
| 470 |
|
| 471 |
static void buffy_del(struct buffy* buf) |
| 472 |
{ |
| 473 |
if(buf) |
| 474 |
{ |
| 475 |
free(buf->data); |
| 476 |
free(buf); |
| 477 |
} |
| 478 |
} |
| 479 |
|
| 480 |
/* Delete this buffy and all following buffies. */ |
| 481 |
static void buffy_del_chain(struct buffy* buf) |
| 482 |
{ |
| 483 |
while(buf) |
| 484 |
{ |
| 485 |
struct buffy* next = buf->next; |
| 486 |
buffy_del(buf); |
| 487 |
buf = next; |
| 488 |
} |
| 489 |
} |
| 490 |
|
| 491 |
void INT123_bc_prepare(struct bufferchain *bc, size_t pool_size, size_t bufblock) |
| 492 |
{ |
| 493 |
INT123_bc_poolsize(bc, pool_size, bufblock); |
| 494 |
bc->pool = NULL; |
| 495 |
bc->pool_fill = 0; |
| 496 |
bc_init(bc); /* Ensure that members are zeroed for read-only use. */ |
| 497 |
} |
| 498 |
|
| 499 |
size_t INT123_bc_fill(struct bufferchain *bc) |
| 500 |
{ |
| 501 |
return (size_t)(bc->size - bc->pos); |
| 502 |
} |
| 503 |
|
| 504 |
void INT123_bc_poolsize(struct bufferchain *bc, size_t pool_size, size_t bufblock) |
| 505 |
{ |
| 506 |
bc->pool_size = pool_size; |
| 507 |
bc->bufblock = bufblock; |
| 508 |
} |
| 509 |
|
| 510 |
void INT123_bc_cleanup(struct bufferchain *bc) |
| 511 |
{ |
| 512 |
buffy_del_chain(bc->pool); |
| 513 |
bc->pool = NULL; |
| 514 |
bc->pool_fill = 0; |
| 515 |
} |
| 516 |
|
| 517 |
/* Fetch a buffer from the pool (if possible) or create one. */ |
| 518 |
static struct buffy* bc_alloc(struct bufferchain *bc, size_t size) |
| 519 |
{ |
| 520 |
/* Easy route: Just try the first available buffer. |
| 521 |
Size does not matter, it's only a hint for creation of new buffers. */ |
| 522 |
if(bc->pool) |
| 523 |
{ |
| 524 |
struct buffy *buf = bc->pool; |
| 525 |
bc->pool = buf->next; |
| 526 |
buf->next = NULL; /* That shall be set to a sensible value later. */ |
| 527 |
buf->size = 0; |
| 528 |
--bc->pool_fill; |
| 529 |
debug2("bc_alloc: picked %p from pool (fill now %zu)", (void*)buf, bc->pool_fill); |
| 530 |
return buf; |
| 531 |
} |
| 532 |
else return buffy_new(size, bc->bufblock); |
| 533 |
} |
| 534 |
|
| 535 |
/* Either stuff the buffer back into the pool or free it for good. */ |
| 536 |
static void bc_free(struct bufferchain *bc, struct buffy* buf) |
| 537 |
{ |
| 538 |
if(!buf) return; |
| 539 |
|
| 540 |
if(bc->pool_fill < bc->pool_size) |
| 541 |
{ |
| 542 |
buf->next = bc->pool; |
| 543 |
bc->pool = buf; |
| 544 |
++bc->pool_fill; |
| 545 |
} |
| 546 |
else buffy_del(buf); |
| 547 |
} |
| 548 |
|
| 549 |
/* Make the buffer count in the pool match the pool size. */ |
| 550 |
static int bc_fill_pool(struct bufferchain *bc) |
| 551 |
{ |
| 552 |
/* Remove superfluous ones. */ |
| 553 |
while(bc->pool_fill > bc->pool_size) |
| 554 |
{ |
| 555 |
/* Lazyness: Just work on the front. */ |
| 556 |
struct buffy* buf = bc->pool; |
| 557 |
bc->pool = buf->next; |
| 558 |
buffy_del(buf); |
| 559 |
--bc->pool_fill; |
| 560 |
} |
| 561 |
|
| 562 |
/* Add missing ones. */ |
| 563 |
while(bc->pool_fill < bc->pool_size) |
| 564 |
{ |
| 565 |
/* Again, just work on the front. */ |
| 566 |
struct buffy* buf; |
| 567 |
buf = buffy_new(0, bc->bufblock); /* Use default block size. */ |
| 568 |
if(!buf) return -1; |
| 569 |
|
| 570 |
buf->next = bc->pool; |
| 571 |
bc->pool = buf; |
| 572 |
++bc->pool_fill; |
| 573 |
} |
| 574 |
|
| 575 |
return 0; |
| 576 |
} |
| 577 |
|
| 578 |
|
| 579 |
static void bc_init(struct bufferchain *bc) |
| 580 |
{ |
| 581 |
bc->first = NULL; |
| 582 |
bc->last = bc->first; |
| 583 |
bc->size = 0; |
| 584 |
bc->pos = 0; |
| 585 |
bc->firstpos = 0; |
| 586 |
bc->fileoff = 0; |
| 587 |
} |
| 588 |
|
| 589 |
static void bc_reset(struct bufferchain *bc) |
| 590 |
{ |
| 591 |
/* Free current chain, possibly stuffing back into the pool. */ |
| 592 |
while(bc->first) |
| 593 |
{ |
| 594 |
struct buffy* buf = bc->first; |
| 595 |
bc->first = buf->next; |
| 596 |
bc_free(bc, buf); |
| 597 |
} |
| 598 |
bc_fill_pool(bc); /* Ignoring an error here... */ |
| 599 |
bc_init(bc); |
| 600 |
} |
| 601 |
|
| 602 |
/* Create a new buffy at the end to be filled. */ |
| 603 |
static int bc_append(struct bufferchain *bc, ptrdiff_t size) |
| 604 |
{ |
| 605 |
struct buffy *newbuf; |
| 606 |
if(size < 1) return -1; |
| 607 |
|
| 608 |
newbuf = bc_alloc(bc, size); |
| 609 |
if(newbuf == NULL) return -2; |
| 610 |
|
| 611 |
if(bc->last != NULL) bc->last->next = newbuf; |
| 612 |
else if(bc->first == NULL) bc->first = newbuf; |
| 613 |
|
| 614 |
bc->last = newbuf; |
| 615 |
debug3("bc_append: new last buffer %p with %td B (really %td)", (void*)bc->last, bc->last->size, bc->last->realsize); |
| 616 |
return 0; |
| 617 |
} |
| 618 |
|
| 619 |
/* Append a new buffer and copy content to it. */ |
| 620 |
static int bc_add(struct bufferchain *bc, const unsigned char *data, ptrdiff_t size) |
| 621 |
{ |
| 622 |
int ret = 0; |
| 623 |
ptrdiff_t part = 0; |
| 624 |
if((size_t)(PTRDIFF_MAX - bc->size) < size) |
| 625 |
return -1; |
| 626 |
debug2("bc_add: adding %zu bytes at %"PRIi64, size, (int64_t)(bc->fileoff+bc->size)); |
| 627 |
if(size >=4) debug4("first bytes: %02x %02x %02x %02x", data[0], data[1], data[2], data[3]); |
| 628 |
|
| 629 |
while(size > 0) |
| 630 |
{ |
| 631 |
/* Try to fill up the last buffer block. */ |
| 632 |
if(bc->last != NULL && bc->last->size < bc->last->realsize) |
| 633 |
{ |
| 634 |
part = bc->last->realsize - bc->last->size; |
| 635 |
if(part > size) part = size; |
| 636 |
|
| 637 |
debug2("bc_add: adding %td B to existing block %p", part, (void*)bc->last); |
| 638 |
memcpy(bc->last->data+bc->last->size, data, part); |
| 639 |
bc->last->size += part; |
| 640 |
size -= part; |
| 641 |
bc->size += part; |
| 642 |
data += part; |
| 643 |
} |
| 644 |
|
| 645 |
/* If there is still data left, put it into a new buffer block. */ |
| 646 |
if(size > 0 && (ret = bc_append(bc, size)) != 0) |
| 647 |
break; |
| 648 |
} |
| 649 |
|
| 650 |
return ret; |
| 651 |
} |
| 652 |
|
| 653 |
/* Common handler for "You want more than I can give." situation. */ |
| 654 |
static ptrdiff_t bc_need_more(struct bufferchain *bc, ptrdiff_t size) |
| 655 |
{ |
| 656 |
debug3("hit end, back to beginning (%td - %td < %td)", bc->size, bc->pos, size); |
| 657 |
/* go back to firstpos, undo the previous reads */ |
| 658 |
bc->pos = bc->firstpos; |
| 659 |
return READER_MORE; |
| 660 |
} |
| 661 |
|
| 662 |
/* Give some data, advancing position but not forgetting yet. */ |
| 663 |
static ptrdiff_t bc_give(struct bufferchain *bc, unsigned char *out, ptrdiff_t size) |
| 664 |
{ |
| 665 |
struct buffy *b = bc->first; |
| 666 |
ptrdiff_t gotcount = 0; |
| 667 |
ptrdiff_t offset = 0; |
| 668 |
if(bc->size - bc->pos < size) return bc_need_more(bc, size); |
| 669 |
|
| 670 |
/* find the current buffer */ |
| 671 |
while(b != NULL && (offset + b->size) <= bc->pos) |
| 672 |
{ |
| 673 |
offset += b->size; |
| 674 |
b = b->next; |
| 675 |
} |
| 676 |
/* now start copying from there */ |
| 677 |
while(gotcount < size && (b != NULL)) |
| 678 |
{ |
| 679 |
ptrdiff_t loff = bc->pos - offset; |
| 680 |
ptrdiff_t chunk = size - gotcount; /* amount of bytes to get from here... */ |
| 681 |
if(chunk > b->size - loff) chunk = b->size - loff; |
| 682 |
|
| 683 |
#ifdef EXTRA_DEBUG |
| 684 |
debug3("copying %liB from %p+%li",(long)chunk, b->data, (long)loff); |
| 685 |
#endif |
| 686 |
|
| 687 |
memcpy(out+gotcount, b->data+loff, chunk); |
| 688 |
gotcount += chunk; |
| 689 |
bc->pos += chunk; |
| 690 |
offset += b->size; |
| 691 |
b = b->next; |
| 692 |
} |
| 693 |
#ifdef EXTRA_DEBUG |
| 694 |
debug2("got %li bytes, pos advanced to %li", (long)gotcount, (long)bc->pos); |
| 695 |
#endif |
| 696 |
|
| 697 |
return gotcount; |
| 698 |
} |
| 699 |
|
| 700 |
/* Skip some bytes and return the new position. |
| 701 |
The buffers are still there, just the read pointer is moved! */ |
| 702 |
static ptrdiff_t bc_skip(struct bufferchain *bc, ptrdiff_t count) |
| 703 |
{ |
| 704 |
if(count >= 0) |
| 705 |
{ |
| 706 |
if(bc->size - bc->pos < count) return bc_need_more(bc, count); |
| 707 |
else return bc->pos += count; |
| 708 |
} |
| 709 |
else return READER_ERROR; |
| 710 |
} |
| 711 |
|
| 712 |
static ptrdiff_t bc_seekback(struct bufferchain *bc, ptrdiff_t count) |
| 713 |
{ |
| 714 |
if(count >= 0 && count <= bc->pos) return bc->pos -= count; |
| 715 |
else return READER_ERROR; |
| 716 |
} |
| 717 |
|
| 718 |
/* Throw away buffies that we passed. */ |
| 719 |
static void bc_forget(struct bufferchain *bc) |
| 720 |
{ |
| 721 |
struct buffy *b = bc->first; |
| 722 |
/* free all buffers that are def'n'tly outdated */ |
| 723 |
/* we have buffers until filepos... delete all buffers fully below it */ |
| 724 |
if(b) debug2("bc_forget: block %td pos %td", b->size, bc->pos); |
| 725 |
else debug("forget with nothing there!"); |
| 726 |
|
| 727 |
while(b != NULL && bc->pos >= b->size) |
| 728 |
{ |
| 729 |
struct buffy *n = b->next; /* != NULL or this is indeed the end and the last cycle anyway */ |
| 730 |
if(n == NULL) bc->last = NULL; /* Going to delete the last buffy... */ |
| 731 |
bc->fileoff += b->size; |
| 732 |
bc->pos -= b->size; |
| 733 |
bc->size -= b->size; |
| 734 |
|
| 735 |
debug5("bc_forget: forgot %p with %td, pos=%td, size=%td, fileoff=%"PRIi64 |
| 736 |
, (void*)b->data, b->size, bc->pos, bc->size, bc->fileoff); |
| 737 |
|
| 738 |
bc_free(bc, b); |
| 739 |
b = n; |
| 740 |
} |
| 741 |
bc->first = b; |
| 742 |
bc->firstpos = bc->pos; |
| 743 |
} |
| 744 |
|
| 745 |
/* reader for input via manually provided buffers */ |
| 746 |
|
| 747 |
static int feed_init(mpg123_handle *fr) |
| 748 |
{ |
| 749 |
bc_init(&fr->rdat.buffer); |
| 750 |
bc_fill_pool(&fr->rdat.buffer); |
| 751 |
fr->rdat.filelen = 0; |
| 752 |
fr->rdat.filepos = 0; |
| 753 |
fr->rdat.flags |= READER_BUFFERED; |
| 754 |
return 0; |
| 755 |
} |
| 756 |
|
| 757 |
/* externally called function, returns 0 on success, -1 on error */ |
| 758 |
// External API uses size_t, we use signed ptrdiff_t internally. Overflow |
| 759 |
// is a theoretical possibility. |
| 760 |
int INT123_feed_more(mpg123_handle *fr, const unsigned char *in, size_t count) |
| 761 |
{ |
| 762 |
int ret = 0; |
| 763 |
if(VERBOSE3) debug("INT123_feed_more"); |
| 764 |
if(count > PTRDIFF_MAX) |
| 765 |
return READER_ERROR; |
| 766 |
if((ret = bc_add(&fr->rdat.buffer, in, (ptrdiff_t)count)) != 0) |
| 767 |
{ |
| 768 |
ret = READER_ERROR; |
| 769 |
if(NOQUIET) error1("Failed to add buffer, return: %i", ret); |
| 770 |
} |
| 771 |
else /* Not talking about filelen... that stays at 0. */ |
| 772 |
|
| 773 |
if(VERBOSE3) debug3("INT123_feed_more: %p %luB bufsize=%lu", fr->rdat.buffer.last->data, |
| 774 |
(unsigned long)fr->rdat.buffer.last->size, (unsigned long)fr->rdat.buffer.size); |
| 775 |
return ret; |
| 776 |
} |
| 777 |
|
| 778 |
static ptrdiff_t feed_read(mpg123_handle *fr, unsigned char *out, ptrdiff_t count) |
| 779 |
{ |
| 780 |
ptrdiff_t gotcount = bc_give(&fr->rdat.buffer, out, count); |
| 781 |
if(gotcount >= 0 && gotcount != count) return READER_ERROR; |
| 782 |
else return gotcount; |
| 783 |
} |
| 784 |
|
| 785 |
/* returns reached position... negative ones are bad... */ |
| 786 |
static int64_t feed_skip_bytes(mpg123_handle *fr, int64_t len) |
| 787 |
{ |
| 788 |
/* This is either the new buffer offset or some negative error value. */ |
| 789 |
int64_t res = bc_skip(&fr->rdat.buffer, (ptrdiff_t)len); |
| 790 |
if(res < 0) return res; |
| 791 |
|
| 792 |
return fr->rdat.buffer.fileoff+res; |
| 793 |
} |
| 794 |
|
| 795 |
static int feed_back_bytes(mpg123_handle *fr, int64_t bytes) |
| 796 |
{ |
| 797 |
if(bytes >=0) |
| 798 |
return bc_seekback(&fr->rdat.buffer, (ptrdiff_t)bytes) >= 0 ? 0 : READER_ERROR; |
| 799 |
else |
| 800 |
return feed_skip_bytes(fr, -bytes) >= 0 ? 0 : READER_ERROR; |
| 801 |
} |
| 802 |
|
| 803 |
static int feed_seek_frame(mpg123_handle *fr, int64_t num){ return READER_ERROR; } |
| 804 |
|
| 805 |
/* Not just for feed reader, also for self-feeding buffered reader. */ |
| 806 |
static void buffered_forget(mpg123_handle *fr) |
| 807 |
{ |
| 808 |
bc_forget(&fr->rdat.buffer); |
| 809 |
fr->rdat.filepos = fr->rdat.buffer.fileoff; |
| 810 |
SATURATE_ADD(fr->rdat.filepos, fr->rdat.buffer.pos, INT64_MAX); |
| 811 |
} |
| 812 |
|
| 813 |
int64_t INT123_feed_set_pos(mpg123_handle *fr, int64_t pos) |
| 814 |
{ |
| 815 |
struct bufferchain *bc = &fr->rdat.buffer; |
| 816 |
if(pos >= bc->fileoff && pos-bc->fileoff < bc->size) |
| 817 |
{ /* We have the position! */ |
| 818 |
bc->pos = (ptrdiff_t)(pos - bc->fileoff); |
| 819 |
debug1("INT123_feed_set_pos inside, next feed from %"PRIi64, (int64_t)(bc->fileoff+bc->size)); |
| 820 |
return bc->fileoff+bc->size; /* Next input after end of buffer... */ |
| 821 |
} |
| 822 |
else |
| 823 |
{ /* I expect to get the specific position on next feed. Forget what I have now. */ |
| 824 |
bc_reset(bc); |
| 825 |
bc->fileoff = pos; |
| 826 |
debug1("INT123_feed_set_pos outside, buffer reset, next feed from %"PRIi64, pos); |
| 827 |
return pos; /* Next input from exactly that position. */ |
| 828 |
} |
| 829 |
} |
| 830 |
|
| 831 |
/* The specific stuff for buffered stream reader. */ |
| 832 |
|
| 833 |
static ptrdiff_t buffered_fullread(mpg123_handle *fr, unsigned char *out, ptrdiff_t count |
| 834 |
, ptrdiff_t (*fullread)(mpg123_handle *, unsigned char *, ptrdiff_t)) |
| 835 |
{ |
| 836 |
struct bufferchain *bc = &fr->rdat.buffer; |
| 837 |
ptrdiff_t gotcount; |
| 838 |
if(VERBOSE3) |
| 839 |
mdebug("buffered_fullread: want %zd", count); |
| 840 |
if(bc->size - bc->pos < count) |
| 841 |
{ /* Add more stuff to buffer. If hitting end of file, adjust count. */ |
| 842 |
unsigned char readbuf[4096]; |
| 843 |
ptrdiff_t need = count - (bc->size-bc->pos); |
| 844 |
while(need>0) |
| 845 |
{ |
| 846 |
int ret; |
| 847 |
ptrdiff_t got = fullread(fr, readbuf, sizeof(readbuf)); |
| 848 |
if(got < 0) |
| 849 |
{ |
| 850 |
if(NOQUIET) error("buffer reading"); |
| 851 |
return READER_ERROR; |
| 852 |
} |
| 853 |
|
| 854 |
if(VERBOSE3) |
| 855 |
debug1("buffered_fullread: buffering %td bytes from stream (if > 0)", got); |
| 856 |
if(got > 0 && (ret=bc_add(bc, readbuf, got)) != 0) |
| 857 |
{ |
| 858 |
if(NOQUIET) error1("unable to add to chain, return: %i", ret); |
| 859 |
return READER_ERROR; |
| 860 |
} |
| 861 |
|
| 862 |
need -= got; /* May underflow here... */ |
| 863 |
if(got < sizeof(readbuf)) /* That naturally catches got == 0, too. */ |
| 864 |
{ |
| 865 |
if(VERBOSE3) fprintf(stderr, "Note: Input data end.\n"); |
| 866 |
break; /* End. */ |
| 867 |
} |
| 868 |
} |
| 869 |
if(bc->size - bc->pos < count) |
| 870 |
count = bc->size - bc->pos; /* We want only what we got. */ |
| 871 |
} |
| 872 |
gotcount = bc_give(bc, out, count); |
| 873 |
if(VERBOSE3) |
| 874 |
mdebug("buffered_fullread: got %td", gotcount); |
| 875 |
if(gotcount != count){ if(NOQUIET) error("gotcount != count"); return READER_ERROR; } |
| 876 |
else return gotcount; |
| 877 |
} |
| 878 |
|
| 879 |
static ptrdiff_t buffered_plain_fullread(mpg123_handle *fr, unsigned char *out, ptrdiff_t count) |
| 880 |
{ |
| 881 |
return buffered_fullread(fr, out, count, plain_fullread); |
| 882 |
} |
| 883 |
|
| 884 |
static ptrdiff_t buffered_icy_fullread(mpg123_handle *fr, unsigned char *out, ptrdiff_t count) |
| 885 |
{ |
| 886 |
return buffered_fullread(fr, out, count, icy_fullread); |
| 887 |
} |
| 888 |
|
| 889 |
#else |
| 890 |
int INT123_feed_more(mpg123_handle *fr, const unsigned char *in, size_t count) |
| 891 |
{ |
| 892 |
fr->err = MPG123_MISSING_FEATURE; |
| 893 |
return -1; |
| 894 |
} |
| 895 |
int64_t INT123_feed_set_pos(mpg123_handle *fr, int64_t pos) |
| 896 |
{ |
| 897 |
fr->err = MPG123_MISSING_FEATURE; |
| 898 |
return -1; |
| 899 |
} |
| 900 |
#endif /* NO_FEEDER */ |
| 901 |
|
| 902 |
/***************************************************************** |
| 903 |
* read frame helper |
| 904 |
*/ |
| 905 |
|
| 906 |
#define bugger_off { mh->err = MPG123_NO_READER; return MPG123_ERR; } |
| 907 |
static int bad_init(mpg123_handle *mh) bugger_off |
| 908 |
static void bad_close(mpg123_handle *mh){} |
| 909 |
static ptrdiff_t bad_fullread(mpg123_handle *mh, unsigned char *data, ptrdiff_t count) bugger_off |
| 910 |
static int bad_head_read(mpg123_handle *mh, unsigned long *newhead) bugger_off |
| 911 |
static int bad_head_shift(mpg123_handle *mh, unsigned long *head) bugger_off |
| 912 |
static int64_t bad_skip_bytes(mpg123_handle *mh, int64_t len) bugger_off |
| 913 |
static int bad_read_frame_body(mpg123_handle *mh, unsigned char *data, int size) bugger_off |
| 914 |
static int bad_back_bytes(mpg123_handle *mh, int64_t bytes) bugger_off |
| 915 |
static int bad_seek_frame(mpg123_handle *mh, int64_t num) bugger_off |
| 916 |
static int64_t bad_tell(mpg123_handle *mh) bugger_off |
| 917 |
static void bad_rewind(mpg123_handle *mh){} |
| 918 |
#undef bugger_off |
| 919 |
|
| 920 |
#define READER_STREAM 0 |
| 921 |
#define READER_ICY_STREAM 1 |
| 922 |
#define READER_FEED 2 |
| 923 |
#define READER_BUF_STREAM 3 |
| 924 |
#define READER_BUF_ICY_STREAM 4 |
| 925 |
static struct reader readers[] = |
| 926 |
{ |
| 927 |
{ /* READER_STREAM */ |
| 928 |
stream_init, |
| 929 |
stream_close, |
| 930 |
plain_fullread, |
| 931 |
generic_head_read, |
| 932 |
generic_head_shift, |
| 933 |
stream_skip_bytes, |
| 934 |
generic_read_frame_body, |
| 935 |
stream_back_bytes, |
| 936 |
stream_seek_frame, |
| 937 |
generic_tell, |
| 938 |
stream_rewind, |
| 939 |
NULL |
| 940 |
} , |
| 941 |
{ /* READER_ICY_STREAM */ |
| 942 |
stream_init, |
| 943 |
stream_close, |
| 944 |
icy_fullread, |
| 945 |
generic_head_read, |
| 946 |
generic_head_shift, |
| 947 |
stream_skip_bytes, |
| 948 |
generic_read_frame_body, |
| 949 |
stream_back_bytes, |
| 950 |
stream_seek_frame, |
| 951 |
generic_tell, |
| 952 |
stream_rewind, |
| 953 |
NULL |
| 954 |
}, |
| 955 |
#ifdef NO_FEEDER |
| 956 |
#define feed_init NULL |
| 957 |
#define feed_read NULL |
| 958 |
#define buffered_fullread NULL |
| 959 |
#define buffered_plain_fullread NULL |
| 960 |
#define buffered_icy_fullread NULL |
| 961 |
#define feed_seek_frame NULL |
| 962 |
#define feed_back_bytes NULL |
| 963 |
#define feed_skip_bytes NULL |
| 964 |
#define buffered_forget NULL |
| 965 |
#endif |
| 966 |
{ /* READER_FEED */ |
| 967 |
feed_init, |
| 968 |
stream_close, |
| 969 |
feed_read, |
| 970 |
generic_head_read, |
| 971 |
generic_head_shift, |
| 972 |
feed_skip_bytes, |
| 973 |
generic_read_frame_body, |
| 974 |
feed_back_bytes, |
| 975 |
feed_seek_frame, |
| 976 |
generic_tell, |
| 977 |
stream_rewind, |
| 978 |
buffered_forget |
| 979 |
}, |
| 980 |
{ /* READER_BUF_STREAM */ |
| 981 |
stream_init, |
| 982 |
stream_close, |
| 983 |
buffered_plain_fullread, |
| 984 |
generic_head_read, |
| 985 |
generic_head_shift, |
| 986 |
stream_skip_bytes, |
| 987 |
generic_read_frame_body, |
| 988 |
stream_back_bytes, |
| 989 |
stream_seek_frame, |
| 990 |
generic_tell, |
| 991 |
stream_rewind, |
| 992 |
buffered_forget |
| 993 |
} , |
| 994 |
{ /* READER_BUF_ICY_STREAM */ |
| 995 |
stream_init, |
| 996 |
stream_close, |
| 997 |
buffered_icy_fullread, |
| 998 |
generic_head_read, |
| 999 |
generic_head_shift, |
| 1000 |
stream_skip_bytes, |
| 1001 |
generic_read_frame_body, |
| 1002 |
stream_back_bytes, |
| 1003 |
stream_seek_frame, |
| 1004 |
generic_tell, |
| 1005 |
stream_rewind, |
| 1006 |
buffered_forget |
| 1007 |
}, |
| 1008 |
}; |
| 1009 |
|
| 1010 |
static struct reader bad_reader = |
| 1011 |
{ |
| 1012 |
bad_init, |
| 1013 |
bad_close, |
| 1014 |
bad_fullread, |
| 1015 |
bad_head_read, |
| 1016 |
bad_head_shift, |
| 1017 |
bad_skip_bytes, |
| 1018 |
bad_read_frame_body, |
| 1019 |
bad_back_bytes, |
| 1020 |
bad_seek_frame, |
| 1021 |
bad_tell, |
| 1022 |
bad_rewind, |
| 1023 |
NULL |
| 1024 |
}; |
| 1025 |
|
| 1026 |
static int stream_init(mpg123_handle *fr) |
| 1027 |
{ |
| 1028 |
#ifndef NO_ICY |
| 1029 |
/* ICY streams of any sort shall not be seekable. */ |
| 1030 |
if(fr->p.icy_interval > 0) fr->rdat.flags |= READER_NOSEEK; |
| 1031 |
#endif |
| 1032 |
|
| 1033 |
fr->rdat.filepos = 0; |
| 1034 |
fr->rdat.filelen = fr->p.flags & MPG123_NO_PEEK_END ? -1 : get_fileinfo(fr); |
| 1035 |
if(fr->p.flags & MPG123_FORCE_SEEKABLE) |
| 1036 |
{ |
| 1037 |
fr->rdat.flags |= READER_SEEKABLE; |
| 1038 |
fr->rdat.flags &= ~READER_NOSEEK; |
| 1039 |
} |
| 1040 |
/* |
| 1041 |
Don't enable seeking on ICY streams, just plain normal files. |
| 1042 |
This check is necessary since the client can enforce ICY parsing on files that would otherwise be seekable. |
| 1043 |
It is a task for the future to make the ICY parsing safe with seeks ... or not. |
| 1044 |
*/ |
| 1045 |
if(fr->rdat.filelen >= 0) |
| 1046 |
{ |
| 1047 |
debug("seekable stream"); |
| 1048 |
fr->rdat.flags |= READER_SEEKABLE; |
| 1049 |
if(!strncmp((char*)fr->id3buf,"TAG",3)) |
| 1050 |
{ |
| 1051 |
fr->rdat.flags |= READER_ID3TAG; |
| 1052 |
fr->metaflags |= MPG123_NEW_ID3; |
| 1053 |
} |
| 1054 |
} |
| 1055 |
/* Switch reader to a buffered one, if allowed. */ |
| 1056 |
else if(fr->p.flags & MPG123_SEEKBUFFER) |
| 1057 |
{ |
| 1058 |
#ifdef NO_FEEDER |
| 1059 |
if(NOQUIET) |
| 1060 |
error("Buffered readers not supported in this build."); |
| 1061 |
fr->err = MPG123_MISSING_FEATURE; |
| 1062 |
return -1; |
| 1063 |
#else |
| 1064 |
if (fr->rd == &readers[READER_STREAM]) |
| 1065 |
{ |
| 1066 |
debug("switching to buffered stream reader"); |
| 1067 |
fr->rd = &readers[READER_BUF_STREAM]; |
| 1068 |
} |
| 1069 |
#ifndef NO_ICY |
| 1070 |
else if(fr->rd == &readers[READER_ICY_STREAM]) |
| 1071 |
{ |
| 1072 |
debug("switching to buffered ICY stream reader"); |
| 1073 |
fr->rd = &readers[READER_BUF_ICY_STREAM]; |
| 1074 |
} |
| 1075 |
#endif |
| 1076 |
else |
| 1077 |
{ |
| 1078 |
if(NOQUIET) error("mpg123 Programmer's fault: invalid reader"); |
| 1079 |
return -1; |
| 1080 |
} |
| 1081 |
bc_init(&fr->rdat.buffer); |
| 1082 |
fr->rdat.filelen = 0; /* We carry the offset, but never know how big the stream is. */ |
| 1083 |
fr->rdat.flags |= READER_BUFFERED; |
| 1084 |
#endif /* NO_ICY */ |
| 1085 |
} |
| 1086 |
return 0; |
| 1087 |
} |
| 1088 |
|
| 1089 |
|
| 1090 |
void INT123_open_bad(mpg123_handle *mh) |
| 1091 |
{ |
| 1092 |
debug("INT123_open_bad"); |
| 1093 |
#ifndef NO_ICY |
| 1094 |
INT123_clear_icy(&mh->icy); |
| 1095 |
#endif |
| 1096 |
mh->rd = &bad_reader; |
| 1097 |
mh->rdat.flags = 0; |
| 1098 |
#ifndef NO_FEEDER |
| 1099 |
bc_init(&mh->rdat.buffer); |
| 1100 |
#endif |
| 1101 |
mh->rdat.filelen = -1; |
| 1102 |
} |
| 1103 |
|
| 1104 |
int INT123_open_feed(mpg123_handle *fr) |
| 1105 |
{ |
| 1106 |
debug("feed reader"); |
| 1107 |
#ifdef NO_FEEDER |
| 1108 |
if(NOQUIET) |
| 1109 |
error("Buffered readers not supported in this build."); |
| 1110 |
fr->err = MPG123_MISSING_FEATURE; |
| 1111 |
return -1; |
| 1112 |
#else |
| 1113 |
#ifndef NO_ICY |
| 1114 |
if(fr->p.icy_interval > 0) |
| 1115 |
{ |
| 1116 |
if(NOQUIET) error("Feed reader cannot do ICY parsing!"); |
| 1117 |
|
| 1118 |
return -1; |
| 1119 |
} |
| 1120 |
INT123_clear_icy(&fr->icy); |
| 1121 |
#endif |
| 1122 |
fr->rd = &readers[READER_FEED]; |
| 1123 |
fr->rdat.flags = 0; |
| 1124 |
if(fr->rd->init(fr) < 0) return -1; |
| 1125 |
|
| 1126 |
debug("feed reader init successful"); |
| 1127 |
return 0; |
| 1128 |
#endif /* NO_FEEDER */ |
| 1129 |
} |
| 1130 |
|
| 1131 |
/* Final code common to open_stream and INT123_open_stream_handle. */ |
| 1132 |
int INT123_open_stream_handle(mpg123_handle *fr, void *iohandle) |
| 1133 |
{ |
| 1134 |
INT123_clear_icy(&fr->icy); /* can be done inside frame_clear ...? */ |
| 1135 |
fr->rdat.filelen = -1; |
| 1136 |
fr->rdat.iohandle = iohandle; |
| 1137 |
fr->rdat.flags = 0; |
| 1138 |
fr->rdat.flags |= READER_HANDLEIO; |
| 1139 |
|
| 1140 |
#ifndef NO_ICY |
| 1141 |
if(fr->p.icy_interval > 0) |
| 1142 |
{ |
| 1143 |
debug("ICY reader"); |
| 1144 |
fr->icy.interval = fr->p.icy_interval; |
| 1145 |
fr->icy.next = fr->icy.interval; |
| 1146 |
fr->rd = &readers[READER_ICY_STREAM]; |
| 1147 |
} |
| 1148 |
else |
| 1149 |
#endif |
| 1150 |
{ |
| 1151 |
fr->rd = &readers[READER_STREAM]; |
| 1152 |
debug("stream reader"); |
| 1153 |
} |
| 1154 |
|
| 1155 |
if(fr->rd->init(fr) < 0) return -1; |
| 1156 |
|
| 1157 |
return MPG123_OK; |
| 1158 |
} |