view src/timidity/libtimidity/stream.c @ 984:df7b09989aee trunk

[svn] - We got a new plugin, captain! - FileWriter is the ultimate plugin for dumping audio to files. It should be the successor of Disk Writer and Out-Lame, as it supports the same output formats as those (WAVE and MP3). The main advantage of having only one file dumping plugin for many formats is that not every plugin has to think about file handling (where to write files to, how to call them etc.) that much anymore. - FileWriter is also very extensible - adding new output formats should be very easy.

#if HAVE_CONFIG_H
#  include <config.h>
#endif

#include "string.h"

#include "timidity.h"
#include "timidity_internal.h"
#include "common.h"

struct _MidIStream
{
  MidIStreamReadFunc read;
  MidIStreamCloseFunc close;
  void *ctx;
};

typedef struct StdIOContext
{
  VFSFile *fp;
  int autoclose;
} StdIOContext;

size_t
stdio_istream_read (void *ctx, void *ptr, size_t size, size_t nmemb)
{
  return vfs_fread (ptr, size, nmemb, ((StdIOContext *) ctx)->fp);
}

int
stdio_istream_close (void *ctx)
{
  int ret = 0;
  if (((StdIOContext *) ctx)->autoclose)
    ret = vfs_fclose (((StdIOContext *) ctx)->fp);
  free (ctx);
  return ret;
}

typedef struct MemContext
{
  sint8 *base;
  sint8 *current;
  sint8 *end;
  int autofree;
} MemContext;

size_t
mem_istream_read (void *ctx, void *ptr, size_t size, size_t nmemb)
{
  MemContext *c;
  size_t count;

  c = (MemContext *) ctx;
  count = nmemb;

  if (c->current + count * size > c->end)
    count = (c->end - c->current) / size;

  memcpy (ptr, c->current, count * size);
  c->current += count * size;

  return count;
}

int
mem_istream_close (void *ctx)
{
  if (((MemContext *) ctx)->autofree)
    free (((MemContext *) ctx)->base);
  free (ctx);
  return 0;
}

MidIStream *
mid_istream_open_fp (VFSFile * fp, int autoclose)
{
  StdIOContext *ctx;
  MidIStream *stream;

  stream = safe_malloc (sizeof (MidIStream));
  if (stream == NULL)
    return NULL;

  ctx = safe_malloc (sizeof (StdIOContext));
  if (ctx == NULL)
    {
      free (stream);
      return NULL;
    }
  ctx->fp = fp;
  ctx->autoclose = autoclose;

  stream->ctx = ctx;
  stream->read = stdio_istream_read;
  stream->close = stdio_istream_close;

  return stream;
}

MidIStream *
mid_istream_open_file (const char *file)
{
  VFSFile *fp;

  fp = vfs_fopen (file, "rb");
  if (fp == NULL)
    return NULL;

  return mid_istream_open_fp (fp, 1);
}

MidIStream *
mid_istream_open_mem (void *mem, size_t size, int autofree)
{
  MemContext *ctx;
  MidIStream *stream;

  stream = safe_malloc (sizeof (MidIStream));
  if (stream == NULL)
    return NULL;

  ctx = safe_malloc (sizeof (MemContext));
  if (ctx == NULL)
    {
      free (stream);
      return NULL;
    }
  ctx->base = mem;
  ctx->current = mem;
  ctx->end = ((sint8 *) mem) + size;
  ctx->autofree = autofree;

  stream->ctx = ctx;
  stream->read = mem_istream_read;
  stream->close = mem_istream_close;

  return stream;
}

MidIStream *
mid_istream_open_callbacks (MidIStreamReadFunc read,
			    MidIStreamCloseFunc close, void *context)
{
  MidIStream *stream;

  stream = safe_malloc (sizeof (MidIStream));
  if (stream == NULL)
    return NULL;

  stream->ctx = context;
  stream->read = read;
  stream->close = close;

  return stream;
}

size_t
mid_istream_read (MidIStream * stream, void *ptr, size_t size, size_t nmemb)
{
  return stream->read (stream->ctx, ptr, size, nmemb);
}

void
mid_istream_skip (MidIStream * stream, size_t len)
{
  size_t c;
  char tmp[1024];
  while (len > 0)
    {
      c = len;
      if (c > 1024)
	c = 1024;
      len -= c;
      if (c != mid_istream_read (stream, tmp, 1, c))
	{
	  DEBUG_MSG ("mid_istream_skip error\n");
	}
    }
}

int
mid_istream_close (MidIStream * stream)
{
  int ret = stream->close (stream->ctx);
  free (stream);
  return ret;
}