summaryrefslogtreecommitdiff
path: root/core/multimedia/opieplayer/libmad/decoder.c
Side-by-side diff
Diffstat (limited to 'core/multimedia/opieplayer/libmad/decoder.c') (more/less context) (ignore whitespace changes)
-rw-r--r--core/multimedia/opieplayer/libmad/decoder.c60
1 files changed, 38 insertions, 22 deletions
diff --git a/core/multimedia/opieplayer/libmad/decoder.c b/core/multimedia/opieplayer/libmad/decoder.c
index dcf7cf3..b2b6cbb 100644
--- a/core/multimedia/opieplayer/libmad/decoder.c
+++ b/core/multimedia/opieplayer/libmad/decoder.c
@@ -1,74 +1,79 @@
/*
- * mad - MPEG audio decoder
+ * libmad - MPEG audio decoder library
* Copyright (C) 2000-2001 Robert Leslie
*
* 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 "libmad_config.h"
-# else
-# ifndef WEXITSTATUS
-# define WEXITSTATUS(stat_val) ((unsigned)(stat_val) >> 8)
-# endif
-# ifndef WIFEXITED
-# define WIFEXITED(stat_val) (((stat_val) & 255) == 0)
-# endif
+# include "libmad_config.h"
# endif
# include "libmad_global.h"
-# include <sys/types.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
-# include <fcntl.h>
+# ifdef HAVE_FCNTL_H
+# include <fcntl.h>
+# endif
+
# include <stdlib.h>
-# include <errno.h>
+
+# ifdef HAVE_ERRNO_H
+# include <errno.h>
+# endif
# include "stream.h"
# include "frame.h"
# include "synth.h"
# include "decoder.h"
void mad_decoder_init(struct mad_decoder *decoder, void *data,
- enum mad_flow (*input_func)(void *, struct mad_stream *),
+ 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_frame *),
+ 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 *,
+ 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;
@@ -77,84 +82,84 @@ void mad_decoder_init(struct mad_decoder *decoder, void *data,
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 {
+ 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;
}
+# 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 {
+ 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 {
+ 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;
@@ -272,24 +277,25 @@ enum mad_flow check_message(struct mad_decoder *decoder)
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
@@ -339,35 +345,37 @@ int run_sync(struct mad_decoder *decoder)
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:
@@ -400,25 +408,25 @@ int run_sync(struct mad_decoder *decoder)
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, frame)) {
+ 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);
@@ -441,24 +449,25 @@ int run_sync(struct mad_decoder *decoder)
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]);
@@ -502,53 +511,60 @@ int run_async(struct mad_decoder *decoder)
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
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;
}
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
+ return -1;
+# endif
}