lfs_wrap.c File Reference

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

Include dependency graph for lfs_wrap.c:

Go to the source code of this file.

Classes
struct	wrap_data

Macros
#define	IO_FD   1 /* Wrapping over callbacks operation on integer file descriptor. */
#define	IO_HANDLE   2 /* Wrapping over custom handle callbacks. */
#define	O_BINARY   0

Functions
static void	wrap_io_cleanup (void *handle)
static void	wrap_destroy (void *handle)
static struct wrap_data *	wrap_get (mpg123_handle *mh)
int attribute_align_arg	mpg123_decode_frame (mpg123_handle *mh, long *num, unsigned char **audio, size_t *bytes)
int attribute_align_arg	mpg123_framebyframe_decode (mpg123_handle *mh, long *num, unsigned char **audio, size_t *bytes)
long attribute_align_arg	mpg123_framepos (mpg123_handle *mh)
long attribute_align_arg	mpg123_tell (mpg123_handle *mh)
long attribute_align_arg	mpg123_tellframe (mpg123_handle *mh)
long attribute_align_arg	mpg123_tell_stream (mpg123_handle *mh)
long attribute_align_arg	mpg123_seek (mpg123_handle *mh, long sampleoff, int whence)
long attribute_align_arg	mpg123_feedseek (mpg123_handle *mh, long sampleoff, int whence, long *input_offset)
long attribute_align_arg	mpg123_seek_frame (mpg123_handle *mh, long frameoff, int whence)
long attribute_align_arg	mpg123_timeframe (mpg123_handle *mh, double sec)
int attribute_align_arg	mpg123_index (mpg123_handle *mh, long **offsets, long *step, size_t *fill)
int attribute_align_arg	mpg123_set_index (mpg123_handle *mh, long *offsets, long step, size_t fill)
int attribute_align_arg	mpg123_position (mpg123_handle *mh, long frame_offset, long buffered_bytes, long *current_frame, long *frames_left, double *current_seconds, double *seconds_left)
long attribute_align_arg	mpg123_framelength (mpg123_handle *mh)
long attribute_align_arg	mpg123_length (mpg123_handle *mh)
int attribute_align_arg	mpg123_set_filesize (mpg123_handle *mh, long size)
ssize_t	wrap_read (void *handle, void *buf, size_t count)
off_t	wrap_lseek (void *handle, off_t offset, int whence)
static ssize_t	fallback_read (int fd, void *buf, size_t count)
static long	fallback_lseek (int fd, long offset, int whence)
int attribute_align_arg	mpg123_replace_reader (mpg123_handle *mh, ssize_t(*r_read)(int, void *, size_t), long(*r_lseek)(int, long, int))
int attribute_align_arg	mpg123_replace_reader_handle (mpg123_handle *mh, ssize_t(*r_read)(void *, void *, size_t), long(*r_lseek)(void *, long, int), void(*cleanup)(void *))
int attribute_align_arg	mpg123_open (mpg123_handle *mh, const char *path)
int attribute_align_arg	mpg123_open_fixed (mpg123_handle *mh, const char *path, int channels, int encoding)
int attribute_align_arg	mpg123_open_fd (mpg123_handle *mh, int fd)
int attribute_align_arg	mpg123_open_handle (mpg123_handle *mh, void *handle)

Macro Definition Documentation

IO_FD

#define IO_FD   1 /* Wrapping over callbacks operation on integer file descriptor. */

Definition at line 72 of file lfs_wrap.c.

IO_HANDLE

#define IO_HANDLE   2 /* Wrapping over custom handle callbacks. */

Definition at line 73 of file lfs_wrap.c.

O_BINARY

#define O_BINARY   0

Definition at line 527 of file lfs_wrap.c.

Function Documentation

fallback_lseek()

static long fallback_lseek ( int  fd, long  offset, int  whence  )

static

Definition at line 584 of file lfs_wrap.c.

