forked from len0rd/rockbox
Submit FS#12142 by Sean Bartell with minor chnages by myself. Removes unused code and irrelevant files from libmad.
git-svn-id: svn://svn.rockbox.org/rockbox/trunk@30065 a1c6a512-1295-4272-9138-f99709370657
This commit is contained in:
Andree Buschmann
parent
fcae888e81
commit
96af117e21
17 changed files with 16 additions and 1945 deletions
|
|
@ -1,183 +0,0 @@
|
|||
Basic Installation
|
||||
==================
|
||||
|
||||
These are generic installation instructions.
|
||||
|
||||
The `configure' shell script attempts to guess correct values for
|
||||
various system-dependent variables used during compilation. It uses
|
||||
those values to create a `Makefile' in each directory of the package.
|
||||
It may also create one or more `.h' files containing system-dependent
|
||||
definitions. Finally, it creates a shell script `config.status' that
|
||||
you can run in the future to recreate the current configuration, a file
|
||||
`config.cache' that saves the results of its tests to speed up
|
||||
reconfiguring, and a file `config.log' containing compiler output
|
||||
(useful mainly for debugging `configure').
|
||||
|
||||
If you need to do unusual things to compile the package, please try
|
||||
to figure out how `configure' could check whether to do them, and mail
|
||||
diffs or instructions to the address given in the `README' so they can
|
||||
be considered for the next release. If at some point `config.cache'
|
||||
contains results you don't want to keep, you may remove or edit it.
|
||||
|
||||
The file `configure.in' is used to create `configure' by a program
|
||||
called `autoconf'. You only need `configure.in' if you want to change
|
||||
it or regenerate `configure' using a newer version of `autoconf'.
|
||||
|
||||
The simplest way to compile this package is:
|
||||
|
||||
1. `cd' to the directory containing the package's source code and type
|
||||
`./configure' to configure the package for your system. If you're
|
||||
using `csh' on an old version of System V, you might need to type
|
||||
`sh ./configure' instead to prevent `csh' from trying to execute
|
||||
`configure' itself.
|
||||
|
||||
Running `configure' takes awhile. While running, it prints some
|
||||
messages telling which features it is checking for.
|
||||
|
||||
2. Type `make' to compile the package.
|
||||
|
||||
3. Optionally, type `make check' to run any self-tests that come with
|
||||
the package.
|
||||
|
||||
4. Type `make install' to install the programs and any data files and
|
||||
documentation.
|
||||
|
||||
5. You can remove the program binaries and object files from the
|
||||
source code directory by typing `make clean'. To also remove the
|
||||
files that `configure' created (so you can compile the package for
|
||||
a different kind of computer), type `make distclean'. There is
|
||||
also a `make maintainer-clean' target, but that is intended mainly
|
||||
for the package's developers. If you use it, you may have to get
|
||||
all sorts of other programs in order to regenerate files that came
|
||||
with the distribution.
|
||||
|
||||
Compilers and Options
|
||||
=====================
|
||||
|
||||
Some systems require unusual options for compilation or linking that
|
||||
the `configure' script does not know about. You can give `configure'
|
||||
initial values for variables by setting them in the environment. Using
|
||||
a Bourne-compatible shell, you can do that on the command line like
|
||||
this:
|
||||
CC=c89 CFLAGS=-O2 LIBS=-lposix ./configure
|
||||
|
||||
Or on systems that have the `env' program, you can do it like this:
|
||||
env CPPFLAGS=-I/usr/local/include LDFLAGS=-s ./configure
|
||||
|
||||
Compiling For Multiple Architectures
|
||||
====================================
|
||||
|
||||
You can compile the package for more than one kind of computer at the
|
||||
same time, by placing the object files for each architecture in their
|
||||
own directory. To do this, you must use a version of `make' that
|
||||
supports the `VPATH' variable, such as GNU `make'. `cd' to the
|
||||
directory where you want the object files and executables to go and run
|
||||
the `configure' script. `configure' automatically checks for the
|
||||
source code in the directory that `configure' is in and in `..'.
|
||||
|
||||
If you have to use a `make' that does not supports the `VPATH'
|
||||
variable, you have to compile the package for one architecture at a time
|
||||
in the source code directory. After you have installed the package for
|
||||
one architecture, use `make distclean' before reconfiguring for another
|
||||
architecture.
|
||||
|
||||
Installation Names
|
||||
==================
|
||||
|
||||
By default, `make install' will install the package's files in
|
||||
`/usr/local/bin', `/usr/local/man', etc. You can specify an
|
||||
installation prefix other than `/usr/local' by giving `configure' the
|
||||
option `--prefix=PATH'.
|
||||
|
||||
You can specify separate installation prefixes for
|
||||
architecture-specific files and architecture-independent files. If you
|
||||
give `configure' the option `--exec-prefix=PATH', the package will use
|
||||
PATH as the prefix for installing programs and libraries.
|
||||
Documentation and other data files will still use the regular prefix.
|
||||
|
||||
In addition, if you use an unusual directory layout you can give
|
||||
options like `--bindir=PATH' to specify different values for particular
|
||||
kinds of files. Run `configure --help' for a list of the directories
|
||||
you can set and what kinds of files go in them.
|
||||
|
||||
If the package supports it, you can cause programs to be installed
|
||||
with an extra prefix or suffix on their names by giving `configure' the
|
||||
option `--program-prefix=PREFIX' or `--program-suffix=SUFFIX'.
|
||||
|
||||
Optional Features
|
||||
=================
|
||||
|
||||
Some packages pay attention to `--enable-FEATURE' options to
|
||||
`configure', where FEATURE indicates an optional part of the package.
|
||||
They may also pay attention to `--with-PACKAGE' options, where PACKAGE
|
||||
is something like `gnu-as' or `x' (for the X Window System). The
|
||||
`README' should mention any `--enable-' and `--with-' options that the
|
||||
package recognizes.
|
||||
|
||||
For packages that use the X Window System, `configure' can usually
|
||||
find the X include and library files automatically, but if it doesn't,
|
||||
you can use the `configure' options `--x-includes=DIR' and
|
||||
`--x-libraries=DIR' to specify their locations.
|
||||
|
||||
Specifying the System Type
|
||||
==========================
|
||||
|
||||
There may be some features `configure' can not figure out
|
||||
automatically, but needs to determine by the type of host the package
|
||||
will run on. Usually `configure' can figure that out, but if it prints
|
||||
a message saying it can not guess the host type, give it the
|
||||
`--host=TYPE' option. TYPE can either be a short name for the system
|
||||
type, such as `sun4', or a canonical name with three fields:
|
||||
CPU-COMPANY-SYSTEM
|
||||
|
||||
See the file `config.sub' for the possible values of each field. If
|
||||
`config.sub' isn't included in this package, then this package doesn't
|
||||
need to know the host type.
|
||||
|
||||
If you are building compiler tools for cross-compiling, you can also
|
||||
use the `--target=TYPE' option to select the type of system they will
|
||||
produce code for and the `--build=TYPE' option to select the type of
|
||||
system on which you are compiling the package.
|
||||
|
||||
Sharing Defaults
|
||||
================
|
||||
|
||||
If you want to set default values for `configure' scripts to share,
|
||||
you can create a site shell script called `config.site' that gives
|
||||
default values for variables like `CC', `cache_file', and `prefix'.
|
||||
`configure' looks for `PREFIX/share/config.site' if it exists, then
|
||||
`PREFIX/etc/config.site' if it exists. Or, you can set the
|
||||
`CONFIG_SITE' environment variable to the location of the site script.
|
||||
A warning: not all `configure' scripts look for a site script.
|
||||
|
||||
Operation Controls
|
||||
==================
|
||||
|
||||
`configure' recognizes the following options to control how it
|
||||
operates.
|
||||
|
||||
`--cache-file=FILE'
|
||||
Use and save the results of the tests in FILE instead of
|
||||
`./config.cache'. Set FILE to `/dev/null' to disable caching, for
|
||||
debugging `configure'.
|
||||
|
||||
`--help'
|
||||
Print a summary of the options to `configure', and exit.
|
||||
|
||||
`--quiet'
|
||||
`--silent'
|
||||
`-q'
|
||||
Do not print messages saying which checks are being made. To
|
||||
suppress all normal output, redirect it to `/dev/null' (any error
|
||||
messages will still be shown).
|
||||
|
||||
`--srcdir=DIR'
|
||||
Look for the package's source code in directory DIR. Usually
|
||||
`configure' can determine that directory automatically.
|
||||
|
||||
`--version'
|
||||
Print the version of Autoconf used to generate the `configure'
|
||||
script, and exit.
|
||||
|
||||
`configure' also accepts some other, not widely useful, options.
|
||||
|
||||
|
|
@ -1,589 +0,0 @@
|
|||
/*
|
||||
* libmad - MPEG audio decoder library
|
||||
* Copyright (C) 2000-2004 Underbit Technologies, Inc.
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*
|
||||
* $Id$
|
||||
*/
|
||||
|
||||
# ifdef HAVE_CONFIG_H
|
||||
# include "config.h"
|
||||
# endif
|
||||
|
||||
# include "global.h"
|
||||
|
||||
# ifdef HAVE_SYS_TYPES_H
|
||||
# include <sys/types.h>
|
||||
# endif
|
||||
|
||||
# ifdef HAVE_SYS_WAIT_H
|
||||
# include <sys/wait.h>
|
||||
# endif
|
||||
|
||||
# ifdef HAVE_UNISTD_H
|
||||
# include <unistd.h>
|
||||
# endif
|
||||
|
||||
# ifdef HAVE_FCNTL_H
|
||||
# include <fcntl.h>
|
||||
# endif
|
||||
|
||||
# ifdef HAVE_ERRNO_H
|
||||
# include <errno.h>
|
||||
# endif
|
||||
|
||||
# include "stream.h"
|
||||
# include "frame.h"
|
||||
# include "synth.h"
|
||||
# include "decoder.h"
|
||||
|
||||
#if 0 /* rockbox: not used */
|
||||
/*
|
||||
* NAME: decoder->init()
|
||||
* DESCRIPTION: initialize a decoder object with callback routines
|
||||
*/
|
||||
void mad_decoder_init(struct mad_decoder *decoder, void *data,
|
||||
enum mad_flow (*input_func)(void *,
|
||||
struct mad_stream *),
|
||||
enum mad_flow (*header_func)(void *,
|
||||
struct mad_header const *),
|
||||
enum mad_flow (*filter_func)(void *,
|
||||
struct mad_stream const *,
|
||||
struct mad_frame *),
|
||||
enum mad_flow (*output_func)(void *,
|
||||
struct mad_header const *,
|
||||
struct mad_pcm *),
|
||||
enum mad_flow (*error_func)(void *,
|
||||
struct mad_stream *,
|
||||
struct mad_frame *),
|
||||
enum mad_flow (*message_func)(void *,
|
||||
void *, unsigned int *))
|
||||
{
|
||||
decoder->mode = -1;
|
||||
|
||||
decoder->options = 0;
|
||||
|
||||
decoder->async.pid = 0;
|
||||
decoder->async.in = -1;
|
||||
decoder->async.out = -1;
|
||||
|
||||
decoder->sync = 0;
|
||||
|
||||
decoder->cb_data = data;
|
||||
|
||||
decoder->input_func = input_func;
|
||||
decoder->header_func = header_func;
|
||||
decoder->filter_func = filter_func;
|
||||
decoder->output_func = output_func;
|
||||
decoder->error_func = error_func;
|
||||
decoder->message_func = message_func;
|
||||
}
|
||||
|
||||
int mad_decoder_finish(struct mad_decoder *decoder)
|
||||
{
|
||||
# if defined(USE_ASYNC)
|
||||
if (decoder->mode == MAD_DECODER_MODE_ASYNC && decoder->async.pid) {
|
||||
pid_t pid;
|
||||
int status;
|
||||
|
||||
close(decoder->async.in);
|
||||
|
||||
do
|
||||
pid = waitpid(decoder->async.pid, &status, 0);
|
||||
while (pid == -1 && errno == EINTR);
|
||||
|
||||
decoder->mode = -1;
|
||||
|
||||
close(decoder->async.out);
|
||||
|
||||
decoder->async.pid = 0;
|
||||
decoder->async.in = -1;
|
||||
decoder->async.out = -1;
|
||||
|
||||
if (pid == -1)
|
||||
return -1;
|
||||
|
||||
return (!WIFEXITED(status) || WEXITSTATUS(status)) ? -1 : 0;
|
||||
}
|
||||
# else
|
||||
/* Avoid compiler warning */
|
||||
(void)decoder;
|
||||
# endif
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
# if defined(USE_ASYNC)
|
||||
static
|
||||
enum mad_flow send_io(int fd, void const *data, size_t len)
|
||||
{
|
||||
char const *ptr = data;
|
||||
ssize_t count;
|
||||
|
||||
while (len) {
|
||||
do
|
||||
count = write(fd, ptr, len);
|
||||
while (count == -1 && errno == EINTR);
|
||||
|
||||
if (count == -1)
|
||||
return MAD_FLOW_BREAK;
|
||||
|
||||
len -= count;
|
||||
ptr += count;
|
||||
}
|
||||
|
||||
return MAD_FLOW_CONTINUE;
|
||||
}
|
||||
|
||||
static
|
||||
enum mad_flow receive_io(int fd, void *buffer, size_t len)
|
||||
{
|
||||
char *ptr = buffer;
|
||||
ssize_t count;
|
||||
|
||||
while (len) {
|
||||
do
|
||||
count = read(fd, ptr, len);
|
||||
while (count == -1 && errno == EINTR);
|
||||
|
||||
if (count == -1)
|
||||
return (errno == EAGAIN) ? MAD_FLOW_IGNORE : MAD_FLOW_BREAK;
|
||||
else if (count == 0)
|
||||
return MAD_FLOW_STOP;
|
||||
|
||||
len -= count;
|
||||
ptr += count;
|
||||
}
|
||||
|
||||
return MAD_FLOW_CONTINUE;
|
||||
}
|
||||
|
||||
static
|
||||
enum mad_flow receive_io_blocking(int fd, void *buffer, size_t len)
|
||||
{
|
||||
int flags, blocking;
|
||||
enum mad_flow result;
|
||||
|
||||
flags = fcntl(fd, F_GETFL);
|
||||
if (flags == -1)
|
||||
return MAD_FLOW_BREAK;
|
||||
|
||||
blocking = flags & ~O_NONBLOCK;
|
||||
|
||||
if (blocking != flags &&
|
||||
fcntl(fd, F_SETFL, blocking) == -1)
|
||||
return MAD_FLOW_BREAK;
|
||||
|
||||
result = receive_io(fd, buffer, len);
|
||||
|
||||
if (flags != blocking &&
|
||||
fcntl(fd, F_SETFL, flags) == -1)
|
||||
return MAD_FLOW_BREAK;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
static
|
||||
enum mad_flow send(int fd, void const *message, unsigned int size)
|
||||
{
|
||||
enum mad_flow result;
|
||||
|
||||
/* send size */
|
||||
|
||||
result = send_io(fd, &size, sizeof(size));
|
||||
|
||||
/* send message */
|
||||
|
||||
if (result == MAD_FLOW_CONTINUE)
|
||||
result = send_io(fd, message, size);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
static
|
||||
enum mad_flow receive(int fd, void **message, unsigned int *size)
|
||||
{
|
||||
enum mad_flow result;
|
||||
unsigned int actual;
|
||||
|
||||
if (*message == 0)
|
||||
*size = 0;
|
||||
|
||||
/* receive size */
|
||||
|
||||
result = receive_io(fd, &actual, sizeof(actual));
|
||||
|
||||
/* receive message */
|
||||
|
||||
if (result == MAD_FLOW_CONTINUE) {
|
||||
if (actual > *size)
|
||||
actual -= *size;
|
||||
else {
|
||||
*size = actual;
|
||||
actual = 0;
|
||||
}
|
||||
|
||||
if (*size > 0) {
|
||||
if (*message == 0) {
|
||||
*message = malloc(*size);
|
||||
if (*message == 0)
|
||||
return MAD_FLOW_BREAK;
|
||||
}
|
||||
|
||||
result = receive_io_blocking(fd, *message, *size);
|
||||
}
|
||||
|
||||
/* throw away remainder of message */
|
||||
|
||||
while (actual && result == MAD_FLOW_CONTINUE) {
|
||||
char sink[256];
|
||||
unsigned int len;
|
||||
|
||||
len = actual > sizeof(sink) ? sizeof(sink) : actual;
|
||||
|
||||
result = receive_io_blocking(fd, sink, len);
|
||||
|
||||
actual -= len;
|
||||
}
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
static
|
||||
enum mad_flow check_message(struct mad_decoder *decoder)
|
||||
{
|
||||
enum mad_flow result;
|
||||
void *message = 0;
|
||||
unsigned int size;
|
||||
|
||||
result = receive(decoder->async.in, &message, &size);
|
||||
|
||||
if (result == MAD_FLOW_CONTINUE) {
|
||||
if (decoder->message_func == 0)
|
||||
size = 0;
|
||||
else {
|
||||
result = decoder->message_func(decoder->cb_data, message, &size);
|
||||
|
||||
if (result == MAD_FLOW_IGNORE ||
|
||||
result == MAD_FLOW_BREAK)
|
||||
size = 0;
|
||||
}
|
||||
|
||||
if (send(decoder->async.out, message, size) != MAD_FLOW_CONTINUE)
|
||||
result = MAD_FLOW_BREAK;
|
||||
}
|
||||
|
||||
if (message)
|
||||
free(message);
|
||||
|
||||
return result;
|
||||
}
|
||||
# endif
|
||||
|
||||
static
|
||||
enum mad_flow error_default(void *data, struct mad_stream *stream,
|
||||
struct mad_frame *frame)
|
||||
{
|
||||
int *bad_last_frame = data;
|
||||
|
||||
switch (stream->error) {
|
||||
case MAD_ERROR_BADCRC:
|
||||
if (*bad_last_frame)
|
||||
mad_frame_mute(frame);
|
||||
else
|
||||
*bad_last_frame = 1;
|
||||
|
||||
return MAD_FLOW_IGNORE;
|
||||
|
||||
default:
|
||||
return MAD_FLOW_CONTINUE;
|
||||
}
|
||||
}
|
||||
|
||||
static
|
||||
int run_sync(struct mad_decoder *decoder)
|
||||
{
|
||||
enum mad_flow (*error_func)(void *, struct mad_stream *, struct mad_frame *);
|
||||
void *error_data;
|
||||
int bad_last_frame = 0;
|
||||
struct mad_stream *stream;
|
||||
struct mad_frame *frame;
|
||||
struct mad_synth *synth;
|
||||
int result = 0;
|
||||
|
||||
if (decoder->input_func == 0)
|
||||
return 0;
|
||||
|
||||
if (decoder->error_func) {
|
||||
error_func = decoder->error_func;
|
||||
error_data = decoder->cb_data;
|
||||
}
|
||||
else {
|
||||
error_func = error_default;
|
||||
error_data = &bad_last_frame;
|
||||
}
|
||||
|
||||
stream = &decoder->sync->stream;
|
||||
frame = &decoder->sync->frame;
|
||||
synth = &decoder->sync->synth;
|
||||
|
||||
mad_stream_init(stream);
|
||||
mad_frame_init(frame);
|
||||
mad_synth_init(synth);
|
||||
|
||||
mad_stream_options(stream, decoder->options);
|
||||
|
||||
do {
|
||||
switch (decoder->input_func(decoder->cb_data, stream)) {
|
||||
case MAD_FLOW_STOP:
|
||||
goto done;
|
||||
case MAD_FLOW_BREAK:
|
||||
goto fail;
|
||||
case MAD_FLOW_IGNORE:
|
||||
continue;
|
||||
case MAD_FLOW_CONTINUE:
|
||||
break;
|
||||
}
|
||||
|
||||
while (1) {
|
||||
# if defined(USE_ASYNC)
|
||||
if (decoder->mode == MAD_DECODER_MODE_ASYNC) {
|
||||
switch (check_message(decoder)) {
|
||||
case MAD_FLOW_IGNORE:
|
||||
case MAD_FLOW_CONTINUE:
|
||||
break;
|
||||
case MAD_FLOW_BREAK:
|
||||
goto fail;
|
||||
case MAD_FLOW_STOP:
|
||||
goto done;
|
||||
}
|
||||
}
|
||||
# endif
|
||||
|
||||
if (decoder->header_func) {
|
||||
if (mad_header_decode(&frame->header, stream) == -1) {
|
||||
if (!MAD_RECOVERABLE(stream->error))
|
||||
break;
|
||||
|
||||
switch (error_func(error_data, stream, frame)) {
|
||||
case MAD_FLOW_STOP:
|
||||
goto done;
|
||||
case MAD_FLOW_BREAK:
|
||||
goto fail;
|
||||
case MAD_FLOW_IGNORE:
|
||||
case MAD_FLOW_CONTINUE:
|
||||
default:
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
switch (decoder->header_func(decoder->cb_data, &frame->header)) {
|
||||
case MAD_FLOW_STOP:
|
||||
goto done;
|
||||
case MAD_FLOW_BREAK:
|
||||
goto fail;
|
||||
case MAD_FLOW_IGNORE:
|
||||
continue;
|
||||
case MAD_FLOW_CONTINUE:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (mad_frame_decode(frame, stream) == -1) {
|
||||
if (!MAD_RECOVERABLE(stream->error))
|
||||
break;
|
||||
|
||||
switch (error_func(error_data, stream, frame)) {
|
||||
case MAD_FLOW_STOP:
|
||||
goto done;
|
||||
case MAD_FLOW_BREAK:
|
||||
goto fail;
|
||||
case MAD_FLOW_IGNORE:
|
||||
break;
|
||||
case MAD_FLOW_CONTINUE:
|
||||
default:
|
||||
continue;
|
||||
}
|
||||
}
|
||||
else
|
||||
bad_last_frame = 0;
|
||||
|
||||
if (decoder->filter_func) {
|
||||
switch (decoder->filter_func(decoder->cb_data, stream, frame)) {
|
||||
case MAD_FLOW_STOP:
|
||||
goto done;
|
||||
case MAD_FLOW_BREAK:
|
||||
goto fail;
|
||||
case MAD_FLOW_IGNORE:
|
||||
continue;
|
||||
case MAD_FLOW_CONTINUE:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
mad_synth_frame(synth, frame);
|
||||
|
||||
if (decoder->output_func) {
|
||||
switch (decoder->output_func(decoder->cb_data,
|
||||
&frame->header, &synth->pcm)) {
|
||||
case MAD_FLOW_STOP:
|
||||
goto done;
|
||||
case MAD_FLOW_BREAK:
|
||||
goto fail;
|
||||
case MAD_FLOW_IGNORE:
|
||||
case MAD_FLOW_CONTINUE:
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
while (stream->error == MAD_ERROR_BUFLEN);
|
||||
|
||||
fail:
|
||||
result = -1;
|
||||
|
||||
done:
|
||||
mad_synth_finish(synth);
|
||||
mad_frame_finish(frame);
|
||||
mad_stream_finish(stream);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
# if defined(USE_ASYNC)
|
||||
static
|
||||
int run_async(struct mad_decoder *decoder)
|
||||
{
|
||||
pid_t pid;
|
||||
int ptoc[2], ctop[2], flags;
|
||||
|
||||
if (pipe(ptoc) == -1)
|
||||
return -1;
|
||||
|
||||
if (pipe(ctop) == -1) {
|
||||
close(ptoc[0]);
|
||||
close(ptoc[1]);
|
||||
return -1;
|
||||
}
|
||||
|
||||
flags = fcntl(ptoc[0], F_GETFL);
|
||||
if (flags == -1 ||
|
||||
fcntl(ptoc[0], F_SETFL, flags | O_NONBLOCK) == -1) {
|
||||
close(ctop[0]);
|
||||
close(ctop[1]);
|
||||
close(ptoc[0]);
|
||||
close(ptoc[1]);
|
||||
return -1;
|
||||
}
|
||||
|
||||
pid = fork();
|
||||
if (pid == -1) {
|
||||
close(ctop[0]);
|
||||
close(ctop[1]);
|
||||
close(ptoc[0]);
|
||||
close(ptoc[1]);
|
||||
return -1;
|
||||
}
|
||||
|
||||
decoder->async.pid = pid;
|
||||
|
||||
if (pid) {
|
||||
/* parent */
|
||||
|
||||
close(ptoc[0]);
|
||||
close(ctop[1]);
|
||||
|
||||
decoder->async.in = ctop[0];
|
||||
decoder->async.out = ptoc[1];
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* child */
|
||||
|
||||
close(ptoc[1]);
|
||||
close(ctop[0]);
|
||||
|
||||
decoder->async.in = ptoc[0];
|
||||
decoder->async.out = ctop[1];
|
||||
|
||||
_exit(run_sync(decoder));
|
||||
|
||||
/* not reached */
|
||||
return -1;
|
||||
}
|
||||
# endif
|
||||
|
||||
/*
|
||||
* NAME: decoder->run()
|
||||
* DESCRIPTION: run the decoder thread either synchronously or asynchronously
|
||||
*/
|
||||
int mad_decoder_run(struct mad_decoder *decoder, enum mad_decoder_mode mode)
|
||||
{
|
||||
int result;
|
||||
int (*run)(struct mad_decoder *) = 0;
|
||||
|
||||
switch (decoder->mode = mode) {
|
||||
case MAD_DECODER_MODE_SYNC:
|
||||
run = run_sync;
|
||||
break;
|
||||
|
||||
case MAD_DECODER_MODE_ASYNC:
|
||||
# if defined(USE_ASYNC)
|
||||
run = run_async;
|
||||
# endif
|
||||
break;
|
||||
}
|
||||
|
||||
if (run == 0)
|
||||
return -1;
|
||||
|
||||
decoder->sync = malloc(sizeof(*decoder->sync));
|
||||
if (decoder->sync == 0)
|
||||
return -1;
|
||||
|
||||
result = run(decoder);
|
||||
|
||||
free(decoder->sync);
|
||||
decoder->sync = 0;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
/*
|
||||
* NAME: decoder->message()
|
||||
* DESCRIPTION: send a message to and receive a reply from the decoder process
|
||||
*/
|
||||
int mad_decoder_message(struct mad_decoder *decoder,
|
||||
void *message, unsigned int *len)
|
||||
{
|
||||
# if defined(USE_ASYNC)
|
||||
if (decoder->mode != MAD_DECODER_MODE_ASYNC ||
|
||||
send(decoder->async.out, message, *len) != MAD_FLOW_CONTINUE ||
|
||||
receive(decoder->async.in, &message, len) != MAD_FLOW_CONTINUE)
|
||||
return -1;
|
||||
|
||||
return 0;
|
||||
# else
|
||||
/* Avoid compiler warnings */
|
||||
(void)decoder;
|
||||
(void)message;
|
||||
(void)len;
|
||||
return -1;
|
||||
# endif
|
||||
}
|
||||
#endif
|
||||
|
|
@ -1,93 +0,0 @@
|
|||
/*
|
||||
* libmad - MPEG audio decoder library
|
||||
* Copyright (C) 2000-2004 Underbit Technologies, Inc.
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*
|
||||
* $Id$
|
||||
*/
|
||||
|
||||
# ifndef LIBMAD_DECODER_H
|
||||
# define LIBMAD_DECODER_H
|
||||
|
||||
# include "stream.h"
|
||||
# include "frame.h"
|
||||
# include "synth.h"
|
||||
|
||||
enum mad_decoder_mode {
|
||||
MAD_DECODER_MODE_SYNC = 0,
|
||||
MAD_DECODER_MODE_ASYNC
|
||||
};
|
||||
|
||||
enum mad_flow {
|
||||
MAD_FLOW_CONTINUE = 0x0000, /* continue normally */
|
||||
MAD_FLOW_STOP = 0x0010, /* stop decoding normally */
|
||||
MAD_FLOW_BREAK = 0x0011, /* stop decoding and signal an error */
|
||||
MAD_FLOW_IGNORE = 0x0020 /* ignore the current frame */
|
||||
};
|
||||
|
||||
struct mad_decoder {
|
||||
enum mad_decoder_mode mode;
|
||||
|
||||
int options;
|
||||
|
||||
struct {
|
||||
long pid;
|
||||
int in;
|
||||
int out;
|
||||
} async;
|
||||
|
||||
struct {
|
||||
struct mad_stream stream;
|
||||
struct mad_frame frame;
|
||||
struct mad_synth synth;
|
||||
} *sync;
|
||||
|
||||
void *cb_data;
|
||||
/* rockbox: unused
|
||||
enum mad_flow (*input_func)(void *, struct mad_stream *);
|
||||
enum mad_flow (*header_func)(void *, struct mad_header const *);
|
||||
enum mad_flow (*filter_func)(void *,
|
||||
struct mad_stream const *, struct mad_frame *);
|
||||
enum mad_flow (*output_func)(void *,
|
||||
struct mad_header const *, struct mad_pcm *);
|
||||
enum mad_flow (*error_func)(void *, struct mad_stream *, struct mad_frame *);
|
||||
enum mad_flow (*message_func)(void *, void *, unsigned int *);
|
||||
*/
|
||||
};
|
||||
/* rockbox: unused
|
||||
void mad_decoder_init(struct mad_decoder *, void *,
|
||||
enum mad_flow (*)(void *, struct mad_stream *),
|
||||
enum mad_flow (*)(void *, struct mad_header const *),
|
||||
enum mad_flow (*)(void *,
|
||||
struct mad_stream const *,
|
||||
struct mad_frame *),
|
||||
enum mad_flow (*)(void *,
|
||||
struct mad_header const *,
|
||||
struct mad_pcm *),
|
||||
enum mad_flow (*)(void *,
|
||||
struct mad_stream *,
|
||||
struct mad_frame *),
|
||||
enum mad_flow (*)(void *, void *, unsigned int *));
|
||||
int mad_decoder_finish(struct mad_decoder *);
|
||||
|
||||
# define mad_decoder_options(decoder, opts) \
|
||||
((void) ((decoder)->options = (opts)))
|
||||
|
||||
int mad_decoder_run(struct mad_decoder *, enum mad_decoder_mode);
|
||||
int mad_decoder_message(struct mad_decoder *, void *, unsigned int *);
|
||||
*/
|
||||
|
||||
# endif
|
||||
|
|
@ -1,81 +0,0 @@
|
|||
/*
|
||||
* libmad - MPEG audio decoder library
|
||||
* Copyright (C) 2000-2004 Underbit Technologies, Inc.
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*
|
||||
* $Id$
|
||||
*/
|
||||
|
||||
# ifdef HAVE_CONFIG_H
|
||||
# include "config.h"
|
||||
# endif
|
||||
|
||||
# include "global.h"
|
||||
|
||||
# include "fixed.h"
|
||||
|
||||
/*
|
||||
* NAME: fixed->abs()
|
||||
* DESCRIPTION: return absolute value of a fixed-point number
|
||||
*/
|
||||
mad_fixed_t mad_f_abs(mad_fixed_t x)
|
||||
{
|
||||
return x < 0 ? -x : x;
|
||||
}
|
||||
|
||||
/*
|
||||
* NAME: fixed->div()
|
||||
* DESCRIPTION: perform division using fixed-point math
|
||||
*/
|
||||
mad_fixed_t mad_f_div(mad_fixed_t x, mad_fixed_t y)
|
||||
{
|
||||
mad_fixed_t q, r;
|
||||
unsigned int bits;
|
||||
|
||||
q = mad_f_abs(x / y);
|
||||
|
||||
if (x < 0) {
|
||||
x = -x;
|
||||
y = -y;
|
||||
}
|
||||
|
||||
r = x % y;
|
||||
|
||||
if (y < 0) {
|
||||
x = -x;
|
||||
y = -y;
|
||||
}
|
||||
|
||||
if (q > mad_f_intpart(MAD_F_MAX) &&
|
||||
!(q == -mad_f_intpart(MAD_F_MIN) && r == 0 && (x < 0) != (y < 0)))
|
||||
return 0;
|
||||
|
||||
for (bits = MAD_F_FRACBITS; bits && r; --bits) {
|
||||
q <<= 1, r <<= 1;
|
||||
if (r >= y)
|
||||
r -= y, ++q;
|
||||
}
|
||||
|
||||
/* round */
|
||||
if (2 * r >= y)
|
||||
++q;
|
||||
|
||||
/* fix sign */
|
||||
if ((x < 0) != (y < 0))
|
||||
q = -q;
|
||||
|
||||
return q << bits;
|
||||
}
|
||||
|
|
@ -507,9 +507,4 @@ mad_fixed_t mad_f_mul_inline(mad_fixed_t x, mad_fixed_t y)
|
|||
# define MAD_F_SCALEBITS MAD_F_FRACBITS
|
||||
# endif
|
||||
|
||||
/* C routines */
|
||||
|
||||
mad_fixed_t mad_f_abs(mad_fixed_t);
|
||||
mad_fixed_t mad_f_div(mad_fixed_t, mad_fixed_t);
|
||||
|
||||
# endif
|
||||
|
|
|
|||
|
|
@ -315,6 +315,7 @@ int mad_header_decode(struct mad_header *header, struct mad_stream *stream)
|
|||
}
|
||||
|
||||
/* stream skip */
|
||||
/* rockbox: not used
|
||||
if (stream->skiplen) {
|
||||
if (!stream->sync)
|
||||
ptr = stream->this_frame;
|
||||
|
|
@ -332,6 +333,7 @@ int mad_header_decode(struct mad_header *header, struct mad_stream *stream)
|
|||
|
||||
stream->sync = 1;
|
||||
}
|
||||
*/
|
||||
|
||||
sync:
|
||||
/* synchronize */
|
||||
|
|
|
|||
|
|
@ -114,7 +114,8 @@ void mad_header_init(struct mad_header *);
|
|||
int mad_header_decode(struct mad_header *, struct mad_stream *);
|
||||
|
||||
void mad_frame_init(struct mad_frame *);
|
||||
void mad_frame_finish(struct mad_frame *);
|
||||
/* rockbox: not used
|
||||
void mad_frame_finish(struct mad_frame *);*/
|
||||
|
||||
int mad_frame_decode(struct mad_frame *, struct mad_stream *);
|
||||
|
||||
|
|
|
|||
|
|
@ -24,11 +24,8 @@
|
|||
|
||||
#define FPM_DEFAULT
|
||||
|
||||
#include "version.h"
|
||||
#include "fixed.h"
|
||||
#include "bit.h"
|
||||
#include "timer.h"
|
||||
#include "stream.h"
|
||||
#include "frame.h"
|
||||
#include "synth.h"
|
||||
#include "decoder.h"
|
||||
|
|
|
|||
|
|
@ -1,36 +0,0 @@
|
|||
#
|
||||
# libmad - MPEG audio decoder library
|
||||
# Copyright (C) 2000-2004 Underbit Technologies, Inc.
|
||||
#
|
||||
# This program is free software; you can redistribute it and/or modify
|
||||
# it under the terms of the GNU General Public License as published by
|
||||
# the Free Software Foundation; either version 2 of the License, or
|
||||
# (at your option) any later version.
|
||||
#
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License
|
||||
# along with this program; if not, write to the Free Software
|
||||
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
#
|
||||
# $Id$
|
||||
#
|
||||
|
||||
/^\/\*$/{
|
||||
N
|
||||
s/ \* libmad - /&/
|
||||
t copy
|
||||
b next
|
||||
: copy
|
||||
g
|
||||
n
|
||||
s|^ \* \$\(Id: .*\) \$$|/* \1 */|p
|
||||
/^ \*\/$/d
|
||||
b copy
|
||||
}
|
||||
/^# *include "/d
|
||||
: next
|
||||
p
|
||||
|
|
@ -1,222 +0,0 @@
|
|||
/*
|
||||
* libmad - MPEG audio decoder library
|
||||
* Copyright (C) 2000-2004 Underbit Technologies, Inc.
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*
|
||||
* $Id$
|
||||
*/
|
||||
|
||||
# include <stdio.h>
|
||||
# include <unistd.h>
|
||||
# include <sys/stat.h>
|
||||
# include <sys/mman.h>
|
||||
|
||||
# include "mad.h"
|
||||
|
||||
/*
|
||||
* This is perhaps the simplest example use of the MAD high-level API.
|
||||
* Standard input is mapped into memory via mmap(), then the high-level API
|
||||
* is invoked with three callbacks: input, output, and error. The output
|
||||
* callback converts MAD's high-resolution PCM samples to 16 bits, then
|
||||
* writes them to standard output in little-endian, stereo-interleaved
|
||||
* format.
|
||||
*/
|
||||
|
||||
static int decode(unsigned char const *, unsigned long);
|
||||
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
struct stat stat;
|
||||
void *fdm;
|
||||
|
||||
if (argc != 1)
|
||||
return 1;
|
||||
|
||||
if (fstat(STDIN_FILENO, &stat) == -1 ||
|
||||
stat.st_size == 0)
|
||||
return 2;
|
||||
|
||||
fdm = mmap(0, stat.st_size, PROT_READ, MAP_SHARED, STDIN_FILENO, 0);
|
||||
if (fdm == MAP_FAILED)
|
||||
return 3;
|
||||
|
||||
decode(fdm, stat.st_size);
|
||||
|
||||
if (munmap(fdm, stat.st_size) == -1)
|
||||
return 4;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* This is a private message structure. A generic pointer to this structure
|
||||
* is passed to each of the callback functions. Put here any data you need
|
||||
* to access from within the callbacks.
|
||||
*/
|
||||
|
||||
struct buffer {
|
||||
unsigned char const *start;
|
||||
unsigned long length;
|
||||
};
|
||||
|
||||
/*
|
||||
* This is the input callback. The purpose of this callback is to (re)fill
|
||||
* the stream buffer which is to be decoded. In this example, an entire file
|
||||
* has been mapped into memory, so we just call mad_stream_buffer() with the
|
||||
* address and length of the mapping. When this callback is called a second
|
||||
* time, we are finished decoding.
|
||||
*/
|
||||
|
||||
static
|
||||
enum mad_flow input(void *data,
|
||||
struct mad_stream *stream)
|
||||
{
|
||||
struct buffer *buffer = data;
|
||||
|
||||
if (!buffer->length)
|
||||
return MAD_FLOW_STOP;
|
||||
|
||||
mad_stream_buffer(stream, buffer->start, buffer->length);
|
||||
|
||||
buffer->length = 0;
|
||||
|
||||
return MAD_FLOW_CONTINUE;
|
||||
}
|
||||
|
||||
/*
|
||||
* The following utility routine performs simple rounding, clipping, and
|
||||
* scaling of MAD's high-resolution samples down to 16 bits. It does not
|
||||
* perform any dithering or noise shaping, which would be recommended to
|
||||
* obtain any exceptional audio quality. It is therefore not recommended to
|
||||
* use this routine if high-quality output is desired.
|
||||
*/
|
||||
|
||||
static inline
|
||||
signed int scale(mad_fixed_t sample)
|
||||
{
|
||||
/* round */
|
||||
sample += (1L << (MAD_F_FRACBITS - 16));
|
||||
|
||||
/* clip */
|
||||
if (sample >= MAD_F_ONE)
|
||||
sample = MAD_F_ONE - 1;
|
||||
else if (sample < -MAD_F_ONE)
|
||||
sample = -MAD_F_ONE;
|
||||
|
||||
/* quantize */
|
||||
return sample >> (MAD_F_FRACBITS + 1 - 16);
|
||||
}
|
||||
|
||||
/*
|
||||
* This is the output callback function. It is called after each frame of
|
||||
* MPEG audio data has been completely decoded. The purpose of this callback
|
||||
* is to output (or play) the decoded PCM audio.
|
||||
*/
|
||||
|
||||
static
|
||||
enum mad_flow output(void *data,
|
||||
struct mad_header const *header,
|
||||
struct mad_pcm *pcm)
|
||||
{
|
||||
unsigned int nchannels, nsamples;
|
||||
mad_fixed_t const *left_ch, *right_ch;
|
||||
|
||||
/* pcm->samplerate contains the sampling frequency */
|
||||
|
||||
nchannels = pcm->channels;
|
||||
nsamples = pcm->length;
|
||||
left_ch = pcm->samples[0];
|
||||
right_ch = pcm->samples[1];
|
||||
|
||||
while (nsamples--) {
|
||||
signed int sample;
|
||||
|
||||
/* output sample(s) in 16-bit signed little-endian PCM */
|
||||
|
||||
sample = scale(*left_ch++);
|
||||
putchar((sample >> 0) & 0xff);
|
||||
putchar((sample >> 8) & 0xff);
|
||||
|
||||
if (nchannels == 2) {
|
||||
sample = scale(*right_ch++);
|
||||
putchar((sample >> 0) & 0xff);
|
||||
putchar((sample >> 8) & 0xff);
|
||||
}
|
||||
}
|
||||
|
||||
return MAD_FLOW_CONTINUE;
|
||||
}
|
||||
|
||||
/*
|
||||
* This is the error callback function. It is called whenever a decoding
|
||||
* error occurs. The error is indicated by stream->error; the list of
|
||||
* possible MAD_ERROR_* errors can be found in the mad.h (or stream.h)
|
||||
* header file.
|
||||
*/
|
||||
|
||||
static
|
||||
enum mad_flow error(void *data,
|
||||
struct mad_stream *stream,
|
||||
struct mad_frame *frame)
|
||||
{
|
||||
struct buffer *buffer = data;
|
||||
|
||||
fprintf(stderr, "decoding error 0x%04x (%s) at byte offset %u\n",
|
||||
stream->error, mad_stream_errorstr(stream),
|
||||
stream->this_frame - buffer->start);
|
||||
|
||||
/* return MAD_FLOW_BREAK here to stop decoding (and propagate an error) */
|
||||
|
||||
return MAD_FLOW_CONTINUE;
|
||||
}
|
||||
|
||||
/*
|
||||
* This is the function called by main() above to perform all the decoding.
|
||||
* It instantiates a decoder object and configures it with the input,
|
||||
* output, and error callback functions above. A single call to
|
||||
* mad_decoder_run() continues until a callback function returns
|
||||
* MAD_FLOW_STOP (to stop decoding) or MAD_FLOW_BREAK (to stop decoding and
|
||||
* signal an error).
|
||||
*/
|
||||
|
||||
static
|
||||
int decode(unsigned char const *start, unsigned long length)
|
||||
{
|
||||
struct buffer buffer;
|
||||
struct mad_decoder decoder;
|
||||
int result;
|
||||
|
||||
/* initialize our private message structure */
|
||||
|
||||
buffer.start = start;
|
||||
buffer.length = length;
|
||||
|
||||
/* configure input, output, and error functions */
|
||||
|
||||
mad_decoder_init(&decoder, &buffer,
|
||||
input, 0 /* header */, 0 /* filter */, output,
|
||||
error, 0 /* message */);
|
||||
|
||||
/* start decoding */
|
||||
|
||||
result = mad_decoder_run(&decoder, MAD_DECODER_MODE_SYNC);
|
||||
|
||||
/* release the decoder */
|
||||
|
||||
mad_decoder_finish(&decoder);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
|
@ -36,7 +36,8 @@ void mad_stream_init(struct mad_stream *stream)
|
|||
{
|
||||
stream->buffer = 0;
|
||||
stream->bufend = 0;
|
||||
stream->skiplen = 0;
|
||||
/* rockbox: not used
|
||||
stream->skiplen = 0; */
|
||||
|
||||
stream->sync = 0;
|
||||
stream->freerate = 0;
|
||||
|
|
@ -62,6 +63,7 @@ void mad_stream_init(struct mad_stream *stream)
|
|||
* NAME: stream->finish()
|
||||
* DESCRIPTION: deallocate any dynamic memory associated with stream
|
||||
*/
|
||||
/* rockbox: not used
|
||||
void mad_stream_finish(struct mad_stream *stream)
|
||||
{
|
||||
if (stream->main_data) {
|
||||
|
|
@ -71,7 +73,7 @@ void mad_stream_finish(struct mad_stream *stream)
|
|||
|
||||
mad_bit_finish(&stream->anc_ptr);
|
||||
mad_bit_finish(&stream->ptr);
|
||||
}
|
||||
} */
|
||||
|
||||
/*
|
||||
* NAME: stream->buffer()
|
||||
|
|
@ -95,10 +97,11 @@ void mad_stream_buffer(struct mad_stream *stream,
|
|||
* NAME: stream->skip()
|
||||
* DESCRIPTION: arrange to skip bytes before the next frame
|
||||
*/
|
||||
/* rockbox: not used
|
||||
void mad_stream_skip(struct mad_stream *stream, unsigned long length)
|
||||
{
|
||||
stream->skiplen += length;
|
||||
}
|
||||
} */
|
||||
|
||||
/*
|
||||
* NAME: stream->sync()
|
||||
|
|
|
|||
|
|
@ -61,7 +61,8 @@ enum mad_error {
|
|||
struct mad_stream {
|
||||
unsigned char const *buffer; /* input bitstream buffer */
|
||||
unsigned char const *bufend; /* end of buffer */
|
||||
unsigned long skiplen; /* bytes to skip before next frame */
|
||||
/* rockbox: not used
|
||||
unsigned long skiplen; */ /* bytes to skip before next frame */
|
||||
|
||||
int sync; /* stream sync found */
|
||||
unsigned long freerate; /* free bitrate (fixed) */
|
||||
|
|
@ -94,14 +95,16 @@ enum {
|
|||
};
|
||||
|
||||
void mad_stream_init(struct mad_stream *);
|
||||
void mad_stream_finish(struct mad_stream *);
|
||||
/* rockbox: not used
|
||||
void mad_stream_finish(struct mad_stream *); */
|
||||
|
||||
# define mad_stream_options(stream, opts) \
|
||||
((void) ((stream)->options = (opts)))
|
||||
|
||||
void mad_stream_buffer(struct mad_stream *,
|
||||
unsigned char const *, unsigned long);
|
||||
void mad_stream_skip(struct mad_stream *, unsigned long);
|
||||
/* rockbox: not used
|
||||
void mad_stream_skip(struct mad_stream *, unsigned long); */
|
||||
|
||||
int mad_stream_sync(struct mad_stream *);
|
||||
|
||||
|
|
|
|||
|
|
@ -41,23 +41,6 @@ struct mad_synth {
|
|||
struct mad_pcm pcm; /* PCM output */
|
||||
};
|
||||
|
||||
/* single channel PCM selector */
|
||||
enum {
|
||||
MAD_PCM_CHANNEL_SINGLE = 0
|
||||
};
|
||||
|
||||
/* dual channel PCM selector */
|
||||
enum {
|
||||
MAD_PCM_CHANNEL_DUAL_1 = 0,
|
||||
MAD_PCM_CHANNEL_DUAL_2 = 1
|
||||
};
|
||||
|
||||
/* stereo PCM selector */
|
||||
enum {
|
||||
MAD_PCM_CHANNEL_STEREO_LEFT = 0,
|
||||
MAD_PCM_CHANNEL_STEREO_RIGHT = 1
|
||||
};
|
||||
|
||||
void mad_synth_init(struct mad_synth *);
|
||||
|
||||
# define mad_synth_finish(synth) /* nothing */
|
||||
|
|
|
|||
|
|
@ -1,488 +0,0 @@
|
|||
/*
|
||||
* libmad - MPEG audio decoder library
|
||||
* Copyright (C) 2000-2004 Underbit Technologies, Inc.
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*
|
||||
* $Id$
|
||||
*/
|
||||
|
||||
# ifdef HAVE_CONFIG_H
|
||||
# include "config.h"
|
||||
# endif
|
||||
|
||||
# include "global.h"
|
||||
|
||||
# include <stdio.h>
|
||||
|
||||
# ifdef HAVE_ASSERT_H
|
||||
# include <assert.h>
|
||||
# endif
|
||||
|
||||
# include "timer.h"
|
||||
|
||||
mad_timer_t const mad_timer_zero = { 0, 0 };
|
||||
|
||||
/*
|
||||
* NAME: timer->compare()
|
||||
* DESCRIPTION: indicate relative order of two timers
|
||||
*/
|
||||
int mad_timer_compare(mad_timer_t timer1, mad_timer_t timer2)
|
||||
{
|
||||
signed long diff;
|
||||
|
||||
diff = timer1.seconds - timer2.seconds;
|
||||
if (diff < 0)
|
||||
return -1;
|
||||
else if (diff > 0)
|
||||
return +1;
|
||||
|
||||
diff = timer1.fraction - timer2.fraction;
|
||||
if (diff < 0)
|
||||
return -1;
|
||||
else if (diff > 0)
|
||||
return +1;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* NAME: timer->negate()
|
||||
* DESCRIPTION: invert the sign of a timer
|
||||
*/
|
||||
void mad_timer_negate(mad_timer_t *timer)
|
||||
{
|
||||
timer->seconds = -timer->seconds;
|
||||
|
||||
if (timer->fraction) {
|
||||
timer->seconds -= 1;
|
||||
timer->fraction = MAD_TIMER_RESOLUTION - timer->fraction;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* NAME: timer->abs()
|
||||
* DESCRIPTION: return the absolute value of a timer
|
||||
*/
|
||||
mad_timer_t mad_timer_abs(mad_timer_t timer)
|
||||
{
|
||||
if (timer.seconds < 0)
|
||||
mad_timer_negate(&timer);
|
||||
|
||||
return timer;
|
||||
}
|
||||
|
||||
/*
|
||||
* NAME: reduce_timer()
|
||||
* DESCRIPTION: carry timer fraction into seconds
|
||||
*/
|
||||
static
|
||||
void reduce_timer(mad_timer_t *timer)
|
||||
{
|
||||
timer->seconds += timer->fraction / MAD_TIMER_RESOLUTION;
|
||||
timer->fraction %= MAD_TIMER_RESOLUTION;
|
||||
}
|
||||
|
||||
/*
|
||||
* NAME: gcd()
|
||||
* DESCRIPTION: compute greatest common denominator
|
||||
*/
|
||||
static
|
||||
unsigned long gcd(unsigned long num1, unsigned long num2)
|
||||
{
|
||||
unsigned long tmp;
|
||||
|
||||
while (num2) {
|
||||
tmp = num2;
|
||||
num2 = num1 % num2;
|
||||
num1 = tmp;
|
||||
}
|
||||
|
||||
return num1;
|
||||
}
|
||||
|
||||
/*
|
||||
* NAME: reduce_rational()
|
||||
* DESCRIPTION: convert rational expression to lowest terms
|
||||
*/
|
||||
static
|
||||
void reduce_rational(unsigned long *numer, unsigned long *denom)
|
||||
{
|
||||
unsigned long factor;
|
||||
|
||||
factor = gcd(*numer, *denom);
|
||||
|
||||
assert(factor != 0);
|
||||
|
||||
*numer /= factor;
|
||||
*denom /= factor;
|
||||
}
|
||||
|
||||
/*
|
||||
* NAME: scale_rational()
|
||||
* DESCRIPTION: solve numer/denom == ?/scale avoiding overflowing
|
||||
*/
|
||||
static
|
||||
unsigned long scale_rational(unsigned long numer, unsigned long denom,
|
||||
unsigned long scale)
|
||||
{
|
||||
reduce_rational(&numer, &denom);
|
||||
reduce_rational(&scale, &denom);
|
||||
|
||||
assert(denom != 0);
|
||||
|
||||
if (denom < scale)
|
||||
return numer * (scale / denom) + numer * (scale % denom) / denom;
|
||||
if (denom < numer)
|
||||
return scale * (numer / denom) + scale * (numer % denom) / denom;
|
||||
|
||||
return numer * scale / denom;
|
||||
}
|
||||
|
||||
/*
|
||||
* NAME: timer->set()
|
||||
* DESCRIPTION: set timer to specific (positive) value
|
||||
*/
|
||||
void mad_timer_set(mad_timer_t *timer, unsigned long seconds,
|
||||
unsigned long numer, unsigned long denom)
|
||||
{
|
||||
timer->seconds = seconds;
|
||||
if (numer >= denom && denom > 0) {
|
||||
timer->seconds += numer / denom;
|
||||
numer %= denom;
|
||||
}
|
||||
|
||||
switch (denom) {
|
||||
case 0:
|
||||
case 1:
|
||||
timer->fraction = 0;
|
||||
break;
|
||||
|
||||
case MAD_TIMER_RESOLUTION:
|
||||
timer->fraction = numer;
|
||||
break;
|
||||
|
||||
case 1000:
|
||||
timer->fraction = numer * (MAD_TIMER_RESOLUTION / 1000);
|
||||
break;
|
||||
|
||||
case 8000:
|
||||
timer->fraction = numer * (MAD_TIMER_RESOLUTION / 8000);
|
||||
break;
|
||||
|
||||
case 11025:
|
||||
timer->fraction = numer * (MAD_TIMER_RESOLUTION / 11025);
|
||||
break;
|
||||
|
||||
case 12000:
|
||||
timer->fraction = numer * (MAD_TIMER_RESOLUTION / 12000);
|
||||
break;
|
||||
|
||||
case 16000:
|
||||
timer->fraction = numer * (MAD_TIMER_RESOLUTION / 16000);
|
||||
break;
|
||||
|
||||
case 22050:
|
||||
timer->fraction = numer * (MAD_TIMER_RESOLUTION / 22050);
|
||||
break;
|
||||
|
||||
case 24000:
|
||||
timer->fraction = numer * (MAD_TIMER_RESOLUTION / 24000);
|
||||
break;
|
||||
|
||||
case 32000:
|
||||
timer->fraction = numer * (MAD_TIMER_RESOLUTION / 32000);
|
||||
break;
|
||||
|
||||
case 44100:
|
||||
timer->fraction = numer * (MAD_TIMER_RESOLUTION / 44100);
|
||||
break;
|
||||
|
||||
case 48000:
|
||||
timer->fraction = numer * (MAD_TIMER_RESOLUTION / 48000);
|
||||
break;
|
||||
|
||||
default:
|
||||
timer->fraction = scale_rational(numer, denom, MAD_TIMER_RESOLUTION);
|
||||
break;
|
||||
}
|
||||
|
||||
if (timer->fraction >= MAD_TIMER_RESOLUTION)
|
||||
reduce_timer(timer);
|
||||
}
|
||||
|
||||
/*
|
||||
* NAME: timer->add()
|
||||
* DESCRIPTION: add one timer to another
|
||||
*/
|
||||
void mad_timer_add(mad_timer_t *timer, mad_timer_t incr)
|
||||
{
|
||||
timer->seconds += incr.seconds;
|
||||
timer->fraction += incr.fraction;
|
||||
|
||||
if (timer->fraction >= MAD_TIMER_RESOLUTION)
|
||||
reduce_timer(timer);
|
||||
}
|
||||
|
||||
/*
|
||||
* NAME: timer->multiply()
|
||||
* DESCRIPTION: multiply a timer by a scalar value
|
||||
*/
|
||||
void mad_timer_multiply(mad_timer_t *timer, signed long scalar)
|
||||
{
|
||||
mad_timer_t addend;
|
||||
unsigned long factor;
|
||||
|
||||
factor = scalar;
|
||||
if (scalar < 0) {
|
||||
factor = -scalar;
|
||||
mad_timer_negate(timer);
|
||||
}
|
||||
|
||||
addend = *timer;
|
||||
*timer = mad_timer_zero;
|
||||
|
||||
while (factor) {
|
||||
if (factor & 1)
|
||||
mad_timer_add(timer, addend);
|
||||
|
||||
mad_timer_add(&addend, addend);
|
||||
factor >>= 1;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* NAME: timer->count()
|
||||
* DESCRIPTION: return timer value in selected units
|
||||
*/
|
||||
signed long mad_timer_count(mad_timer_t timer, enum mad_units units)
|
||||
{
|
||||
switch (units) {
|
||||
case MAD_UNITS_HOURS:
|
||||
return timer.seconds / 60 / 60;
|
||||
|
||||
case MAD_UNITS_MINUTES:
|
||||
return timer.seconds / 60;
|
||||
|
||||
case MAD_UNITS_SECONDS:
|
||||
return timer.seconds;
|
||||
|
||||
case MAD_UNITS_DECISECONDS:
|
||||
case MAD_UNITS_CENTISECONDS:
|
||||
case MAD_UNITS_MILLISECONDS:
|
||||
|
||||
case MAD_UNITS_8000_HZ:
|
||||
case MAD_UNITS_11025_HZ:
|
||||
case MAD_UNITS_12000_HZ:
|
||||
case MAD_UNITS_16000_HZ:
|
||||
case MAD_UNITS_22050_HZ:
|
||||
case MAD_UNITS_24000_HZ:
|
||||
case MAD_UNITS_32000_HZ:
|
||||
case MAD_UNITS_44100_HZ:
|
||||
case MAD_UNITS_48000_HZ:
|
||||
|
||||
case MAD_UNITS_24_FPS:
|
||||
case MAD_UNITS_25_FPS:
|
||||
case MAD_UNITS_30_FPS:
|
||||
case MAD_UNITS_48_FPS:
|
||||
case MAD_UNITS_50_FPS:
|
||||
case MAD_UNITS_60_FPS:
|
||||
case MAD_UNITS_75_FPS:
|
||||
return timer.seconds * (signed long) units +
|
||||
(signed long) scale_rational(timer.fraction, MAD_TIMER_RESOLUTION,
|
||||
units);
|
||||
|
||||
case MAD_UNITS_23_976_FPS:
|
||||
case MAD_UNITS_24_975_FPS:
|
||||
case MAD_UNITS_29_97_FPS:
|
||||
case MAD_UNITS_47_952_FPS:
|
||||
case MAD_UNITS_49_95_FPS:
|
||||
case MAD_UNITS_59_94_FPS:
|
||||
return (mad_timer_count(timer, -units) + 1) * 1000 / 1001;
|
||||
}
|
||||
|
||||
/* unsupported units */
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* NAME: timer->fraction()
|
||||
* DESCRIPTION: return fractional part of timer in arbitrary terms
|
||||
*/
|
||||
unsigned long mad_timer_fraction(mad_timer_t timer, unsigned long denom)
|
||||
{
|
||||
timer = mad_timer_abs(timer);
|
||||
|
||||
switch (denom) {
|
||||
case 0:
|
||||
return timer.fraction ?
|
||||
MAD_TIMER_RESOLUTION / timer.fraction : MAD_TIMER_RESOLUTION + 1;
|
||||
|
||||
case MAD_TIMER_RESOLUTION:
|
||||
return timer.fraction;
|
||||
|
||||
default:
|
||||
return scale_rational(timer.fraction, MAD_TIMER_RESOLUTION, denom);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* NAME: timer->string()
|
||||
* DESCRIPTION: write a string representation of a timer using a template
|
||||
*/
|
||||
void mad_timer_string(mad_timer_t timer,
|
||||
char *dest, char const *format, enum mad_units units,
|
||||
enum mad_units fracunits, unsigned long subparts)
|
||||
{
|
||||
unsigned long hours, minutes, seconds, sub;
|
||||
unsigned int frac;
|
||||
|
||||
timer = mad_timer_abs(timer);
|
||||
|
||||
seconds = timer.seconds;
|
||||
frac = sub = 0;
|
||||
|
||||
dest[0]=0;
|
||||
(void)format;
|
||||
|
||||
switch (fracunits) {
|
||||
case MAD_UNITS_HOURS:
|
||||
case MAD_UNITS_MINUTES:
|
||||
case MAD_UNITS_SECONDS:
|
||||
break;
|
||||
|
||||
case MAD_UNITS_DECISECONDS:
|
||||
case MAD_UNITS_CENTISECONDS:
|
||||
case MAD_UNITS_MILLISECONDS:
|
||||
|
||||
case MAD_UNITS_8000_HZ:
|
||||
case MAD_UNITS_11025_HZ:
|
||||
case MAD_UNITS_12000_HZ:
|
||||
case MAD_UNITS_16000_HZ:
|
||||
case MAD_UNITS_22050_HZ:
|
||||
case MAD_UNITS_24000_HZ:
|
||||
case MAD_UNITS_32000_HZ:
|
||||
case MAD_UNITS_44100_HZ:
|
||||
case MAD_UNITS_48000_HZ:
|
||||
|
||||
case MAD_UNITS_24_FPS:
|
||||
case MAD_UNITS_25_FPS:
|
||||
case MAD_UNITS_30_FPS:
|
||||
case MAD_UNITS_48_FPS:
|
||||
case MAD_UNITS_50_FPS:
|
||||
case MAD_UNITS_60_FPS:
|
||||
case MAD_UNITS_75_FPS:
|
||||
{
|
||||
unsigned long denom;
|
||||
|
||||
denom = MAD_TIMER_RESOLUTION / fracunits;
|
||||
|
||||
frac = timer.fraction / denom;
|
||||
sub = scale_rational(timer.fraction % denom, denom, subparts);
|
||||
}
|
||||
break;
|
||||
|
||||
case MAD_UNITS_23_976_FPS:
|
||||
case MAD_UNITS_24_975_FPS:
|
||||
case MAD_UNITS_29_97_FPS:
|
||||
case MAD_UNITS_47_952_FPS:
|
||||
case MAD_UNITS_49_95_FPS:
|
||||
case MAD_UNITS_59_94_FPS:
|
||||
/* drop-frame encoding */
|
||||
/* N.B. this is only well-defined for MAD_UNITS_29_97_FPS */
|
||||
{
|
||||
unsigned long frame, cycle, d, m;
|
||||
|
||||
frame = mad_timer_count(timer, fracunits);
|
||||
|
||||
cycle = -fracunits * 60 * 10 - (10 - 1) * 2;
|
||||
|
||||
d = frame / cycle;
|
||||
m = frame % cycle;
|
||||
frame += (10 - 1) * 2 * d;
|
||||
if (m > 2)
|
||||
frame += 2 * ((m - 2) / (cycle / 10));
|
||||
|
||||
frac = frame % -fracunits;
|
||||
seconds = frame / -fracunits;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
switch (units) {
|
||||
case MAD_UNITS_HOURS:
|
||||
minutes = seconds / 60;
|
||||
hours = minutes / 60;
|
||||
|
||||
// sprintf(dest, format,
|
||||
// hours,
|
||||
// (unsigned int) (minutes % 60),
|
||||
// (unsigned int) (seconds % 60),
|
||||
// frac, sub);
|
||||
break;
|
||||
|
||||
case MAD_UNITS_MINUTES:
|
||||
minutes = seconds / 60;
|
||||
|
||||
// sprintf(dest, format,
|
||||
// minutes,
|
||||
// (unsigned int) (seconds % 60),
|
||||
// frac, sub);
|
||||
break;
|
||||
|
||||
case MAD_UNITS_SECONDS:
|
||||
// sprintf(dest, format,
|
||||
// seconds,
|
||||
// frac, sub);
|
||||
break;
|
||||
|
||||
case MAD_UNITS_23_976_FPS:
|
||||
case MAD_UNITS_24_975_FPS:
|
||||
case MAD_UNITS_29_97_FPS:
|
||||
case MAD_UNITS_47_952_FPS:
|
||||
case MAD_UNITS_49_95_FPS:
|
||||
case MAD_UNITS_59_94_FPS:
|
||||
if (fracunits < 0) {
|
||||
/* not yet implemented */
|
||||
sub = 0;
|
||||
}
|
||||
|
||||
/* fall through */
|
||||
|
||||
case MAD_UNITS_DECISECONDS:
|
||||
case MAD_UNITS_CENTISECONDS:
|
||||
case MAD_UNITS_MILLISECONDS:
|
||||
|
||||
case MAD_UNITS_8000_HZ:
|
||||
case MAD_UNITS_11025_HZ:
|
||||
case MAD_UNITS_12000_HZ:
|
||||
case MAD_UNITS_16000_HZ:
|
||||
case MAD_UNITS_22050_HZ:
|
||||
case MAD_UNITS_24000_HZ:
|
||||
case MAD_UNITS_32000_HZ:
|
||||
case MAD_UNITS_44100_HZ:
|
||||
case MAD_UNITS_48000_HZ:
|
||||
|
||||
case MAD_UNITS_24_FPS:
|
||||
case MAD_UNITS_25_FPS:
|
||||
case MAD_UNITS_30_FPS:
|
||||
case MAD_UNITS_48_FPS:
|
||||
case MAD_UNITS_50_FPS:
|
||||
case MAD_UNITS_60_FPS:
|
||||
case MAD_UNITS_75_FPS:
|
||||
// sprintf(dest, format, mad_timer_count(timer, units), sub);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
|
@ -1,100 +0,0 @@
|
|||
/*
|
||||
* libmad - MPEG audio decoder library
|
||||
* Copyright (C) 2000-2004 Underbit Technologies, Inc.
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*
|
||||
* $Id$
|
||||
*/
|
||||
|
||||
# ifndef LIBMAD_TIMER_H
|
||||
# define LIBMAD_TIMER_H
|
||||
|
||||
typedef struct {
|
||||
signed long seconds; /* whole seconds */
|
||||
unsigned long fraction; /* 1/MAD_TIMER_RESOLUTION seconds */
|
||||
} mad_timer_t;
|
||||
|
||||
extern mad_timer_t const mad_timer_zero;
|
||||
|
||||
# define MAD_TIMER_RESOLUTION 352800000UL
|
||||
|
||||
enum mad_units {
|
||||
MAD_UNITS_HOURS = -2,
|
||||
MAD_UNITS_MINUTES = -1,
|
||||
MAD_UNITS_SECONDS = 0,
|
||||
|
||||
/* metric units */
|
||||
|
||||
MAD_UNITS_DECISECONDS = 10,
|
||||
MAD_UNITS_CENTISECONDS = 100,
|
||||
MAD_UNITS_MILLISECONDS = 1000,
|
||||
|
||||
/* audio sample units */
|
||||
|
||||
MAD_UNITS_8000_HZ = 8000,
|
||||
MAD_UNITS_11025_HZ = 11025,
|
||||
MAD_UNITS_12000_HZ = 12000,
|
||||
|
||||
MAD_UNITS_16000_HZ = 16000,
|
||||
MAD_UNITS_22050_HZ = 22050,
|
||||
MAD_UNITS_24000_HZ = 24000,
|
||||
|
||||
MAD_UNITS_32000_HZ = 32000,
|
||||
MAD_UNITS_44100_HZ = 44100,
|
||||
MAD_UNITS_48000_HZ = 48000,
|
||||
|
||||
/* video frame/field units */
|
||||
|
||||
MAD_UNITS_24_FPS = 24,
|
||||
MAD_UNITS_25_FPS = 25,
|
||||
MAD_UNITS_30_FPS = 30,
|
||||
MAD_UNITS_48_FPS = 48,
|
||||
MAD_UNITS_50_FPS = 50,
|
||||
MAD_UNITS_60_FPS = 60,
|
||||
|
||||
/* CD audio frames */
|
||||
|
||||
MAD_UNITS_75_FPS = 75,
|
||||
|
||||
/* video drop-frame units */
|
||||
|
||||
MAD_UNITS_23_976_FPS = -24,
|
||||
MAD_UNITS_24_975_FPS = -25,
|
||||
MAD_UNITS_29_97_FPS = -30,
|
||||
MAD_UNITS_47_952_FPS = -48,
|
||||
MAD_UNITS_49_95_FPS = -50,
|
||||
MAD_UNITS_59_94_FPS = -60
|
||||
};
|
||||
|
||||
# define mad_timer_reset(timer) ((void) (*(timer) = mad_timer_zero))
|
||||
|
||||
int mad_timer_compare(mad_timer_t, mad_timer_t);
|
||||
|
||||
# define mad_timer_sign(timer) mad_timer_compare((timer), mad_timer_zero)
|
||||
|
||||
void mad_timer_negate(mad_timer_t *);
|
||||
mad_timer_t mad_timer_abs(mad_timer_t);
|
||||
|
||||
void mad_timer_set(mad_timer_t *, unsigned long, unsigned long, unsigned long);
|
||||
void mad_timer_add(mad_timer_t *, mad_timer_t);
|
||||
void mad_timer_multiply(mad_timer_t *, signed long);
|
||||
|
||||
signed long mad_timer_count(mad_timer_t, enum mad_units);
|
||||
unsigned long mad_timer_fraction(mad_timer_t, unsigned long);
|
||||
void mad_timer_string(mad_timer_t, char *, char const *,
|
||||
enum mad_units, enum mad_units, unsigned long);
|
||||
|
||||
# endif
|
||||
|
|
@ -1,74 +0,0 @@
|
|||
/*
|
||||
* libmad - MPEG audio decoder library
|
||||
* Copyright (C) 2000-2004 Underbit Technologies, Inc.
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*
|
||||
* $Id$
|
||||
*/
|
||||
|
||||
# ifdef HAVE_CONFIG_H
|
||||
# include "config.h"
|
||||
# endif
|
||||
|
||||
# include "global.h"
|
||||
|
||||
# include "version.h"
|
||||
|
||||
char const mad_version[] = "MPEG Audio Decoder " MAD_VERSION;
|
||||
char const mad_copyright[] = "Copyright (C) " MAD_PUBLISHYEAR " " MAD_AUTHOR;
|
||||
char const mad_author[] = MAD_AUTHOR " <" MAD_EMAIL ">";
|
||||
|
||||
char const mad_build[] = ""
|
||||
# if defined(DEBUG)
|
||||
"DEBUG "
|
||||
# elif defined(NDEBUG)
|
||||
"NDEBUG "
|
||||
# endif
|
||||
|
||||
# if defined(EXPERIMENTAL)
|
||||
"EXPERIMENTAL "
|
||||
# endif
|
||||
|
||||
# if defined(FPM_64BIT)
|
||||
"FPM_64BIT "
|
||||
# elif defined(FPM_INTEL)
|
||||
"FPM_INTEL "
|
||||
# elif defined(FPM_ARM)
|
||||
"FPM_ARM "
|
||||
# elif defined(FPM_MIPS)
|
||||
"FPM_MIPS "
|
||||
# elif defined(FPM_SPARC)
|
||||
"FPM_SPARC "
|
||||
# elif defined(FPM_PPC)
|
||||
"FPM_PPC "
|
||||
# elif defined(FPM_DEFAULT)
|
||||
"FPM_DEFAULT "
|
||||
# endif
|
||||
|
||||
# if defined(OPT_SPEED)
|
||||
"OPT_SPEED "
|
||||
# elif defined(OPT_ACCURACY)
|
||||
"OPT_ACCURACY "
|
||||
# endif
|
||||
|
||||
# if defined(OPT_SSO)
|
||||
"OPT_SSO "
|
||||
# endif
|
||||
|
||||
# if defined(OPT_STRICT)
|
||||
"OPT_STRICT "
|
||||
# endif
|
||||
;
|
||||
|
|
@ -1,47 +0,0 @@
|
|||
/*
|
||||
* libmad - MPEG audio decoder library
|
||||
* Copyright (C) 2000-2004 Underbit Technologies, Inc.
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*
|
||||
* $Id$
|
||||
*/
|
||||
|
||||
# ifndef LIBMAD_VERSION_H
|
||||
# define LIBMAD_VERSION_H
|
||||
|
||||
# define MAD_VERSION_MAJOR 0
|
||||
# define MAD_VERSION_MINOR 15
|
||||
# define MAD_VERSION_PATCH 1
|
||||
# define MAD_VERSION_EXTRA " (beta)"
|
||||
|
||||
# define MAD_VERSION_STRINGIZE(str) #str
|
||||
# define MAD_VERSION_STRING(num) MAD_VERSION_STRINGIZE(num)
|
||||
|
||||
# define MAD_VERSION MAD_VERSION_STRING(MAD_VERSION_MAJOR) "." \
|
||||
MAD_VERSION_STRING(MAD_VERSION_MINOR) "." \
|
||||
MAD_VERSION_STRING(MAD_VERSION_PATCH) \
|
||||
MAD_VERSION_EXTRA
|
||||
|
||||
# define MAD_PUBLISHYEAR "2000-2004"
|
||||
# define MAD_AUTHOR "Underbit Technologies, Inc."
|
||||
# define MAD_EMAIL "info@underbit.com"
|
||||
|
||||
extern char const mad_version[];
|
||||
extern char const mad_copyright[];
|
||||
extern char const mad_author[];
|
||||
extern char const mad_build[];
|
||||
|
||||
# endif
|
||||
Loading…
Add table
Add a link
Reference in a new issue