readers.c File Reference

#include "mpg123lib_intern.h"
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include "compat.h"
#include "debug.h"

Include dependency graph for readers.c:

Go to the source code of this file.

Macros
#define	bugger_off   { mh->err = MPG123_NO_READER; return MPG123_ERR; }
#define	READER_STREAM   0
#define	READER_ICY_STREAM   1
#define	READER_FEED   2
#define	READER_BUF_STREAM   3
#define	READER_BUF_ICY_STREAM   4
#define	O_BINARY   (0)

Functions
static int	default_init (mpg123_handle *fr)
static off_t	get_fileinfo (mpg123_handle *)
static ssize_t	posix_read (int fd, void *buf, size_t count)
static off_t	posix_lseek (int fd, off_t offset, int whence)
static off_t	nix_lseek (int fd, off_t offset, int whence)
static ssize_t	plain_fullread (mpg123_handle *fr, unsigned char *buf, ssize_t count)
static off_t	io_seek (struct reader_data *rdat, off_t offset, int whence)
static ssize_t	io_read (struct reader_data *rdat, void *buf, size_t count)
static void	bc_init (struct bufferchain *bc)
static void	bc_reset (struct bufferchain *bc)
static int	bc_append (struct bufferchain *bc, ssize_t size)
static int	bc_add (struct bufferchain *bc, const unsigned char *data, ssize_t size)
static ssize_t	bc_give (struct bufferchain *bc, unsigned char *out, ssize_t size)
static ssize_t	bc_skip (struct bufferchain *bc, ssize_t count)
static ssize_t	bc_seekback (struct bufferchain *bc, ssize_t count)
static void	bc_forget (struct bufferchain *bc)
static ssize_t	plain_read (mpg123_handle *fr, void *buf, size_t count)
static ssize_t	icy_fullread (mpg123_handle *fr, unsigned char *buf, ssize_t count)
static off_t	stream_lseek (mpg123_handle *fr, off_t pos, int whence)
static void	stream_close (mpg123_handle *fr)
static int	stream_seek_frame (mpg123_handle *fr, off_t newframe)
static int	generic_head_read (mpg123_handle *fr, unsigned long *newhead)
static int	generic_head_shift (mpg123_handle *fr, unsigned long *head)
static off_t	stream_skip_bytes (mpg123_handle *fr, off_t len)
static int	stream_back_bytes (mpg123_handle *fr, off_t bytes)
static int	generic_read_frame_body (mpg123_handle *fr, unsigned char *buf, int size)
static off_t	generic_tell (mpg123_handle *fr)
static void	stream_rewind (mpg123_handle *fr)
static struct buffy *	buffy_new (size_t size, size_t minsize)
static void	buffy_del (struct buffy *buf)
static void	buffy_del_chain (struct buffy *buf)
void	bc_prepare (struct bufferchain *bc, size_t pool_size, size_t bufblock)
size_t	bc_fill (struct bufferchain *bc)
void	bc_poolsize (struct bufferchain *bc, size_t pool_size, size_t bufblock)
void	bc_cleanup (struct bufferchain *bc)
static struct buffy *	bc_alloc (struct bufferchain *bc, size_t size)
static void	bc_free (struct bufferchain *bc, struct buffy *buf)
static int	bc_fill_pool (struct bufferchain *bc)
static ssize_t	bc_need_more (struct bufferchain *bc)
static int	feed_init (mpg123_handle *fr)
int	feed_more (mpg123_handle *fr, const unsigned char *in, long count)
static ssize_t	feed_read (mpg123_handle *fr, unsigned char *out, ssize_t count)
static off_t	feed_skip_bytes (mpg123_handle *fr, off_t len)
static int	feed_back_bytes (mpg123_handle *fr, off_t bytes)
static int	feed_seek_frame (mpg123_handle *fr, off_t num)
static void	buffered_forget (mpg123_handle *fr)
off_t	feed_set_pos (mpg123_handle *fr, off_t pos)
static ssize_t	buffered_fullread (mpg123_handle *fr, unsigned char *out, ssize_t count)
static int	bad_init (mpg123_handle *mh) bugger_off static void bad_close(mpg123_handle *mh)
static ssize_t	bad_fullread (mpg123_handle *mh, unsigned char *data, ssize_t count) bugger_off static int bad_head_read(mpg123_handle *mh
static ssize_t unsigned long *newhead static bugger_off int	bad_head_shift (mpg123_handle *mh, unsigned long *head) bugger_off static off_t bad_skip_bytes(mpg123_handle *mh
static ssize_t unsigned long *newhead static bugger_off int off_t len static bugger_off int	bad_read_frame_body (mpg123_handle *mh, unsigned char *data, int size) bugger_off static int bad_back_bytes(mpg123_handle *mh
static ssize_t unsigned long *newhead static bugger_off int off_t len static bugger_off int off_t bytes static bugger_off int	bad_seek_frame (mpg123_handle *mh, off_t num) bugger_off static off_t bad_tell(mpg123_handle *mh) bugger_off static void bad_rewind(mpg123_handle *mh)
void	open_bad (mpg123_handle *mh)
int	open_feed (mpg123_handle *fr)
static int	open_finish (mpg123_handle *fr)
int	open_stream (mpg123_handle *fr, const char *bs_filenam, int fd)
int	open_stream_handle (mpg123_handle *fr, void *iohandle)

Variables
static struct reader	readers []
static struct reader	bad_reader

Macro Definition Documentation

bugger_off

#define bugger_off   { mh->err = MPG123_NO_READER; return MPG123_ERR; }

Definition at line 902 of file readers.c.

O_BINARY

#define O_BINARY   (0)

READER_BUF_ICY_STREAM

#define READER_BUF_ICY_STREAM   4

Definition at line 920 of file readers.c.

READER_BUF_STREAM

#define READER_BUF_STREAM   3

Definition at line 919 of file readers.c.

READER_FEED

#define READER_FEED   2

Definition at line 918 of file readers.c.

READER_ICY_STREAM

#define READER_ICY_STREAM   1

Definition at line 917 of file readers.c.

READER_STREAM

#define READER_STREAM   0

Definition at line 916 of file readers.c.

Function Documentation

bad_fullread()

static ssize_t bad_fullread ( mpg123_handle *  mh, unsigned char *  data, ssize_t  count  )

static

bad_head_shift()

static ssize_t unsigned long *newhead static bugger_off int bad_head_shift ( mpg123_handle *  mh, unsigned long *  head  )

static

bad_init()

static int bad_init ( mpg123_handle *  mh )

static

Definition at line 903 of file readers.c.

                                        {}

bad_read_frame_body()

static ssize_t unsigned long *newhead static bugger_off int off_t len static bugger_off int bad_read_frame_body ( mpg123_handle *  mh, unsigned char *  data, int  size  )

static

bad_seek_frame()

static ssize_t unsigned long *newhead static bugger_off int off_t len static bugger_off int off_t bytes static bugger_off int bad_seek_frame ( mpg123_handle *  mh, off_t  num  )

static

Definition at line 911 of file readers.c.

                                         {}

bc_add()

static int bc_add ( struct bufferchain *  bc, const unsigned char *  data, ssize_t  size  )

static

Definition at line 637 of file readers.c.

{
    int ret = 0;
    ssize_t part = 0;
    debug2("bc_add: adding %"SSIZE_P" bytes at %"OFF_P, (ssize_p)size, (off_p)(bc->fileoff+bc->size));
    if(size >=4) debug4("first bytes: %02x %02x %02x %02x", data[0], data[1], data[2], data[3]);
 
    while(size > 0)
    {
        /* Try to fill up the last buffer block. */
        if(bc->last != NULL && bc->last->size < bc->last->realsize)
        {
            part = bc->last->realsize - bc->last->size;
            if(part > size) part = size;
 
            debug2("bc_add: adding %"SSIZE_P" B to existing block %p", (ssize_p)part, (void*)bc->last);
            memcpy(bc->last->data+bc->last->size, data, part);
            bc->last->size += part;
            size -= part;
            bc->size += part;
            data += part;
        }
 
        /* If there is still data left, put it into a new buffer block. */
        if(size > 0 && (ret = bc_append(bc, size)) != 0)
        break;
    }
 
    return ret;
}

Referenced by buffered_fullread(), and feed_more().

bc_alloc()

static struct buffy * bc_alloc ( struct bufferchain *  bc, size_t  size  )

static

Definition at line 535 of file readers.c.

{
    /* Easy route: Just try the first available buffer.
       Size does not matter, it's only a hint for creation of new buffers. */
    if(bc->pool)
    {
        struct buffy *buf = bc->pool;
        bc->pool = buf->next;
        buf->next = NULL; /* That shall be set to a sensible value later. */
        buf->size = 0;
        --bc->pool_fill;
        debug2("bc_alloc: picked %p from pool (fill now %"SIZE_P")", (void*)buf, (size_p)bc->pool_fill);
        return buf;
    }
    else return buffy_new(size, bc->bufblock);
}

Referenced by bc_append().

bc_append()

static int bc_append ( struct bufferchain *  bc, ssize_t  size  )

static

Definition at line 620 of file readers.c.

{
    struct buffy *newbuf;
    if(size < 1) return -1;
 
    newbuf = bc_alloc(bc, size);
    if(newbuf == NULL) return -2;
 
    if(bc->last != NULL)  bc->last->next = newbuf;
    else if(bc->first == NULL) bc->first = newbuf;
 
    bc->last  = newbuf;
    debug3("bc_append: new last buffer %p with %"SSIZE_P" B (really %"SSIZE_P")", (void*)bc->last, (ssize_p)bc->last->size, (ssize_p)bc->last->realsize);
    return 0;
}

Referenced by bc_add().

bc_cleanup()

void bc_cleanup

(

struct bufferchain *

bc

)

Definition at line 527 of file readers.c.

{
    buffy_del_chain(bc->pool);
    bc->pool = NULL;
    bc->pool_fill = 0;
}

bc_fill()

size_t bc_fill

(

struct bufferchain *

bc

)

Definition at line 516 of file readers.c.

{
    return (size_t)(bc->size - bc->pos);
}

bc_fill_pool()

static int bc_fill_pool ( struct bufferchain *  bc )

static

Definition at line 567 of file readers.c.

{
    /* Remove superfluous ones. */
    while(bc->pool_fill > bc->pool_size)
    {
        /* Lazyness: Just work on the front. */
        struct buffy* buf = bc->pool;
        bc->pool = buf->next;
        buffy_del(buf);
        --bc->pool_fill;
    }
 
    /* Add missing ones. */
    while(bc->pool_fill < bc->pool_size)
    {
        /* Again, just work on the front. */
        struct buffy* buf;
        buf = buffy_new(0, bc->bufblock); /* Use default block size. */
        if(!buf) return -1;
 
        buf->next = bc->pool;
        bc->pool = buf;
        ++bc->pool_fill;
    }
 
    return 0;
}

Referenced by bc_reset(), and feed_init().

bc_forget()

static void bc_forget ( struct bufferchain *  bc )

static

Definition at line 734 of file readers.c.

{
    struct buffy *b = bc->first;
    /* free all buffers that are def'n'tly outdated */
    /* we have buffers until filepos... delete all buffers fully below it */
    if(b) debug2("bc_forget: block %lu pos %lu", (unsigned long)b->size, (unsigned long)bc->pos);
    else debug("forget with nothing there!");
 
    while(b != NULL && bc->pos >= b->size)
    {
        struct buffy *n = b->next; /* != NULL or this is indeed the end and the last cycle anyway */
        if(n == NULL) bc->last = NULL; /* Going to delete the last buffy... */
        bc->fileoff += b->size;
        bc->pos  -= b->size;
        bc->size -= b->size;
 
        debug5("bc_forget: forgot %p with %lu, pos=%li, size=%li, fileoff=%li", (void*)b->data, (long)b->size, (long)bc->pos,  (long)bc->size, (long)bc->fileoff);
 
        bc_free(bc, b);
        b = n;
    }
    bc->first = b;
    bc->firstpos = bc->pos;
}

Referenced by buffered_forget().

bc_free()

static void bc_free ( struct bufferchain *  bc, struct buffy *  buf  )

static

Definition at line 553 of file readers.c.

{
    if(!buf) return;
 
    if(bc->pool_fill < bc->pool_size)
    {
        buf->next = bc->pool;
        bc->pool = buf;
        ++bc->pool_fill;
    }
    else buffy_del(buf);
}

Referenced by bc_forget(), and bc_reset().

bc_give()

static ssize_t bc_give ( struct bufferchain *  bc, unsigned char *  out, ssize_t  size  )

static

Definition at line 678 of file readers.c.

{
    struct buffy *b = bc->first;
    ssize_t gotcount = 0;
    ssize_t offset = 0;
    if(bc->size - bc->pos < size) return bc_need_more(bc);
 
    /* find the current buffer */
    while(b != NULL && (offset + b->size) <= bc->pos)
    {
        offset += b->size;
        b = b->next;
    }
    /* now start copying from there */
    while(gotcount < size && (b != NULL))
    {
        ssize_t loff = bc->pos - offset;
        ssize_t chunk = size - gotcount; /* amount of bytes to get from here... */
        if(chunk > b->size - loff) chunk = b->size - loff;
 
#ifdef EXTRA_DEBUG
        debug3("copying %liB from %p+%li",(long)chunk, b->data, (long)loff);
#endif
 
        memcpy(out+gotcount, b->data+loff, chunk);
        gotcount += chunk;
        bc->pos  += chunk;
        offset += b->size;
        b = b->next;
    }
#ifdef EXTRA_DEBUG
    debug2("got %li bytes, pos advanced to %li", (long)gotcount, (long)bc->pos);
#endif
 
    return gotcount;
}

Referenced by buffered_fullread(), and feed_read().

bc_init()

static void bc_init ( struct bufferchain *  bc )

static

Definition at line 596 of file readers.c.

{
    bc->first = NULL;
    bc->last  = bc->first;
    bc->size  = 0;
    bc->pos   = 0;
    bc->firstpos = 0;
    bc->fileoff  = 0;
}

Referenced by bc_prepare(), bc_reset(), default_init(), feed_init(), and open_bad().

bc_need_more()

static ssize_t bc_need_more ( struct bufferchain *  bc )

static

Definition at line 669 of file readers.c.

{
    debug3("hit end, back to beginning (%li - %li < %li)", (long)bc->size, (long)bc->pos, (long)bc->size);
    /* go back to firstpos, undo the previous reads */
    bc->pos = bc->firstpos;
    return READER_MORE;
}

Referenced by bc_give(), and bc_skip().

bc_poolsize()

void bc_poolsize	(	struct bufferchain *	bc,
		size_t	pool_size,
		size_t	bufblock
	)

Definition at line 521 of file readers.c.

{
    bc->pool_size = pool_size;
    bc->bufblock = bufblock;
}

bc_prepare()

void bc_prepare	(	struct bufferchain *	bc,
		size_t	pool_size,
		size_t	bufblock
	)

Definition at line 508 of file readers.c.

{
    bc_poolsize(bc, pool_size, bufblock);
    bc->pool = NULL;
    bc->pool_fill = 0;
    bc_init(bc); /* Ensure that members are zeroed for read-only use. */
}

bc_reset()

static void bc_reset ( struct bufferchain *  bc )

static

Definition at line 606 of file readers.c.

{
    /* Free current chain, possibly stuffing back into the pool. */
    while(bc->first)
    {
        struct buffy* buf = bc->first;
        bc->first = buf->next;
        bc_free(bc, buf);
    }
    bc_fill_pool(bc); /* Ignoring an error here... */
    bc_init(bc);
}

Referenced by feed_set_pos(), and stream_close().

bc_seekback()

static ssize_t bc_seekback ( struct bufferchain *  bc, ssize_t  count  )

static

Definition at line 727 of file readers.c.

{
    if(count >= 0 && count <= bc->pos) return bc->pos -= count;
    else return READER_ERROR;
}

Referenced by feed_back_bytes().

bc_skip()

static ssize_t bc_skip ( struct bufferchain *  bc, ssize_t  count  )

static

Definition at line 717 of file readers.c.

{
    if(count >= 0)
    {
        if(bc->size - bc->pos < count) return bc_need_more(bc);
        else return bc->pos += count;
    }
    else return READER_ERROR;
}

Referenced by feed_skip_bytes().

buffered_forget()

static void buffered_forget ( mpg123_handle *  fr )

static

Definition at line 816 of file readers.c.

{
    bc_forget(&fr->rdat.buffer);
    fr->rdat.filepos = fr->rdat.buffer.fileoff + fr->rdat.buffer.pos;
}

buffered_fullread()

static ssize_t buffered_fullread ( mpg123_handle *  fr, unsigned char *  out, ssize_t  count  )

static

Definition at line 842 of file readers.c.

{
    struct bufferchain *bc = &fr->rdat.buffer;
    ssize_t gotcount;
    if(VERBOSE3)
        mdebug("buffered_fullread: want %zd", count);
    if(bc->size - bc->pos < count)
    { /* Add more stuff to buffer. If hitting end of file, adjust count. */
        unsigned char readbuf[4096];
        ssize_t need = count - (bc->size-bc->pos);
        while(need>0)
        {
            int ret;
            ssize_t got = fr->rdat.fullread(fr, readbuf, sizeof(readbuf));
            if(got < 0)
            {
                if(NOQUIET) error("buffer reading");
                return READER_ERROR;
            }
 
            if(VERBOSE3) debug1("buffered_fullread: buffering %li bytes from stream (if > 0)", (long)got);
            if(got > 0 && (ret=bc_add(bc, readbuf, got)) != 0)
            {
                if(NOQUIET) error1("unable to add to chain, return: %i", ret);
                return READER_ERROR;
            }
 
            need -= got; /* May underflow here... */
            if(got < sizeof(readbuf)) /* That naturally catches got == 0, too. */
            {
                if(VERBOSE3) fprintf(stderr, "Note: Input data end.\n");
                break; /* End. */
            }
        }
        if(bc->size - bc->pos < count)
        count = bc->size - bc->pos; /* We want only what we got. */
    }
    gotcount = bc_give(bc, out, count);
    if(VERBOSE3)
        mdebug("buffered_fullread: got %zd", gotcount);
    if(gotcount != count){ if(NOQUIET) error("gotcount != count"); return READER_ERROR; }
    else return gotcount;
}

buffy_del()

static void buffy_del ( struct buffy *  buf )

static

Definition at line 488 of file readers.c.

{
    if(buf)
    {
        free(buf->data);
        free(buf);
    }
}

Referenced by bc_fill_pool(), bc_free(), and buffy_del_chain().

buffy_del_chain()

static void buffy_del_chain ( struct buffy *  buf )

static

Definition at line 498 of file readers.c.

{
    while(buf)
    {
        struct buffy* next = buf->next;
        buffy_del(buf);
        buf = next;
    }
}

Referenced by bc_cleanup().

buffy_new()

static struct buffy * buffy_new ( size_t  size, size_t  minsize  )

static

Definition at line 470 of file readers.c.

{
    struct buffy *newbuf;
    newbuf = malloc(sizeof(struct buffy));
    if(newbuf == NULL) return NULL;
 
    newbuf->realsize = size > minsize ? size : minsize;
    newbuf->data = malloc(newbuf->realsize);
    if(newbuf->data == NULL)
    {
        free(newbuf);
        return NULL;
    }
    newbuf->size = 0;
    newbuf->next = NULL;
    return newbuf;
}

Referenced by bc_alloc(), and bc_fill_pool().

default_init()

static int default_init ( mpg123_handle *  fr )

static

Definition at line 1036 of file readers.c.

{
#ifdef TIMEOUT_READ
    if(fr->p.timeout > 0)
    {
        int flags;
        if(fr->rdat.r_read != NULL)
        {
            if(NOQUIET)
                error( "Timeout reading does not work with user-provided"
                    " read function. Implement it yourself!" );
            return -1;
        }
        flags = fcntl(fr->rdat.filept, F_GETFL);
        flags |= O_NONBLOCK;
        fcntl(fr->rdat.filept, F_SETFL, flags);
        fr->rdat.fdread = timeout_read;
        fr->rdat.timeout_sec = fr->p.timeout;
        fr->rdat.flags |= READER_NONBLOCK;
    }
    else
#endif
    fr->rdat.fdread = plain_read;
 
    fr->rdat.read  = fr->rdat.r_read  != NULL ? fr->rdat.r_read  : posix_read;
    fr->rdat.lseek = fr->rdat.r_lseek != NULL ? fr->rdat.r_lseek : posix_lseek;
#ifndef NO_ICY
    /* ICY streams of any sort shall not be seekable. */
    if(fr->p.icy_interval > 0) fr->rdat.lseek = nix_lseek;
#endif
 
    fr->rdat.filelen = fr->p.flags & MPG123_NO_PEEK_END ? -1 : get_fileinfo(fr);
    fr->rdat.filepos = 0;
    if(fr->p.flags & MPG123_FORCE_SEEKABLE)
        fr->rdat.flags |= READER_SEEKABLE;
    /*
        Don't enable seeking on ICY streams, just plain normal files.
        This check is necessary since the client can enforce ICY parsing on files that would otherwise be seekable.
        It is a task for the future to make the ICY parsing safe with seeks ... or not.
    */
    if(fr->rdat.filelen >= 0)
    {
        debug("seekable stream");
        fr->rdat.flags |= READER_SEEKABLE;
        if(!strncmp((char*)fr->id3buf,"TAG",3))
        {
            fr->rdat.flags |= READER_ID3TAG;
            fr->metaflags  |= MPG123_NEW_ID3;
        }
    }
    /* Switch reader to a buffered one, if allowed. */
    else if(fr->p.flags & MPG123_SEEKBUFFER)
    {
#ifdef NO_FEEDER
        if(NOQUIET)
            error("Buffered readers not supported in this build.");
        fr->err = MPG123_MISSING_FEATURE;
        return -1;
#else
        if     (fr->rd == &readers[READER_STREAM])
        {
            debug("switching to buffered stream reader");
            fr->rd = &readers[READER_BUF_STREAM];
            fr->rdat.fullread = plain_fullread;
        }
#ifndef NO_ICY
        else if(fr->rd == &readers[READER_ICY_STREAM])
        {
            debug("switching to buffered ICY stream reader");
            fr->rd = &readers[READER_BUF_ICY_STREAM];
            fr->rdat.fullread = icy_fullread;
        }
#endif
        else
        {
            if(NOQUIET) error("mpg123 Programmer's fault: invalid reader");
            return -1;
        }
        bc_init(&fr->rdat.buffer);
        fr->rdat.filelen = 0; /* We carry the offset, but never know how big the stream is. */
        fr->rdat.flags |= READER_BUFFERED;
#endif /* NO_ICY */
    }
    return 0;
}

feed_back_bytes()

static int feed_back_bytes ( mpg123_handle *  fr, off_t  bytes  )

static

Definition at line 805 of file readers.c.

{
    if(bytes >=0)
    return bc_seekback(&fr->rdat.buffer, (ssize_t)bytes) >= 0 ? 0 : READER_ERROR;
    else
    return feed_skip_bytes(fr, -bytes) >= 0 ? 0 : READER_ERROR;
}

feed_init()

static int feed_init ( mpg123_handle *  fr )

static

Definition at line 761 of file readers.c.

{
    bc_init(&fr->rdat.buffer);
    bc_fill_pool(&fr->rdat.buffer);
    fr->rdat.filelen = 0;
    fr->rdat.filepos = 0;
    fr->rdat.flags |= READER_BUFFERED;
    return 0;
}

feed_more()

int feed_more	(	mpg123_handle *	fr,
		const unsigned char *	in,
		long	count
	)

Definition at line 772 of file readers.c.

{
    int ret = 0;
    if(VERBOSE3) debug("feed_more");
    if((ret = bc_add(&fr->rdat.buffer, in, count)) != 0)
    {
        ret = READER_ERROR;
        if(NOQUIET) error1("Failed to add buffer, return: %i", ret);
    }
    else /* Not talking about filelen... that stays at 0. */
 
    if(VERBOSE3) debug3("feed_more: %p %luB bufsize=%lu", fr->rdat.buffer.last->data,
        (unsigned long)fr->rdat.buffer.last->size, (unsigned long)fr->rdat.buffer.size);
    return ret;
}

feed_read()

static ssize_t feed_read ( mpg123_handle *  fr, unsigned char *  out, ssize_t  count  )

static

Definition at line 788 of file readers.c.

{
    ssize_t gotcount = bc_give(&fr->rdat.buffer, out, count);
    if(gotcount >= 0 && gotcount != count) return READER_ERROR;
    else return gotcount;
}

feed_seek_frame()

static int feed_seek_frame ( mpg123_handle *  fr, off_t  num  )

static

Definition at line 813 of file readers.c.

{ return READER_ERROR; }

feed_set_pos()

off_t feed_set_pos	(	mpg123_handle *	fr,
		off_t	pos
	)

Definition at line 822 of file readers.c.

{
    struct bufferchain *bc = &fr->rdat.buffer;
    if(pos >= bc->fileoff && pos-bc->fileoff < bc->size)
    { /* We have the position! */
        bc->pos = (ssize_t)(pos - bc->fileoff);
        debug1("feed_set_pos inside, next feed from %"OFF_P, (off_p)(bc->fileoff+bc->size));
        return bc->fileoff+bc->size; /* Next input after end of buffer... */
    }
    else
    { /* I expect to get the specific position on next feed. Forget what I have now. */
        bc_reset(bc);
        bc->fileoff = pos;
        debug1("feed_set_pos outside, buffer reset, next feed from %"OFF_P, (off_p)pos);
        return pos; /* Next input from exactly that position. */
    }
}

feed_skip_bytes()

static off_t feed_skip_bytes ( mpg123_handle *  fr, off_t  len  )

static

Definition at line 796 of file readers.c.

{
    /* This is either the new buffer offset or some negative error value. */
    off_t res = bc_skip(&fr->rdat.buffer, (ssize_t)len);
    if(res < 0) return res;
 
    return fr->rdat.buffer.fileoff+res;
}

Referenced by feed_back_bytes().

generic_head_read()

static int generic_head_read ( mpg123_handle *  fr, unsigned long *  newhead  )

static

Definition at line 303 of file readers.c.

{
    unsigned char hbuf[4];
    int ret = fr->rd->fullread(fr,hbuf,4);
    if(ret == READER_MORE) return ret;
    if(ret != 4) return FALSE;
 
    *newhead = ((unsigned long) hbuf[0] << 24) |
               ((unsigned long) hbuf[1] << 16) |
               ((unsigned long) hbuf[2] << 8)  |
                (unsigned long) hbuf[3];
 
    return TRUE;
}

generic_head_shift()

static int generic_head_shift ( mpg123_handle *  fr, unsigned long *  head  )

static

Definition at line 319 of file readers.c.

{
    unsigned char hbuf;
    int ret = fr->rd->fullread(fr,&hbuf,1);
    if(ret == READER_MORE) return ret;
    if(ret != 1) return FALSE;
 
    *head <<= 8;
    *head |= hbuf;
    *head &= 0xffffffff;
    return TRUE;
}

generic_read_frame_body()

static int generic_read_frame_body ( mpg123_handle *  fr, unsigned char *  buf, int  size  )

static

Definition at line 388 of file readers.c.

{
    long l;
    l=fr->rd->fullread(fr,buf,size);
    return (l >= 0 && l<size) ? READER_ERROR : l;
}

generic_tell()

static off_t generic_tell ( mpg123_handle *  fr )

static

Definition at line 395 of file readers.c.

{
#ifndef NO_FEEDER
    if(fr->rdat.flags & READER_BUFFERED)
    fr->rdat.filepos = fr->rdat.buffer.fileoff+fr->rdat.buffer.pos;
#endif
 
    return fr->rdat.filepos;
}

get_fileinfo()

static off_t get_fileinfo ( mpg123_handle *  fr )

static

Definition at line 430 of file readers.c.

{
    off_t len;
 
    if((len=io_seek(&fr->rdat,0,SEEK_END)) < 0)
    {
        debug("cannot seek to end");
        return -1;
    } else if(len >= 128)
    {
        if(io_seek(&fr->rdat,-128,SEEK_END) < 0)
        {
            debug("cannot seek to END-128");
            return -1;
        }
        if(fr->rd->fullread(fr,(unsigned char *)fr->id3buf,128) != 128)
        {
            debug("cannot read ID3v1?!");
            return -1;
        }
        if(!strncmp((char*)fr->id3buf,"TAG",3)) len -= 128;
    } else
    {
        debug("stream too short for ID3");
    }
 
    if(io_seek(&fr->rdat,0,SEEK_SET) < 0)
    {
        debug("cannot seek back");
        return -1;
    }
 
    debug1("returning length: %"OFF_P, (off_p)len);
    return len;
}

Referenced by default_init().

icy_fullread()

static ssize_t icy_fullread ( mpg123_handle *  fr, unsigned char *  buf, ssize_t  count  )

static

Definition at line 92 of file readers.c.

{
    ssize_t ret,cnt;
    cnt = 0;
    if(fr->rdat.flags & READER_SEEKABLE)
    {
        if(NOQUIET) error("mpg123 programmer error: I don't do ICY on seekable streams.");
        return -1;
    }
    /*
        There used to be a check for expected file end here (length value or ID3 flag).
        This is not needed:
        1. EOF is indicated by fdread returning zero bytes anyway.
        2. We get false positives of EOF for either files that grew or
        3. ... files that have ID3v1 tags in between (stream with intro).
    */
 
    while(cnt < count)
    {
        /* all icy code is inside this if block, everything else is the plain fullread we know */
        /* debug1("read: %li left", (long) count-cnt); */
        if(fr->icy.next < count-cnt)
        {
            unsigned char temp_buff;
            size_t meta_size;
            ssize_t cut_pos;
 
            /* we are near icy-metaint boundary, read up to the boundary */
            if(fr->icy.next > 0)
            {
                cut_pos = fr->icy.next;
                ret = fr->rdat.fdread(fr,buf+cnt,cut_pos);
                if(ret < 1)
                {
                    if(ret == 0) break; /* Just EOF. */
                    if(NOQUIET) error("icy boundary read");
 
                    return READER_ERROR;
                }
 
                if(!(fr->rdat.flags & READER_BUFFERED)) fr->rdat.filepos += ret;
                cnt += ret;
                fr->icy.next -= ret;
                if(fr->icy.next > 0)
                {
                    debug1("another try... still %li left", (long)fr->icy.next);
                    continue;
                }
            }
            /* now off to read icy data */
 
            /* one byte icy-meta size (must be multiplied by 16 to get icy-meta length) */
 
            ret = fr->rdat.fdread(fr,&temp_buff,1); /* Getting one single byte hast to suceed. */
            if(ret < 0){ if(NOQUIET) error("reading icy size"); return READER_ERROR; }
            if(ret == 0) break;
 
            debug2("got meta-size byte: %u, at filepos %li", temp_buff, (long)fr->rdat.filepos );
            if(!(fr->rdat.flags & READER_BUFFERED)) fr->rdat.filepos += ret; /* 1... */
 
            if((meta_size = ((size_t) temp_buff) * 16))
            {
                /* we have got some metadata */
                char *meta_buff;
                /* TODO: Get rid of this malloc ... perhaps hooking into the reader buffer pool? */
                meta_buff = malloc(meta_size+1);
                if(meta_buff != NULL)
                {
                    ssize_t left = meta_size;
                    while(left > 0)
                    {
                        ret = fr->rdat.fdread(fr,meta_buff+meta_size-left,left);
                        /* 0 is error here, too... there _must_ be the ICY data, the server promised! */
                        if(ret < 1){ if(NOQUIET) error("reading icy-meta"); return READER_ERROR; }
                        left -= ret;
                    }
                    meta_buff[meta_size] = 0; /* string paranoia */
                    if(!(fr->rdat.flags & READER_BUFFERED)) fr->rdat.filepos += ret;
 
                    if(fr->icy.data) free(fr->icy.data);
                    fr->icy.data = meta_buff;
                    fr->metaflags |= MPG123_NEW_ICY;
                    debug2("icy-meta: %s size: %d bytes", fr->icy.data, (int)meta_size);
                }
                else
                {
                    if(NOQUIET) error1("cannot allocate memory for meta_buff (%lu bytes) ... trying to skip the metadata!", (unsigned long)meta_size);
                    fr->rd->skip_bytes(fr, meta_size);
                }
            }
            fr->icy.next = fr->icy.interval;
        }
        else
        {
            ret = plain_fullread(fr, buf+cnt, count-cnt);
            if(ret < 0){ if(NOQUIET) error1("reading the rest of %li", (long)(count-cnt)); return READER_ERROR; }
            if(ret == 0) break;
 
            cnt += ret;
            fr->icy.next -= ret;
        }
    }
    /* debug1("done reading, got %li", (long)cnt); */
    return cnt;
}

Referenced by default_init().

io_read()

static ssize_t io_read ( struct reader_data *  rdat, void *  buf, size_t  count  )

static

Definition at line 1245 of file readers.c.

{
    if(rdat->flags & READER_HANDLEIO)
    {
        if(rdat->r_read_handle != NULL)
        {
            return rdat->r_read_handle(rdat->iohandle, buf, count);
        }
        else return -1;
    }
    else
    return rdat->read(rdat->filept, buf, count);
}

Referenced by plain_read().

io_seek()

static off_t io_seek ( struct reader_data *  rdat, off_t  offset, int  whence  )

static

Definition at line 1231 of file readers.c.

{
    if(rdat->flags & READER_HANDLEIO)
    {
        if(rdat->r_lseek_handle != NULL)
        {
            return rdat->r_lseek_handle(rdat->iohandle, offset, whence);
        }
        else return -1;
    }
    else
    return rdat->lseek(rdat->filept, offset, whence);
}

Referenced by get_fileinfo(), and stream_lseek().

nix_lseek()

static off_t nix_lseek ( int  fd, off_t  offset, int  whence  )

static

Definition at line 34 of file readers.c.

{ return -1; }

Referenced by default_init().

open_bad()

void open_bad

(

mpg123_handle *

mh

)

Definition at line 1123 of file readers.c.

{
    debug("open_bad");
#ifndef NO_ICY
    clear_icy(&mh->icy);
#endif
    mh->rd = &bad_reader;
    mh->rdat.flags = 0;
#ifndef NO_FEEDER
    bc_init(&mh->rdat.buffer);
#endif
    mh->rdat.filelen = -1;
}

open_feed()

int open_feed

(

mpg123_handle *

fr

)

Definition at line 1137 of file readers.c.

{
    debug("feed reader");
#ifdef NO_FEEDER
    if(NOQUIET)
        error("Buffered readers not supported in this build.");
    fr->err = MPG123_MISSING_FEATURE;
    return -1;
#else
#ifndef NO_ICY
    if(fr->p.icy_interval > 0)
    {
        if(NOQUIET) error("Feed reader cannot do ICY parsing!");
 
        return -1;
    }
    clear_icy(&fr->icy);
#endif
    fr->rd = &readers[READER_FEED];
    fr->rdat.flags = 0;
    if(fr->rd->init(fr) < 0) return -1;
 
    debug("feed reader init successful");
    return 0;
#endif /* NO_FEEDER */
}

open_finish()

static int open_finish ( mpg123_handle *  fr )

static

Definition at line 1165 of file readers.c.

{
#ifndef NO_ICY
    if(fr->p.icy_interval > 0)
    {
        debug("ICY reader");
        fr->icy.interval = fr->p.icy_interval;
        fr->icy.next = fr->icy.interval;
        fr->rd = &readers[READER_ICY_STREAM];
    }
    else
#endif
    {
        fr->rd = &readers[READER_STREAM];
        debug("stream reader");
    }
 
    if(fr->rd->init(fr) < 0) return -1;
 
    return MPG123_OK;
}

Referenced by open_stream(), and open_stream_handle().

open_stream()

int open_stream	(	mpg123_handle *	fr,
		const char *	bs_filenam,
		int	fd
	)

Definition at line 1187 of file readers.c.

{
    int filept_opened = 1;
    int filept; /* descriptor of opened file/stream */
 
    clear_icy(&fr->icy); /* can be done inside frame_clear ...? */
 
    if(!bs_filenam) /* no file to open, got a descriptor (stdin) */
    {
        filept = fd;
        filept_opened = 0; /* and don't try to close it... */
    }
    #ifndef O_BINARY
    #define O_BINARY (0)
    #endif
    else if((filept = compat_open(bs_filenam, O_RDONLY|O_BINARY)) < 0) /* a plain old file to open... */
    {
        if(NOQUIET) error2("Cannot open file %s: %s", bs_filenam, strerror(errno));
        fr->err = MPG123_BAD_FILE;
        return MPG123_ERR; /* error... */
    }
 
    /* now we have something behind filept and can init the reader */
    fr->rdat.filelen = -1;
    fr->rdat.filept  = filept;
    fr->rdat.flags = 0;
    if(filept_opened)   fr->rdat.flags |= READER_FD_OPENED;
 
    return open_finish(fr);
}

open_stream_handle()

int open_stream_handle	(	mpg123_handle *	fr,
		void *	iohandle
	)

Definition at line 1218 of file readers.c.

{
    clear_icy(&fr->icy); /* can be done inside frame_clear ...? */
    fr->rdat.filelen = -1;
    fr->rdat.filept  = -1;
    fr->rdat.iohandle = iohandle;
    fr->rdat.flags = 0;
    fr->rdat.flags |= READER_HANDLEIO;
 
    return open_finish(fr);
}

plain_fullread()

static ssize_t plain_fullread ( mpg123_handle *  fr, unsigned char *  buf, ssize_t  count  )

static

Definition at line 202 of file readers.c.

{
    ssize_t ret,cnt=0;
 
#ifdef EXTRA_DEBUG
    debug1("plain fullread of %"SSIZE_P, (size_p)count);
#endif
    /*
        There used to be a check for expected file end here (length value or ID3 flag).
        This is not needed:
        1. EOF is indicated by fdread returning zero bytes anyway.
        2. We get false positives of EOF for either files that grew or
        3. ... files that have ID3v1 tags in between (stream with intro).
    */
    while(cnt < count)
    {
        ret = fr->rdat.fdread(fr,buf+cnt,count-cnt);
        if(ret < 0) return READER_ERROR;
        if(ret == 0) break;
        if(!(fr->rdat.flags & READER_BUFFERED)) fr->rdat.filepos += ret;
        cnt += ret;
    }
    return cnt;
}

Referenced by default_init(), and icy_fullread().

plain_read()

static ssize_t plain_read ( mpg123_handle *  fr, void *  buf, size_t  count  )

static

Definition at line 58 of file readers.c.

{
    ssize_t ret = io_read(&fr->rdat, buf, count);
    if(VERBOSE3) debug2("read %li bytes of %li", (long)ret, (long)count);
    return ret;
}

Referenced by default_init().

posix_lseek()

static off_t posix_lseek ( int  fd, off_t  offset, int  whence  )

static

Definition at line 33 of file readers.c.

{ return lseek(fd, offset, whence); }

Referenced by default_init().

posix_read()

static ssize_t posix_read ( int  fd, void *  buf, size_t  count  )

static

Definition at line 32 of file readers.c.

{ return read(fd, buf, count); }

Referenced by default_init().

stream_back_bytes()

static int stream_back_bytes ( mpg123_handle *  fr, off_t  bytes  )

static

Definition at line 377 of file readers.c.

{
    off_t want = fr->rd->tell(fr)-bytes;
    if(want < 0) return READER_ERROR;
    if(stream_skip_bytes(fr,-bytes) != want) return READER_ERROR;
 
    return 0;
}

stream_close()

static void stream_close ( mpg123_handle *  fr )

static

Definition at line 240 of file readers.c.

{
    if(fr->rdat.flags & READER_FD_OPENED) compat_close(fr->rdat.filept);
 
    fr->rdat.filept = 0;
 
#ifndef NO_FEEDER
    if(fr->rdat.flags & READER_BUFFERED)  bc_reset(&fr->rdat.buffer);
#endif
    if(fr->rdat.flags & READER_HANDLEIO)
    {
        if(fr->rdat.cleanup_handle != NULL) fr->rdat.cleanup_handle(fr->rdat.iohandle);
 
        fr->rdat.iohandle = NULL;
    }
}

stream_lseek()

static off_t stream_lseek ( mpg123_handle *  fr, off_t  pos, int  whence  )

static

Definition at line 227 of file readers.c.

{
    off_t ret;
    ret = io_seek(&fr->rdat, pos, whence);
    if (ret >= 0)   fr->rdat.filepos = ret;
    else
    {
        fr->err = MPG123_LSEEK_FAILED;
        ret = READER_ERROR; /* not the original value */
    }
    return ret;
}

Referenced by stream_rewind(), and stream_skip_bytes().

stream_rewind()

static void stream_rewind ( mpg123_handle *  fr )

static

Definition at line 406 of file readers.c.

{
    if(fr->rdat.flags & READER_SEEKABLE)
    {
        fr->rdat.filepos = stream_lseek(fr,0,SEEK_SET);
#ifndef NO_FEEDER
        fr->rdat.buffer.fileoff = fr->rdat.filepos;
#endif
    }
#ifndef NO_FEEDER
    if(fr->rdat.flags & READER_BUFFERED)
    {
        fr->rdat.buffer.pos      = 0;
        fr->rdat.buffer.firstpos = 0;
        fr->rdat.filepos = fr->rdat.buffer.fileoff;
    }
#endif
}

stream_seek_frame()

static int stream_seek_frame ( mpg123_handle *  fr, off_t  newframe  )

static

Definition at line 257 of file readers.c.

{
    debug2("seek_frame to %"OFF_P" (from %"OFF_P")", (off_p)newframe, (off_p)fr->num);
    /* Seekable streams can go backwards and jump forwards.
       Non-seekable streams still can go forward, just not jump. */
    if((fr->rdat.flags & READER_SEEKABLE) || (newframe >= fr->num))
    {
        off_t preframe; /* a leading frame we jump to */
        off_t seek_to;  /* the byte offset we want to reach */
        off_t to_skip;  /* bytes to skip to get there (can be negative) */
        /*
            now seek to nearest leading index position and read from there until newframe is reached.
            We use skip_bytes, which handles seekable and non-seekable streams
            (the latter only for positive offset, which we ensured before entering here).
        */
        seek_to = frame_index_find(fr, newframe, &preframe);
        /* No need to seek to index position if we are closer already.
           But I am picky about fr->num == newframe, play safe by reading the frame again.
           If you think that's stupid, don't call a seek to the current frame. */
        if(fr->num >= newframe || fr->num < preframe)
        {
            to_skip = seek_to - fr->rd->tell(fr);
            if(fr->rd->skip_bytes(fr, to_skip) != seek_to)
            return READER_ERROR;
 
            debug2("going to %lu; just got %lu", (long unsigned)newframe, (long unsigned)preframe);
            fr->num = preframe-1; /* Watch out! I am going to read preframe... fr->num should indicate the frame before! */
        }
        while(fr->num < newframe)
        {
            /* try to be non-fatal now... frameNum only gets advanced on success anyway */
            if(!read_frame(fr)) break;
        }
        /* Now the wanted frame should be ready for decoding. */
        debug1("arrived at %lu", (long unsigned)fr->num);
 
        return MPG123_OK;
    }
    else
    {
        fr->err = MPG123_NO_SEEK;
        return READER_ERROR; /* invalid, no seek happened */
    }
}

stream_skip_bytes()

static off_t stream_skip_bytes ( mpg123_handle *  fr, off_t  len  )

static

Definition at line 333 of file readers.c.

{
    if(fr->rdat.flags & READER_SEEKABLE)
    {
        off_t ret = stream_lseek(fr, len, SEEK_CUR);
        return (ret < 0) ? READER_ERROR : ret;
    }
    else if(len >= 0)
    {
        unsigned char buf[1024]; /* ThOr: Compaq cxx complained and it makes sense to me... or should one do a cast? What for? */
        ssize_t ret;
        while (len > 0)
        {
            ssize_t num = len < (off_t)sizeof(buf) ? (ssize_t)len : (ssize_t)sizeof(buf);
            ret = fr->rd->fullread(fr, buf, num);
            if (ret < 0) return ret;
            else if(ret == 0) break; /* EOF... an error? interface defined to tell the actual position... */
            len -= ret;
        }
        return fr->rd->tell(fr);
    }
#ifndef NO_FEEDER
    else if(fr->rdat.flags & READER_BUFFERED)
    { /* Perhaps we _can_ go a bit back. */
        if(fr->rdat.buffer.pos >= -len)
        {
            fr->rdat.buffer.pos += len;
            return fr->rd->tell(fr);
        }
        else
        {
            fr->err = MPG123_NO_SEEK;
            return READER_ERROR;
        }
    }
#endif
    else
    {
        fr->err = MPG123_NO_SEEK;
        return READER_ERROR;
    }
}

Referenced by stream_back_bytes().

Variable Documentation

bad_reader

struct reader bad_reader

static

Initial value:

=
{
    bad_init,
    bad_close,
    bad_fullread,
    bad_head_read,
    bad_head_shift,
    bad_skip_bytes,
    bad_read_frame_body,
    bad_back_bytes,
    bad_seek_frame,
    bad_tell,
    bad_rewind,
    NULL
}

Definition at line 1020 of file readers.c.

Referenced by open_bad().

readers

struct reader readers[]

static

Definition at line 921 of file readers.c.

Referenced by default_init(), open_feed(), open_finish(), SCardListReadersA(), and SCardListReadersW().