1 files changed, 13 insertions, 1 deletions

diff --git a/core/multimedia/opieplayer/libmad/decoder.c b/core/multimedia/opieplayer/libmad/decoder.c
index b2b6cbb..d039bfb 100644
--- a/core/multimedia/opieplayer/libmad/decoder.c
+++ b/core/multimedia/opieplayer/libmad/decoder.c
@@ -1,27 +1,27 @@
 /*
  * libmad - MPEG audio decoder library
- * Copyright (C) 2000-2001 Robert Leslie
+ * 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 "libmad_config.h"
 # endif
 
 # include "libmad_global.h"
 
@@ -31,48 +31,52 @@
 
 # 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
 
 # include <stdlib.h>
 
 # ifdef HAVE_ERRNO_H
 #  include <errno.h>
 # endif
 
 # include "stream.h"
 # include "frame.h"
 # include "synth.h"
 # include "decoder.h"
 
+/*
+         * 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;
@@ -501,70 +505,78 @@ int run_async(struct mad_decoder *decoder)
     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
   return -1;
 # endif
 }