{
    /* Since the offset is long int already, the returned value really should fit into a long... but whatever. */
    long newpos_long;
    off_t newpos;
    newpos = lseek(fd, offset, whence);
    newpos_long = newpos;
    if(newpos_long == newpos)
    return newpos_long;
    else
    {
        errno = EOVERFLOW;
        return -1;
    }
}

Referenced by mpg123_replace_reader().

fallback_read()

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

static

Definition at line 579 of file lfs_wrap.c.

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

Referenced by mpg123_replace_reader().

wrap_destroy()

static void wrap_destroy ( void *  handle )

static

Definition at line 115 of file lfs_wrap.c.

{
    struct wrap_data *wh = handle;
    wrap_io_cleanup(handle);
    if(wh->indextable != NULL)
    free(wh->indextable);
 
    free(wh);
}

Referenced by wrap_get().

wrap_get()

static struct wrap_data * wrap_get ( mpg123_handle *  mh )

static

Definition at line 126 of file lfs_wrap.c.

{
    struct wrap_data* whd;
    if(mh == NULL) return NULL;
 
    /* Access the private storage inside the mpg123 handle.
       The real callback functions and handles are stored there. */
    if(mh->wrapperdata == NULL)
    {
        /* Create a new one. */
        mh->wrapperdata = malloc(sizeof(struct wrap_data));
        if(mh->wrapperdata == NULL)
        {
            mh->err = MPG123_OUT_OF_MEM;
            return NULL;
        }
    /* When we have wrapper data present, the callback for its proper cleanup is needed. */
        mh->wrapperclean = wrap_destroy;
 
        whd = mh->wrapperdata;
        whd->indextable = NULL;
        whd->iotype = 0;
        whd->fd = -1;
        whd->my_fd = -1;
        whd->r_read = NULL;
        whd->r_lseek = NULL;
        whd->handle = NULL;
        whd->r_h_read = NULL;
        whd->r_h_lseek = NULL;
        whd->h_cleanup = NULL;
    }
    else whd = mh->wrapperdata;
 
    return whd;
}

Referenced by mpg123_index(), mpg123_replace_reader(), mpg123_replace_reader_handle(), and mpg123_set_index().

wrap_io_cleanup()

static void wrap_io_cleanup ( void *  handle )

static

Definition at line 97 of file lfs_wrap.c.

{
    struct wrap_data *ioh = handle;
    if(ioh->iotype == IO_HANDLE)
    {
        if(ioh->h_cleanup != NULL && ioh->handle != NULL)
        ioh->h_cleanup(ioh->handle);
 
        ioh->handle = NULL;
    }
    if(ioh->my_fd >= 0)
    {
        close(ioh->my_fd);
        ioh->my_fd = -1;
    }
}

Referenced by mpg123_open(), mpg123_open_fd(), mpg123_open_handle(), and wrap_destroy().

wrap_lseek()

off_t wrap_lseek	(	void *	handle,
		off_t	offset,
		int	whence
	)

Definition at line 544 of file lfs_wrap.c.

{
    struct wrap_data *ioh = handle;
    long smalloff = offset;
    if(smalloff == offset)
    {
        switch(ioh->iotype)
        {
            case IO_FD: return ioh->r_lseek(ioh->fd, smalloff, whence);
            case IO_HANDLE: return ioh->r_h_lseek(ioh->handle, smalloff, whence);
        }
        return -1;
    }
    else
    {
        errno = EOVERFLOW;
        return -1;
    }
}

Referenced by mpg123_open(), mpg123_open_fd(), and mpg123_open_handle().

wrap_read()

ssize_t wrap_read	(	void *	handle,
		void *	buf,
		size_t	count
	)

Definition at line 531 of file lfs_wrap.c.

{
    struct wrap_data *ioh = handle;
    switch(ioh->iotype)
    {
        case IO_FD: return ioh->r_read(ioh->fd, buf, count);
        case IO_HANDLE: return ioh->r_h_read(ioh->handle, buf, count);
    }
    error("Serious breakage - bad IO type in LFS wrapper!");
    return -1;
}

Referenced by mpg123_open(), mpg123_open_fd(), and mpg123_open_handle().