Added debian extra dependency packages.

Signed-off-by: Michele Calgaro <michele.calgaro@yahoo.it>

1 files changed, 1215 insertions, 0 deletions

diff --git a/debian/transcode/transcode-1.1.7/export/aud_aux.c b/debian/transcode/transcode-1.1.7/export/aud_aux.c
new file mode 100644
index 00000000..8ca4421c
--- /dev/null
+++ b/debian/transcode/transcode-1.1.7/export/aud_aux.c
@@ -0,0 +1,1215 @@
+/*
+ *  aud_aux.c
+ *
+ *  Copyright (C) Thomas Oestreich - June 2001
+ *  Copyright (C) Nicolas LAURENT - August 2003
+ *
+ *  This file is part of transcode, a video stream processing tool
+ *
+ *  transcode 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, or (at your option)
+ *  any later version.
+ *
+ *  transcode 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 GNU Make; see the file COPYING.  If not, write to
+ *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+
+#include "transcode.h"
+#include "aud_aux.h"
+
+#include "libtc/libtc.h"
+
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <stdint.h>
+#include <assert.h>
+
+#ifdef HAVE_LAME
+#ifdef HAVE_LAME_INC
+#include <lame/lame.h>
+#else
+#include <lame.h>
+#endif
+#endif
+
+#ifdef HAVE_FFMPEG
+#include "libtc/tcavcodec.h"
+
+
+static AVCodec        *mpa_codec = NULL;
+static AVCodecContext mpa_ctx;
+static char           *mpa_buf     = NULL;
+static int            mpa_buf_ptr  = 0;
+static int            mpa_bytes_ps, mpa_bytes_pf;
+
+#endif
+
+/*
+ * Capabilities:
+ *
+ *             +-------------------------------+
+ *             |             Output            |
+ *             +-------------------------------+
+ *             |  PCM  |  MP2  |  MP3  |  AC3  |
+ * +---+-------+-------+-------+-------+-------+
+ * | I |  PCM  |   X   |   X   |   X   |   X   |
+ * | n +-------+-------+-------+-------+-------+
+ * | p |  MP2  |       |   X   |       |       |
+ * | u +-------+-------+-------+-------+-------+
+ * | t |  MP3  |       |       |   X   |       |
+ * |   +-------+-------+-------+-------+-------+
+ * |   |  AC3  |       |       |       |   X   |
+ * +---+---------------------------------------+
+ *
+ */
+
+
+/*-----------------------------------------------------------------------------
+                       G L O B A L   V A R I A B L E S
+-----------------------------------------------------------------------------*/
+
+#define MP3_CHUNK_SZ (2*1152)
+
+static int verbose_flag=TC_DEBUG;
+#define IS_AUDIO_MONO   (avi_aud_chan == 1)
+#ifdef HAVE_LAME
+#define IS_VBR      (lame_get_VBR(lgf) != vbr_off)
+#endif
+
+/* Output buffer */
+#define OUTPUT_SIZE SIZE_PCM_FRAME
+static char *output   = NULL;
+#ifdef HAVE_LAME
+static int output_len = 0;
+#endif
+
+/* Input buffer */
+#define INPUT_SIZE  SIZE_PCM_FRAME
+static char *input   = NULL;
+#ifdef HAVE_LAME
+static int input_len = 0;
+#endif
+
+/* encoder */
+static int (*tc_audio_encode_function)(char *, int, avi_t *)=NULL;
+#ifdef HAVE_LAME
+static lame_global_flags *lgf;
+#endif
+static int lame_flush=0;
+static int bitrate=0;
+
+/* output stream */
+static avi_t *avifile2=NULL;
+static FILE *fd=NULL;
+static int is_pipe = 0;
+
+// AVI file information for subsequent calls of open routine:
+static int avi_aud_codec, avi_aud_bitrate;
+static long avi_aud_rate;
+static int avi_aud_chan, avi_aud_bits;
+
+/*-----------------------------------------------------------------------------
+                             P R O T O T Y P E S
+-----------------------------------------------------------------------------*/
+
+static int tc_audio_init_ffmpeg(vob_t *vob, int o_codec);
+static int tc_audio_init_lame(vob_t *vob, int o_codec);
+static int tc_audio_init_raw(vob_t *vob);
+static int tc_audio_write(char *buffer, size_t size, avi_t *avifile);
+static int tc_audio_encode_ffmpeg(char *aud_buffer, int aud_size, avi_t *avifile);
+static int tc_audio_encode_mp3(char *aud_buffer, int aud_size, avi_t *avifile);
+static int tc_audio_pass_through(char *aud_buffer, int aud_size, avi_t *avifile);
+static int tc_audio_pass_through_ac3(char *aud_buffer, int aud_size, avi_t *avifile);
+static int tc_audio_pass_through_pcm(char *aud_buffer, int aud_size, avi_t *avifile);
+static int tc_audio_mute(char *aud_buffer, int aud_size, avi_t *avifile);
+#ifdef HAVE_LAME
+static char * lame_error2str(int error);
+static void no_debug(const char *format, va_list ap) {return;}
+static int tc_get_mp3_header(unsigned char* hbuf, int* chans, int* srate);
+#endif
+
+/**
+ * Init Lame Encoder
+ *
+ * @param vob
+ *
+ * @return TC_EXPORT_OK or TC_EXPORT_ERROR
+ */
+static int tc_audio_init_lame(vob_t *vob, int o_codec)
+{
+    static int initialized=0;
+    int res = TC_EXPORT_ERROR;
+
+    if (!initialized)
+        if (verbose_flag & TC_DEBUG)
+            tc_info("Audio: using new version");
+
+    if(initialized==0)
+    {
+#ifdef HAVE_LAME
+        int preset = 0;
+        lgf=lame_init();
+        if(lgf<0)
+        {
+            tc_warn("Lame encoder init failed.");
+            return(TC_EXPORT_ERROR);
+        }
+
+        if(!(verbose_flag & TC_DEBUG)) lame_set_msgf  (lgf, no_debug);
+        if(!(verbose_flag & TC_DEBUG)) lame_set_debugf(lgf, no_debug);
+        if(!(verbose_flag & TC_DEBUG)) lame_set_errorf(lgf, no_debug);
+
+        lame_set_bWriteVbrTag(lgf, 0);
+        lame_set_quality(lgf, vob->mp3quality);
+
+        /* Setting bitrate */
+        if(vob->a_vbr)
+        { /* VBR */
+            lame_set_VBR(lgf, vob->a_vbr);
+            /*  1 = best vbr q  6=~128k */
+            lame_set_VBR_q(lgf, vob->mp3quality);
+            /*
+             * if(vob->mp3bitrate>0)
+             *  lame_set_VBR_mean_bitrate_kbps(
+             *      lgf,
+             *      vob->mp3bitrate);
+             */
+        } else {
+            lame_set_VBR(lgf, 0);
+            lame_set_brate(lgf, vob->mp3bitrate);
+        }
+
+        /* Playing with bitreservoir */
+        if(vob->bitreservoir == TC_FALSE)
+            lame_set_disable_reservoir(lgf, 1);
+
+        /* Mono / Sterero ? */
+        if (IS_AUDIO_MONO)
+        {
+            lame_set_num_channels(lgf, avi_aud_chan);
+            lame_set_mode(lgf, MONO);
+        } else {
+            lame_set_num_channels(lgf, 2);
+            lame_set_mode(lgf, JOINT_STEREO);
+        }
+        /* Overide defaults */
+        if (vob->mp3mode==1)
+            lame_set_mode(lgf, STEREO);
+        if (vob->mp3mode==2)
+            lame_set_mode(lgf, MONO);
+
+        /* sample rate */
+        lame_set_in_samplerate(lgf, vob->a_rate);
+        lame_set_out_samplerate(lgf, avi_aud_rate);
+
+        /* Optimisations */
+        if(tc_accel & AC_MMX)
+            lame_set_asm_optimizations(lgf, MMX, 1);
+
+        if(tc_accel & AC_3DNOW)
+            lame_set_asm_optimizations(lgf, AMD_3DNOW, 1);
+
+        if(tc_accel & AC_SSE)
+            lame_set_asm_optimizations(lgf, SSE, 1);
+
+
+        /* Preset stuff */
+        if (vob->lame_preset && strlen (vob->lame_preset))
+        {
+            char *c = strchr (vob->lame_preset, ',');
+            int fast = 0;
+
+            if (c && *c && *(c+1)) {
+                if (strcmp(c+1, "fast"))
+                {
+                    *c = '\0';
+                    fast = 1;
+                }
+            }
+
+            if (strcmp (vob->lame_preset, "standard") == 0)
+            {
+                preset = fast?STANDARD_FAST:STANDARD;
+                vob->a_vbr = 1;
+            }
+            else if (strcmp (vob->lame_preset, "medium") == 0)
+            {
+                preset = fast?MEDIUM_FAST:MEDIUM;
+                vob->a_vbr = 1;
+            }
+            else if (strcmp (vob->lame_preset, "extreme") == 0)
+            {
+                preset = fast?EXTREME_FAST:EXTREME;
+                vob->a_vbr = 1;
+            }
+            else if (strcmp (vob->lame_preset, "insane") == 0) {
+                preset = INSANE;
+                vob->a_vbr = 1;
+            }
+            else if ( atoi(vob->lame_preset) != 0)
+            {
+                vob->a_vbr = 1;
+                preset = atoi(vob->lame_preset);
+                avi_aud_bitrate = preset;
+            }
+            else
+                tc_warn("Lame preset `%s' not supported. "
+                        "Falling back defaults.",
+                        vob->lame_preset);
+
+            if (fast == 1)
+                *c = ',';
+
+            if (preset)
+            {
+                if (verbose_flag & TC_DEBUG)
+                    tc_info("Using Lame preset `%s'.",
+                            vob->lame_preset);
+                lame_set_preset(lgf, preset);
+            }
+        }
+
+        /* Init Lame ! */
+        lame_init_params(lgf);
+        if(verbose_flag)
+            tc_info("Audio: using lame-%s",
+                get_lame_version());
+        if (verbose_flag & TC_DEBUG) {
+            tc_info("Lame config: PCM -> %s",
+                    (o_codec==CODEC_MP3)?"MP3":"MP2");
+            tc_info("             bitrate         : %d kbit/s",
+                    vob->mp3bitrate);
+            tc_info("             ouput samplerate: %d Hz",
+                    (vob->mp3frequency>0)?vob->mp3frequency:vob->a_rate);
+        }
+        /* init lame encoder only on first call */
+        initialized = 1;
+        res = TC_EXPORT_OK;
+
+#else  /* HAVE_LAME */
+        tc_warn("No Lame support available!");
+#endif /* HAVE_LAME */
+    }
+
+    return res;
+}
+
+
+
+/**
+ * Init FFMPEG AUDIO Encoder
+ *
+ * @param vob
+ *
+ * @return TC_EXPORT_OK or TC_EXPORT_ERROR
+ */
+static int tc_audio_init_ffmpeg(vob_t *vob, int o_codec)
+{
+    int init_ret = TC_EXPORT_ERROR;
+#ifdef HAVE_FFMPEG
+    unsigned long codeid = 0;
+    int ret = 0;
+
+    TC_INIT_LIBAVCODEC;
+
+    switch (o_codec) {
+      case   0x50:
+        codeid = CODEC_ID_MP2;
+        break;
+      case 0x2000:
+        codeid = CODEC_ID_AC3;
+        break;
+      default:
+        tc_warn("cannot init ffmpeg with %x", o_codec);
+    }
+
+    //-- get it --
+    mpa_codec = avcodec_find_encoder(codeid);
+    if (!mpa_codec) {
+      tc_log_warn("encode_ffmpeg", "mpa codec not found !");
+      return(TC_EXPORT_ERROR);
+    }
+
+    // OPEN
+
+    //-- set parameters (bitrate, channels and sample-rate) --
+    //--------------------------------------------------------
+    avcodec_get_context_defaults(&mpa_ctx);
+#if LIBAVCODEC_VERSION_MAJOR < 53
+    mpa_ctx.codec_type  = CODEC_TYPE_AUDIO;
+#else
+    mpa_ctx.codec_type  = AVMEDIA_TYPE_AUDIO;
+#endif
+    mpa_ctx.bit_rate    = vob->mp3bitrate * 1000;  // bitrate dest.
+    mpa_ctx.channels    = vob->dm_chan;            // channels
+    mpa_ctx.sample_rate = vob->a_rate;
+
+    //-- open codec --
+    //----------------
+    TC_LOCK_LIBAVCODEC;
+    ret = avcodec_open(&mpa_ctx, mpa_codec);
+    TC_UNLOCK_LIBAVCODEC;
+    if (ret < 0) {
+        tc_warn("tc_audio_init_ffmpeg: could not open %s codec !",
+                (codeid == CODEC_ID_MP2) ?"mpa" :"ac3");
+        return(TC_EXPORT_ERROR);
+    }
+
+    //-- bytes per sample and bytes per frame --
+    mpa_bytes_ps = mpa_ctx.channels * vob->dm_bits/8;
+    mpa_bytes_pf = mpa_ctx.frame_size * mpa_bytes_ps;
+
+    //-- create buffer to hold 1 frame --
+    mpa_buf     = malloc(mpa_bytes_pf);
+    mpa_buf_ptr = 0;
+    init_ret    = TC_EXPORT_OK;
+
+#else  /* HAVE_FFMPEG */
+    tc_warn("No FFmpeg support available!");
+#endif /* HAVE_FFMPEG */
+
+    return init_ret;
+
+}
+
+
+/**
+ * Init audio encoder RAW -> *
+ *
+ * @param vob
+ *
+ * @return TC_EXPORT_OK or TC_EXPORT_ERROR
+ */
+static int tc_audio_init_raw(vob_t *vob)
+{
+    if(vob->pass_flag & TC_AUDIO)
+    {
+        avi_t *avifile;
+
+        avifile = AVI_open_input_file(vob->audio_in_file, 1);
+        if(avifile != NULL)
+        {
+            /* set correct pass-through track: */
+            AVI_set_audio_track(avifile, vob->a_track);
+
+            /*
+             * small hack to fix incorrect samplerates caused by
+             * transcode < 0.5.0-20011109
+             */
+            if (vob->mp3frequency==0)
+                vob->mp3frequency=AVI_audio_rate(avifile);
+
+            avi_aud_rate    =  vob->mp3frequency;
+            avi_aud_chan    =  AVI_audio_channels(avifile);
+            avi_aud_bits    =  AVI_audio_bits(avifile);
+            avi_aud_codec   =  AVI_audio_format(avifile);
+            avi_aud_bitrate =  AVI_audio_mp3rate(avifile);
+
+            AVI_close(avifile);
+        } else {
+            AVI_print_error("avi open error");
+            return(TC_EXPORT_ERROR);
+        }
+    } else
+        tc_audio_encode_function=tc_audio_mute;
+
+    return(TC_EXPORT_OK);
+}
+
+
+/**
+ * init audio encoder
+ *
+ * @param vob
+ * @param v is TC_DEBUG for verbose output or 0
+ *
+ * @return  TC_EXPORT_OK or TC_EXPORT_ERROR
+ */
+
+int tc_audio_init(vob_t *vob, int v)
+{
+    int ret=TC_EXPORT_OK;
+    int sample_size;
+    verbose_flag=v;
+
+    /* Default */
+    avi_aud_bitrate = vob->mp3bitrate;
+    avi_aud_codec = vob->ex_a_codec;
+
+    avi_aud_bits=vob->dm_bits;
+    avi_aud_chan=vob->dm_chan;
+    avi_aud_rate=(vob->mp3frequency != 0)?vob->mp3frequency:vob->a_rate;
+
+    lame_flush=vob->encoder_flush;
+
+    /* For encoding */
+    sample_size = avi_aud_bits * 8 * avi_aud_chan;
+
+    /*
+     * Sanity checks
+     */
+    if((sample_size == 0) &&
+       (vob->im_a_codec != CODEC_NULL))
+    {
+        tc_warn("Zero sample size detected for audio format `0x%x'. "
+              "Muting.", vob->im_a_codec);
+        tc_audio_encode_function=tc_audio_mute;
+        return(TC_EXPORT_OK);
+    }
+
+    output = malloc (OUTPUT_SIZE);
+    input  = malloc (INPUT_SIZE);
+    if (!output || !input) {
+        tc_log_error(__FILE__, "(%s:%d) Out of memory", __FILE__, __LINE__);
+        return (TC_EXPORT_ERROR);
+    }
+
+
+    /* paranoia... */
+    memset (output, 0, OUTPUT_SIZE);
+    memset (input, 0, INPUT_SIZE);
+
+    if (verbose_flag & TC_DEBUG)
+        tc_info("Audio submodule in=0x%x out=0x%x", vob->im_a_codec, vob->ex_a_codec);
+
+    switch(vob->im_a_codec)
+    {
+    case CODEC_PCM:
+        switch(vob->ex_a_codec)
+        {
+        case CODEC_NULL:
+            tc_audio_encode_function = tc_audio_mute;
+            break;
+
+        case CODEC_MP3:
+            ret=tc_audio_init_lame(vob, vob->ex_a_codec);
+            tc_audio_encode_function = tc_audio_encode_mp3;
+            break;
+
+        case CODEC_PCM:
+            tc_info("PCM -> PCM");
+            /* adjust bitrate with magic ! */
+            avi_aud_bitrate=(vob->a_rate*4)/1000*8;
+            tc_audio_encode_function = tc_audio_pass_through_pcm;
+            break;
+
+        case CODEC_MP2:
+            tc_info("PCM -> MP2");
+            ret=tc_audio_init_ffmpeg(vob, vob->ex_a_codec);
+            tc_audio_encode_function = tc_audio_encode_ffmpeg;
+            break;
+
+        case CODEC_AC3:
+            tc_info("PCM -> AC3");
+            ret=tc_audio_init_ffmpeg(vob, vob->ex_a_codec);
+            tc_audio_encode_function = tc_audio_encode_ffmpeg;
+            break;
+
+        default:
+            tc_warn("Conversion not supported (in=0x%x out=0x%x)",
+                    vob->im_a_codec, vob->ex_a_codec);
+            ret=TC_EXPORT_ERROR;
+            break;
+        }
+        break;
+
+    case CODEC_MP2:
+    case CODEC_MP3: /* only pass through supported */
+        switch(vob->ex_a_codec)
+        {
+        case CODEC_NULL:
+            tc_audio_encode_function = tc_audio_mute;
+            break;
+
+        case CODEC_MP2:
+        case CODEC_MP3:
+            tc_audio_encode_function = tc_audio_pass_through;
+            break;
+
+        default:
+            tc_warn("Conversion not supported (in=x0%x out=x0%x)",
+                    vob->im_a_codec, vob->ex_a_codec);
+            ret=TC_EXPORT_ERROR;
+            break;
+        }
+        break;
+
+    case CODEC_AC3: /* only pass through supported */
+        switch(vob->ex_a_codec)
+        {
+        case CODEC_NULL:
+            tc_audio_encode_function = tc_audio_mute;
+            break;
+
+        case CODEC_AC3:
+            tc_info("AC3->AC3");
+            if (vob->audio_file_flag) {
+                tc_audio_encode_function = tc_audio_pass_through;
+            } else {
+                tc_audio_encode_function = tc_audio_pass_through_ac3;
+            }
+            /*
+             *the bitrate can only be determined in the encoder
+             * section. `bitrate_flags' will be set to 1 after
+             * bitrate is determined.
+             */
+            break;
+        default:
+            tc_warn("Conversion not supported (in=0x%x out=0x%x)",
+                    vob->im_a_codec, vob->ex_a_codec);
+            ret=TC_EXPORT_ERROR;
+            break;
+        }
+        break;
+
+    case CODEC_NULL: /* no audio requested */
+        tc_audio_encode_function = tc_audio_mute;
+        break;
+
+    case CODEC_RAW: /* pass-through mode */
+        tc_audio_encode_function = tc_audio_pass_through;
+        ret=tc_audio_init_raw(vob);
+        break;
+
+    default:
+        tc_warn("Conversion not supported (in=x0%x out=x0%x)",
+              vob->im_a_codec, vob->ex_a_codec);
+        ret=TC_EXPORT_ERROR;
+        break;
+    }
+
+    return(ret);
+}
+
+
+/**
+ * open audio output file
+ *
+ * @param vob
+ * @param avifile
+ *
+ * @return TC_EXPORT_OK or TC_EXPORT_ERROR
+ */
+int tc_audio_open(vob_t *vob, avi_t *avifile)
+{
+    if (tc_audio_encode_function != tc_audio_mute)
+    {
+        if(vob->audio_file_flag)
+        {
+            if(! fd)
+            {
+                if (vob->audio_out_file[0] == '|')
+                {
+                    fd = popen(vob->audio_out_file+1, "w");
+                    if (! fd)
+                    {
+                        tc_warn("Cannot popen() audio "
+                                "file `%s'",
+                                vob->audio_out_file+1);
+                        return(TC_EXPORT_ERROR);
+                    }
+                    is_pipe = 1;
+                } else {
+                    fd = fopen(vob->audio_out_file, "w");
+                    if (! fd)
+                    {
+                        tc_warn("Cannot open() audio "
+                              "file `%s'",
+                              vob->audio_out_file);
+                        return(TC_EXPORT_ERROR);
+                    }
+                }
+            }
+
+            if (verbose_flag & TC_DEBUG)
+                tc_info("Sending audio output to %s",
+                        vob->audio_out_file);
+        } else {
+
+            if(avifile==NULL)
+            {
+                tc_audio_encode_function = tc_audio_mute;
+                tc_info("No option `-m' found. Muting sound.");
+                return(TC_EXPORT_OK);
+            }
+
+            AVI_set_audio(avifile,
+                      avi_aud_chan,
+                      avi_aud_rate,
+                      avi_aud_bits,
+                      avi_aud_codec,
+                      avi_aud_bitrate);
+            AVI_set_audio_vbr(avifile, vob->a_vbr);
+
+            if (vob->avi_comment_fd > 0)
+                AVI_set_comment_fd(avifile,
+                           vob->avi_comment_fd);
+
+            if(avifile2 == NULL)
+                avifile2 = avifile; /* save for close */
+
+            if (verbose_flag & TC_DEBUG)
+                tc_info("AVI stream: format=0x%x, rate=%ld Hz, "
+                        "bits=%d, channels=%d, bitrate=%d",
+                        avi_aud_codec,
+                        avi_aud_rate,
+                        avi_aud_bits,
+                        avi_aud_chan,
+                        avi_aud_bitrate);
+        }
+    }
+
+    return(TC_EXPORT_OK);
+}
+
+
+/**
+ * Write audio data to output stream
+ */
+static int tc_audio_write(char *buffer, size_t size, avi_t *avifile)
+{
+    if (fd != NULL) {
+        if (fwrite(buffer, size, 1, fd) != 1) {
+            tc_warn("Audio file write error (errno=%d) [%s].", errno, strerror(errno));
+            return(TC_EXPORT_ERROR);
+        }
+    } else {
+        if (AVI_write_audio(avifile, buffer, size) < 0) {
+            AVI_print_error("AVI file audio write error");
+            return(TC_EXPORT_ERROR);
+        }
+    }
+
+    return(TC_EXPORT_OK);
+}
+
+
+/**
+ * encode audio frame in MP3 format
+ *
+ * @param aud_buffer is the input buffer ?
+ * @param aud_size is the input buffer length
+ * @param avifile is the output stream
+ *
+ * @return
+ *
+ * How this code works:
+ *
+ * We always encode raw audio chunks which are MP3_CHUNK_SZ (==2304)
+ * bytes large. `input' contains the raw audio buffer contains
+ * the encoded audio
+ *
+ * It is possible (very likely) that lame cannot produce a valid mp3
+ * chunk per "audio frame" so we do not write out any compressed audio.
+ * We need to buffer the not consumed input audio where another 2304
+ * bytes chunk won't fit in AND we need to buffer the already encoded
+ * but not enough audio.
+ *
+ * To find out how much we actually need to encode we decode the mp3
+ * header of the recently encoded audio chunk and read out the actual
+ * length.
+ *
+ * Then we write the audio. There can either be more than one valid mp3
+ * frame in buffer and/or still enough raw data left to encode one.
+ *
+ * Easy, eh? -- tibit.
+ */
+static int tc_audio_encode_mp3(char *aud_buffer, int aud_size, avi_t *avifile)
+{
+#ifdef HAVE_LAME
+    int outsize=0;
+    int count=0;
+
+    /*
+     * Apend the new incoming audio to the already available but not yet
+     * consumed.
+     */
+        ac_memcpy (input+input_len, aud_buffer, aud_size);
+    input_len += aud_size;
+    if (verbose_flag & TC_DEBUG)
+        tc_info("audio_encode_mp3: input buffer size=%d", input_len);
+
+    /*
+     * As long as lame doesn't return encoded data (lame needs to fill its
+     * internal buffers) AND as long as there is enough input data left.
+     */
+    while(input_len >= MP3_CHUNK_SZ)
+    {
+        if(IS_AUDIO_MONO)
+        {
+            outsize = lame_encode_buffer(
+                lgf,
+                (short int *)(input+count*MP3_CHUNK_SZ),
+                (short int *)(input+count*MP3_CHUNK_SZ),
+                MP3_CHUNK_SZ/2,
+                output+output_len,
+                OUTPUT_SIZE - output_len);
+        } else {
+            outsize = lame_encode_buffer_interleaved(
+                lgf,
+                (short int *) (input+count*MP3_CHUNK_SZ),
+                MP3_CHUNK_SZ/4,
+                output + output_len,
+                OUTPUT_SIZE - output_len);
+        }
+
+        if(outsize < 0)
+        {
+            tc_warn("Lame encoding error: (%s)",
+                    lame_error2str(outsize));
+            return(TC_EXPORT_ERROR);
+        }
+
+        output_len += outsize;
+        input_len  -= MP3_CHUNK_SZ;
+
+        ++count;
+
+        if (verbose_flag & TC_DEBUG)
+            tc_info("Encoding: count=%d outsize=%d output_len=%d "
+                "consumed=%d",
+                count, outsize, output_len, count*MP3_CHUNK_SZ);
+    }
+    /* Update input */
+    memmove(input, input+count*MP3_CHUNK_SZ, input_len);
+
+
+    if (verbose_flag & TC_DEBUG)
+        tc_info("output_len=%d input_len=%d count=%d",
+            output_len, input_len, count);
+
+    /* If we don't have any output data, there's nothing to do */
+    if (output_len == 0) {
+        return(TC_EXPORT_OK);
+    }
+
+    /*
+     * Now, it's time to write mp3 data to output stream...
+     */
+    if (IS_VBR)
+    {
+        int offset=0;
+        int size;
+
+        /*
+         * In VBR mode, we should write _complete_ chunk. And their
+         * size may change from one to other... So we should analyse
+         * each one and write it if enough data is avaible.
+         */
+
+        if (verbose_flag & TC_DEBUG)
+            tc_info("Writing... (output_len=%d)\n", output_len);
+        while((size=tc_get_mp3_header(output+offset, NULL, NULL)) > 0)
+        {
+            if (size > output_len)
+                break;
+
+            if (verbose_flag & TC_DEBUG)
+                tc_info("Writing chunk of size=%d", size);
+            tc_audio_write(output+offset, size, avifile);
+            offset += size;
+            output_len -= size;
+        }
+        memmove(output, output+offset, output_len);
+        if (verbose_flag & TC_DEBUG)
+            tc_info("Writing OK (output_len=%d)", output_len);
+    } else {
+        /*
+         * in CBR mode, write our data in simplest way.
+         * Thinking too much about chunk will break audio playback
+         * on archos Jukebox Multimedia...
+         */
+        tc_audio_write(output, output_len, avifile);
+        output_len=0;
+    }
+    return(TC_EXPORT_OK);
+#else   // HAVE_LAME
+    tc_warn("No Lame support available!");
+    return(TC_EXPORT_ERROR);
+#endif
+}
+
+static int tc_audio_encode_ffmpeg(char *aud_buffer, int aud_size, avi_t *avifile)
+{
+#ifdef HAVE_FFMPEG
+    int  in_size, out_size;
+    char *in_buf;
+
+    //-- input buffer and amount of bytes --
+    in_size = aud_size;
+    in_buf  = aud_buffer;
+
+    //-- any byte in mpa-buffer left from past call ? --
+    //--------------------------------------------------
+    if (mpa_buf_ptr > 0) {
+
+      int bytes_needed, bytes_avail;
+
+      bytes_needed = mpa_bytes_pf - mpa_buf_ptr;
+      bytes_avail  = in_size;
+
+      //-- complete frame -> encode --
+      //------------------------------
+      if ( bytes_avail >= bytes_needed ) {
+
+    ac_memcpy(&mpa_buf[mpa_buf_ptr], in_buf, bytes_needed);
+
+    TC_LOCK_LIBAVCODEC;
+    out_size = avcodec_encode_audio(&mpa_ctx, (unsigned char *)output,
+                    OUTPUT_SIZE, (short *)mpa_buf);
+    TC_UNLOCK_LIBAVCODEC;
+    tc_audio_write(output, out_size, avifile);
+
+        in_size -= bytes_needed;
+        in_buf  += bytes_needed;
+
+        mpa_buf_ptr = 0;
+      }
+
+      //-- incomplete frame -> append bytes to mpa-buffer and return --
+      //---------------------------------------------------------------
+      else {
+
+    ac_memcpy(&mpa_buf[mpa_buf_ptr], aud_buffer, bytes_avail);
+        mpa_buf_ptr += bytes_avail;
+        return (0);
+      }
+    } //bytes availabe from last call?
+
+
+    //-- encode only as much "full" frames as available --
+    //----------------------------------------------------
+
+    while (in_size >= mpa_bytes_pf) {
+      TC_LOCK_LIBAVCODEC;
+      out_size = avcodec_encode_audio(&mpa_ctx, (unsigned char *)output,
+                      OUTPUT_SIZE, (short *)in_buf);
+      TC_UNLOCK_LIBAVCODEC;
+
+      tc_audio_write(output, out_size, avifile);
+
+      in_size -= mpa_bytes_pf;
+      in_buf  += mpa_bytes_pf;
+    }
+
+    //-- hold rest of bytes in mpa-buffer --
+    //--------------------------------------
+    if (in_size > 0) {
+      mpa_buf_ptr = in_size;
+      ac_memcpy(mpa_buf, in_buf, mpa_buf_ptr);
+    }
+
+    return(TC_EXPORT_OK);
+#else   // HAVE_FFMPEG
+    tc_warn("No FFMPEG support available!");
+    return(TC_EXPORT_ERROR);
+#endif
+}
+
+static int tc_audio_pass_through_ac3(char *aud_buffer, int aud_size, avi_t *avifile)
+{
+    if(bitrate == 0)
+    {
+        int i;
+        uint16_t sync_word = 0;
+
+        /* try to determine bitrate from audio frame: */
+        for(i=0;i<aud_size-3;++i)
+        {
+            sync_word = (sync_word << 8) + (uint8_t) aud_buffer[i];
+            if(sync_word == 0x0b77)
+            {
+                /* from import/ac3scan.c */
+                static const int bitrates[] = {
+                    32, 40, 48, 56,
+                    64, 80, 96, 112,
+                    128, 160, 192, 224,
+                    256, 320, 384, 448,
+                    512, 576, 640
+                };
+                int ratecode = (aud_buffer[i+3] & 0x3E) >> 1;
+                if (ratecode < sizeof(bitrates)/sizeof(*bitrates))
+                    bitrate = bitrates[ratecode];
+                break;
+            }
+        }
+
+        /* assume bitrate > 0 is OK. */
+        if (bitrate > 0)
+        {
+            AVI_set_audio_bitrate(avifile, bitrate);
+            if (verbose_flag & TC_DEBUG)
+                tc_info("bitrate %d kBits/s", bitrate);
+        }
+    }
+
+    return(tc_audio_write(aud_buffer, aud_size, avifile));
+}
+
+
+/**
+ *
+ */
+static int tc_audio_pass_through_pcm(char *aud_buffer, int aud_size, avi_t *avifile)
+{
+#ifdef WORDS_BIGENDIAN
+    int i;
+    char tmp;
+
+    for(i=0; i<aud_size; i+=2)
+    {
+        tmp = aud_buffer[i+1];
+        aud_buffer[i+1] = aud_buffer[i];
+        aud_buffer[i] = tmp;
+    }
+#endif
+    return(tc_audio_write(aud_buffer, aud_size, avifile));
+
+}
+
+/**
+ *
+ */
+static int tc_audio_pass_through(char *aud_buffer, int aud_size, avi_t *avifile)
+{
+    return(tc_audio_write(aud_buffer, aud_size, avifile));
+
+}
+
+/**
+ *
+ */
+static int tc_audio_mute(char *aud_buffer, int aud_size, avi_t *avifile)
+{
+    /*
+     * Avoid Gcc to complain
+     */
+    (void)aud_buffer;
+    (void)aud_size;
+    (void)avifile;
+
+    return(TC_EXPORT_OK);
+}
+
+
+/**
+ * encode audio frame
+ *
+ * @param aud_buffer is the input buffer ?
+ * @param aud_size is the input buffer length ?
+ * @param avifile is the output stream ?
+ *
+ * @return
+ */
+int tc_audio_encode(char *aud_buffer, int aud_size, avi_t *avifile)
+{
+    assert(tc_audio_encode_function != NULL);
+    return(tc_audio_encode_function(aud_buffer, aud_size, avifile));
+ }
+
+
+/**
+ * Close audio stream
+ */
+int tc_audio_close()
+{
+    /* reset bitrate flag for AC3 pass-through */
+    bitrate = 0;
+
+    if (tc_audio_encode_function == tc_audio_encode_mp3)
+    {
+#ifdef HAVE_LAME
+        if(lame_flush) {
+
+            int outsize=0;
+
+            outsize = lame_encode_flush(lgf, output, 0);
+
+            if (verbose_flag & TC_DEBUG)
+                tc_info("flushing %d audio bytes", outsize);
+
+            if (output && outsize > 0) {
+                tc_audio_write(output, outsize, avifile2);
+            }
+        }
+#endif
+    }
+
+    if(fd)
+    {
+        if (is_pipe)
+            pclose(fd);
+        else
+            fclose(fd);
+        fd=NULL;
+    }
+
+    avifile2 = NULL;
+    return(TC_EXPORT_OK);
+}
+
+
+
+int tc_audio_stop()
+{
+        if (input) {
+            free(input);
+            input = NULL;
+        }
+        if (output) {
+            free(output);
+            output = NULL;
+        }
+#ifdef HAVE_LAME
+    if (tc_audio_encode_function == tc_audio_encode_mp3)
+        lame_close(lgf);
+#endif
+
+#ifdef HAVE_FFMPEG
+    if (tc_audio_encode_function == tc_audio_encode_ffmpeg)
+    {
+        //-- release encoder --
+        if (mpa_codec) avcodec_close(&mpa_ctx);
+
+        //-- cleanup buffer resources --
+        if (mpa_buf) free(mpa_buf);
+        mpa_buf     = NULL;
+        mpa_buf_ptr = 0;
+
+    }
+#endif    
+
+    return(0);
+}
+
+
+#ifdef HAVE_LAME
+
+/**
+ *
+ */
+static char * lame_error2str(int error)
+{
+    switch (error)
+    {
+    case -1: return "-1:  mp3buf was too small";
+    case -2: return "-2:  malloc() problem";
+    case -3: return "-3:  lame_init_params() not called";
+    case -4: return "-4:  psycho acoustic problems";
+    case -5: return "-5:  ogg cleanup encoding error";
+    case -6: return "-6:  ogg frame encoding error";
+    default: return "Unknown lame error";
+    }
+}
+
+// from mencoder
+//----------------------- mp3 audio frame header parser -----------------------
+
+static int tabsel_123[2][3][16] = {
+   { {0,32,64,96,128,160,192,224,256,288,320,352,384,416,448,0},
+     {0,32,48,56, 64, 80, 96,112,128,160,192,224,256,320,384,0},
+     {0,32,40,48, 56, 64, 80, 96,112,128,160,192,224,256,320,0} },
+
+   { {0,32,48,56,64,80,96,112,128,144,160,176,192,224,256,0},
+     {0,8,16,24,32,40,48,56,64,80,96,112,128,144,160,0},
+     {0,8,16,24,32,40,48,56,64,80,96,112,128,144,160,0} }
+};
+static long freqs[9] = { 44100, 48000, 32000, 22050, 24000, 16000 , 11025 , 12000 , 8000 };
+
+/*
+ * return frame size or -1 (bad frame)
+ */
+static int tc_get_mp3_header(unsigned char* hbuf, int* chans, int* srate){
+    int stereo, ssize, crc, lsf, mpeg25, framesize;
+    int padding, bitrate_index, sampling_frequency;
+    unsigned long newhead =
+      hbuf[0] << 24 |
+      hbuf[1] << 16 |
+      hbuf[2] <<  8 |
+      hbuf[3];
+
+
+    // head_check:
+    if( (newhead & 0xffe00000) != 0xffe00000 ||
+        (newhead & 0x0000fc00) == 0x0000fc00){
+    //tc_log_warn(__FILE__, "head_check failed");
+    return -1;
+    }
+
+    if((4-((newhead>>17)&3))!=3){
+      tc_warn("not layer-3");
+      return -1;
+    }
+
+    if( newhead & ((long)1<<20) ) {
+      lsf = (newhead & ((long)1<<19)) ? 0x0 : 0x1;
+      mpeg25 = 0;
+    } else {
+      lsf = 1;
+      mpeg25 = 1;
+    }
+
+    if(mpeg25)
+      sampling_frequency = 6 + ((newhead>>10)&0x3);
+    else
+      sampling_frequency = ((newhead>>10)&0x3) + (lsf*3);
+
+    if(sampling_frequency>8){
+    tc_warn("invalid sampling_frequency");
+    return -1;  // valid: 0..8
+    }
+
+    crc = ((newhead>>16)&0x1)^0x1;
+    bitrate_index = ((newhead>>12)&0xf);
+    padding   = ((newhead>>9)&0x1);
+//    fr->extension = ((newhead>>8)&0x1);
+//    fr->mode      = ((newhead>>6)&0x3);
+//    fr->mode_ext  = ((newhead>>4)&0x3);
+//    fr->copyright = ((newhead>>3)&0x1);
+//    fr->original  = ((newhead>>2)&0x1);
+//    fr->emphasis  = newhead & 0x3;
+
+    stereo    = ( (((newhead>>6)&0x3)) == 3) ? 1 : 2;
+
+    if(!bitrate_index){
+      tc_warn("Free format not supported.");
+      return -1;
+    }
+
+    if(lsf)
+      ssize = (stereo == 1) ? 9 : 17;
+    else
+      ssize = (stereo == 1) ? 17 : 32;
+    if(crc) ssize += 2;
+
+    framesize = tabsel_123[lsf][2][bitrate_index] * 144000;
+
+    if(!framesize){
+    tc_warn("invalid framesize/bitrate_index");
+    return -1;  // valid: 1..14
+    }
+
+    framesize /= freqs[sampling_frequency]<<lsf;
+    framesize += padding;
+
+//    if(framesize<=0 || framesize>MAXFRAMESIZE) return FALSE;
+    if(srate) *srate = freqs[sampling_frequency];
+    if(chans) *chans = stereo;
+
+    return framesize;
+}
+
+#endif  // HAVE_LAME
+