Added debian extra dependency packages.

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

1 files changed, 1113 insertions, 0 deletions

diff --git a/debian/transcode/transcode-1.1.7/src/decoder.c b/debian/transcode/transcode-1.1.7/src/decoder.c
new file mode 100644
index 00000000..b0c0d180
--- /dev/null
+++ b/debian/transcode/transcode-1.1.7/src/decoder.c
@@ -0,0 +1,1113 @@
+/*
+ *  decoder.c -- transcode import layer module, implementation.
+ *
+ *  Copyright (C) Thomas Oestreich - June 2001
+ *  Updated and partially rewritten by
+ *  Francesco Romani - July 2007
+ *
+ *  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 "dl_loader.h"
+#include "filter.h"
+#include "framebuffer.h"
+#include "video_trans.h"
+#include "audio_trans.h"
+#include "decoder.h"
+#include "encoder.h"
+#include "frame_threads.h"
+#include "cmdline.h"
+#include "probe.h"
+
+
+/*************************************************************************/
+
+/* anonymous since used just internally */
+enum {
+    TC_IM_THREAD_UNKNOWN = -1, /* halting cause not specified      */
+    TC_IM_THREAD_DONE = 0,     /* import ends as expected          */
+    TC_IM_THREAD_INTERRUPT,    /* external event interrupts import */
+    TC_IM_THREAD_EXT_ERROR,    /* external (I/O) error             */
+    TC_IM_THREAD_INT_ERROR,    /* internal (core) error            */
+    TC_IM_THREAD_PROBE_ERROR,  /* source is incompatible           */
+};
+
+
+typedef struct tcdecoderdata_ TCDecoderData;
+struct tcdecoderdata_ {
+    const char *tag;            /* audio or video? used for logging */
+    FILE *fd;                   /* for stream import                */
+    void *im_handle;            /* import module handle             */
+    volatile int active_flag;   /* active or not?                   */
+    pthread_t thread_id;
+    pthread_mutex_t lock;
+};
+
+
+/*************************************************************************/
+
+static TCDecoderData video_decdata = {
+    .tag         = "video",
+    .fd          = NULL,
+    .im_handle   = NULL,
+    .active_flag = 0,
+    .thread_id   = (pthread_t)0,
+    .lock        = PTHREAD_MUTEX_INITIALIZER,
+};
+
+static TCDecoderData audio_decdata = {
+    .tag         = "audio",
+    .fd          = NULL,
+    .im_handle   = NULL,
+    .active_flag = 0,
+    .thread_id   = (pthread_t)0,
+    .lock        = PTHREAD_MUTEX_INITIALIZER,
+};
+
+static pthread_t tc_pthread_main = (pthread_t)0;
+static long int vframecount = 0;
+static long int aframecount = 0;
+
+
+/*************************************************************************/
+/*  Old-style compatibility support functions                            */
+/*************************************************************************/
+
+struct modpair {
+    int codec; /* internal codec/colorspace/format */
+    int caps;  /* module capabilities              */
+};
+
+static const struct modpair audpairs[] = {
+    { CODEC_PCM,     TC_CAP_PCM    },
+    { CODEC_AC3,     TC_CAP_AC3    },
+    { CODEC_RAW,     TC_CAP_AUD    },
+    { CODEC_NULL,    TC_CAP_NONE   } /* end marker, must be the last */
+};
+
+static const struct modpair vidpairs[] = {
+    { CODEC_RGB,     TC_CAP_RGB    },
+    { CODEC_YUV,     TC_CAP_YUV    },
+    { CODEC_YUV422,  TC_CAP_YUV422 },
+    { CODEC_RAW_YUV, TC_CAP_VID    },
+    { CODEC_RAW,     TC_CAP_VID    },
+    { CODEC_NULL,    TC_CAP_NONE   } /* end marker, must be the last */
+};
+
+
+/*
+ * check_module_caps: verifies if a module is compatible with transcode
+ * core colorspace/format settings.
+ *
+ * Parameters:
+ *       param: data describing (old-style) module capabilities.
+ *       codec: codec/format/colorspace requested by core.
+ *      mpairs: table of formats/capabilities to be used for check.
+ * Return Value:
+ *       0: module INcompatible with core format request.
+ *      !0: module can accomplish to the core format request.
+ */
+static int check_module_caps(const transfer_t *param, int codec,
+                             const struct modpair *mpairs)
+{
+    int caps = 0;
+
+    if (param->flag == verbose) {
+        caps = (codec == mpairs[0].codec);
+        /* legacy: grab the first and stay */
+    } else {
+        int i = 0;
+
+        /* module returned capability flag */
+        if (verbose >= TC_DEBUG) {
+            tc_log_msg(__FILE__, "Capability flag 0x%x | 0x%x",
+                       param->flag, codec);
+        }
+
+        for (i = 0; mpairs[i].codec != CODEC_NULL; i++) {
+            if (codec == mpairs[i].codec) {
+                caps = (param->flag & mpairs[i].caps);
+                break;
+            }
+        }
+    }
+    return caps;
+}
+
+/*************************************************************************/
+/*                  optimized block-wise fread                           */
+/*************************************************************************/
+
+#ifdef PIPE_BUF
+#define BLOCKSIZE PIPE_BUF /* 4096 on linux-x86 */
+#else
+#define BLOCKSIZE 4096
+#endif
+
+static int mfread(uint8_t *buf, int size, int nelem, FILE *f)
+{
+    int fd = fileno(f);
+    int n = 0, r1 = 0, r2 = 0;
+    while (n < size*nelem-BLOCKSIZE) {
+        if ( !(r1 = read (fd, &buf[n], BLOCKSIZE))) return 0;
+        n += r1;
+    }
+    while (size*nelem-n) {
+        if ( !(r2 = read (fd, &buf[n], size*nelem-n)))return 0;
+        n += r2;
+    }
+    return nelem;
+}
+
+/*************************************************************************/
+/*               some macro goodies                                      */
+/*************************************************************************/
+
+#define RETURN_IF_NULL(HANDLE, MEDIA) do { \
+    if ((HANDLE) == NULL) { \
+        tc_log_error(PACKAGE, "Loading %s import module failed", (MEDIA)); \
+        tc_log_error(PACKAGE, \
+                     "Did you enable this module when you ran configure?"); \
+        return TC_ERROR; \
+    } \
+} while (0)
+
+#define RETURN_IF_NOT_SUPPORTED(CAPS, MEDIA) do { \
+    if (!(CAPS)) { \
+        tc_log_error(PACKAGE, "%s format not supported by import module", \
+                     (MEDIA)); \
+        return TC_ERROR; \
+    } \
+} while (0)
+
+#define RETURN_IF_FUNCTION_FAILED(func, ...) do { \
+    int ret = func(__VA_ARGS__); \
+    if (ret != TC_OK) { \
+        return TC_ERROR; \
+    } \
+} while (0)
+
+#define RETURN_IF_REGISTRATION_FAILED(PTR, MEDIA) do { \
+    /* ok, that's pure paranoia */ \
+    if ((PTR) == NULL) { \
+        tc_log_error(__FILE__, "frame registration failed (%s)", (MEDIA)); \
+        return TC_IM_THREAD_INT_ERROR; \
+    } \
+} while (0)
+
+/*************************************************************************/
+/*               stream-specific functions                               */
+/*************************************************************************/
+/*               status handling functions                               */
+/*************************************************************************/
+
+
+/*
+ * tc_import_thread_stop (Thread safe): mark the import status flag
+ * as `stopped'; the import thread will stop as soon as is possible.
+ *
+ * Parameters:
+ *      decdata: pointer to a TCDecoderData structure representing the
+ *               import thread to stop.
+ * Return Value:
+ *      None
+ */
+static void tc_import_thread_stop(TCDecoderData *decdata)
+{
+    pthread_mutex_lock(&decdata->lock);
+    decdata->active_flag = TC_FALSE;
+    pthread_mutex_unlock(&decdata->lock);
+}
+
+/*
+ * tc_import_thread_start (Thread safe): mark the import status flag
+ * as `started'; import thread become running and it starts producing data.
+ *
+ * Parameters:
+ *      decdata: pointer to a TCDecoderData structure representing the
+ *               import thread to start.
+ * Return Value:
+ *      None
+ */
+static void tc_import_thread_start(TCDecoderData *decdata)
+{
+    pthread_mutex_lock(&decdata->lock);
+    decdata->active_flag = TC_TRUE;
+    pthread_mutex_unlock(&decdata->lock);
+}
+
+/*
+ * tc_import_thread_is_active (Thread safe): poll for the current
+ * status flag of an import thread.
+ *
+ * Parameters:
+ *      decdata: pointer to a TCDecoderData structure representing the
+ *               import thread to query.
+ * Return Value:
+ *      TC_FALSE: import thread is stopped or stopping.
+ *      TC_TRUE:  import thread is running.
+ */
+
+static int tc_import_thread_is_active(TCDecoderData *decdata)
+{
+    int flag;
+    pthread_mutex_lock(&decdata->lock);
+    flag = decdata->active_flag;
+    pthread_mutex_unlock(&decdata->lock);
+    return flag;
+}
+
+/*************************************************************************/
+/*               stream open/close functions                             */
+/*************************************************************************/
+
+/*
+ * tc_import_{video,audio}_open: open audio stream for importing.
+ * 
+ * Parameters:
+ *      vob: vob structure
+ * Return Value:
+ *         TC_OK: succesfull.
+ *      TC_ERROR: failure; reason was tc_log*()ged out.
+ */
+static int tc_import_video_open(vob_t *vob)
+{
+    int ret;
+    transfer_t import_para;
+
+    memset(&import_para, 0, sizeof(transfer_t));
+
+    import_para.flag = TC_VIDEO;
+
+    ret = tcv_import(TC_IMPORT_OPEN, &import_para, vob);
+    if (ret < 0) {
+        tc_log_error(PACKAGE, "video import module error: OPEN failed");
+        return TC_ERROR;
+    }
+
+    video_decdata.fd = import_para.fd;
+
+    return TC_OK;
+}
+
+
+static int tc_import_audio_open(vob_t *vob)
+{
+    int ret;
+    transfer_t import_para;
+
+    memset(&import_para, 0, sizeof(transfer_t));
+
+    import_para.flag = TC_AUDIO;
+
+    ret = tca_import(TC_IMPORT_OPEN, &import_para, vob);
+    if (ret < 0) {
+        tc_log_error(PACKAGE, "audio import module error: OPEN failed");
+        return TC_ERROR;
+    }
+
+    audio_decdata.fd = import_para.fd;
+
+    return TC_OK;
+}
+
+/*
+ * tc_import_{video,audio}_close: close audio stream used for importing.
+ * 
+ * Parameters:
+ *      None.
+ * Return Value:
+ *         TC_OK: succesfull.
+ *      TC_ERROR: failure; reason was tc_log*()ged out.
+ */
+
+static int tc_import_audio_close(void)
+{
+    int ret;
+    transfer_t import_para;
+
+    memset(&import_para, 0, sizeof(transfer_t));
+
+    import_para.flag = TC_AUDIO;
+    import_para.fd   = audio_decdata.fd;
+
+    ret = tca_import(TC_IMPORT_CLOSE, &import_para, NULL);
+    if (ret == TC_IMPORT_ERROR) {
+        tc_log_warn(PACKAGE, "audio import module error: CLOSE failed");
+        return TC_ERROR;
+    }
+    audio_decdata.fd = NULL;
+
+    return TC_OK;
+}
+
+static int tc_import_video_close(void)
+{
+    int ret;
+    transfer_t import_para;
+
+    memset(&import_para, 0, sizeof(transfer_t));
+
+    import_para.flag = TC_VIDEO;
+    import_para.fd   = video_decdata.fd;
+
+    ret = tcv_import(TC_IMPORT_CLOSE, &import_para, NULL);
+    if (ret == TC_IMPORT_ERROR) {
+        tc_log_warn(PACKAGE, "video import module error: CLOSE failed");
+        return TC_ERROR;
+    }
+    video_decdata.fd = NULL;
+
+    return TC_OK;
+}
+
+
+/*************************************************************************/
+/*                       the import loops                                */
+/*************************************************************************/
+
+
+#define MARK_TIME_RANGE(PTR, VOB) do { \
+    /* Set skip attribute based on -c */ \
+    if (fc_time_contains((VOB)->ttime, (PTR)->id)) \
+        (PTR)->attributes &= ~TC_FRAME_IS_OUT_OF_RANGE; \
+    else \
+        (PTR)->attributes |= TC_FRAME_IS_OUT_OF_RANGE; \
+} while (0)
+
+
+/*
+ * stop_cause: specify the cause of an import loop termination.
+ *
+ * Parameters:
+ *      ret: termination cause identifier to be specified
+ * Return Value:
+ *      the most specific recognizable termination cause.
+ */
+static int stop_cause(int ret)
+{
+    if (ret == TC_IM_THREAD_UNKNOWN) {
+        if (tc_interrupted()) {
+            ret = TC_IM_THREAD_INTERRUPT;
+        } else if (tc_stopped()) {
+            ret = TC_IM_THREAD_DONE;
+        }
+    }
+    return ret;
+}
+
+/*
+ * {video,audio}_import_loop: data import loops. Feed frame FIFOs with
+ * new data forever until are interrupted or stopped.
+ *
+ * Parameters:
+ *      vob: vob structure
+ * Return Value:
+ *      TC_IM_THREAD_* value reporting operation status.
+ */
+static int video_import_loop(vob_t *vob)
+{
+    int ret = 0, vbytes = 0;
+    vframe_list_t *ptr = NULL;
+    transfer_t import_para;
+    TCFrameStatus next = (tc_frame_threads_have_video_workers())
+                            ?TC_FRAME_WAIT :TC_FRAME_READY;
+    int im_ret = TC_IM_THREAD_UNKNOWN;
+
+    if (verbose >= TC_DEBUG)
+        tc_log_msg(__FILE__, "video thread id=%ld", (unsigned long)pthread_self());
+
+    vbytes = vob->im_v_size;
+
+    while (tc_running() && tc_import_thread_is_active(&video_decdata)) {
+
+        if (verbose >= TC_THREADS)
+            tc_log_msg(__FILE__, "(V) %10s [%ld] %i bytes", "requesting",
+                       vframecount, vbytes);
+
+        /* stage 1: register new blank frame */
+        ptr = vframe_register(vframecount);
+        if (ptr == NULL) {
+            if (verbose >= TC_THREADS)
+                tc_log_msg(__FILE__, "(V) frame registration interrupted!");
+            break;
+        }
+
+        /* stage 2: fill the frame with data */
+        ptr->attributes = 0;
+        MARK_TIME_RANGE(ptr, vob);
+
+        if (verbose >= TC_THREADS)
+            tc_log_msg(__FILE__, "(V) new frame registered and marked, now filling...");
+
+        if (video_decdata.fd != NULL) {
+            if (vbytes && (ret = mfread(ptr->video_buf, vbytes, 1, video_decdata.fd)) != 1)
+                ret = -1;
+            ptr->video_len  = vbytes;
+            ptr->video_size = vbytes;
+        } else {
+            import_para.fd         = NULL;
+            import_para.buffer     = ptr->video_buf;
+            import_para.buffer2    = ptr->video_buf2;
+            import_para.size       = vbytes;
+            import_para.flag       = TC_VIDEO;
+            import_para.attributes = ptr->attributes;
+
+            ret = tcv_import(TC_IMPORT_DECODE, &import_para, vob);
+
+            ptr->video_len   = import_para.size;
+            ptr->video_size  = import_para.size;
+            ptr->attributes |= import_para.attributes;
+        }
+
+        if (verbose >= TC_THREADS)
+            tc_log_msg(__FILE__, "(V) new frame filled (%s)", (ret == -1) ?"FAILED" :"OK");
+
+        if (ret < 0) {
+            if (verbose >= TC_DEBUG)
+                tc_log_msg(__FILE__, "(V) data read failed - end of stream");
+
+            ptr->video_len  = 0;
+            ptr->video_size = 0;
+            if (!tc_has_more_video_in_file(vob)) {
+                ptr->attributes = TC_FRAME_IS_END_OF_STREAM;
+            } else {
+                ptr->attributes = TC_FRAME_IS_SKIPPED;
+            }
+        }
+
+        ptr->v_height   = vob->im_v_height;
+        ptr->v_width    = vob->im_v_width;
+        ptr->v_bpp      = BPP;
+
+        if (verbose >= TC_THREADS)
+            tc_log_msg(__FILE__, "(V) new frame is being processed");
+
+        /* stage 3: account filled frame and process it if needed */
+        if (TC_FRAME_NEED_PROCESSING(ptr)) {
+            //first stage pre-processing - (synchronous)
+            preprocess_vid_frame(vob, ptr);
+
+            //filter pre-processing - (synchronous)
+            ptr->tag = TC_VIDEO|TC_PRE_S_PROCESS;
+            tc_filter_process((frame_list_t *)ptr);
+        }
+
+        if (verbose >= TC_THREADS)
+            tc_log_msg(__FILE__, "(V) new frame ready to be pushed");
+
+        /* stage 4: push frame to next transcoding layer */
+        vframe_push_next(ptr, next);
+
+        if (verbose >= TC_THREADS)
+            tc_log_msg(__FILE__, "(V) %10s [%ld] %i bytes", "received",
+                       vframecount, ptr->video_size);
+
+        if (verbose >= TC_THREADS)
+            tc_log_msg(__FILE__, "(V) new frame pushed");
+
+        if (ret < 0) {
+            /* 
+             * we must delay this stuff in order to properly END_OF_STREAM
+             * frames _and_ to push them to subsequent stages
+             */
+            tc_import_thread_stop(&audio_decdata);
+            im_ret = TC_IM_THREAD_DONE;
+            break;
+        }
+        vframecount++;
+    }
+    return stop_cause(im_ret);
+}
+
+
+#define GET_AUDIO_FRAME do { \
+    if (audio_decdata.fd != NULL) { \
+        if (abytes && (ret = mfread(ptr->audio_buf, abytes, 1, audio_decdata.fd)) != 1) { \
+            ret = -1; \
+        } \
+        ptr->audio_len  = abytes; \
+        ptr->audio_size = abytes; \
+    } else { \
+        import_para.fd         = NULL; \
+        import_para.buffer     = ptr->audio_buf; \
+        import_para.size       = abytes; \
+        import_para.flag       = TC_AUDIO; \
+        import_para.attributes = ptr->attributes; \
+        \
+        ret = tca_import(TC_IMPORT_DECODE, &import_para, vob); \
+        \
+        ptr->audio_len  = import_para.size; \
+        ptr->audio_size = import_para.size; \
+    } \
+} while (0)
+
+static int audio_import_loop(vob_t *vob)
+{
+    int ret = 0, abytes;
+    aframe_list_t *ptr = NULL;
+    transfer_t import_para;
+    TCFrameStatus next = (tc_frame_threads_have_audio_workers())
+                            ?TC_FRAME_WAIT :TC_FRAME_READY;
+    int im_ret = TC_IM_THREAD_UNKNOWN;
+
+    if (verbose >= TC_DEBUG)
+        tc_log_msg(__FILE__, "audio thread id=%ld",
+                   (unsigned long)pthread_self());
+
+    abytes = vob->im_a_size;
+
+    while (tc_running() && tc_import_thread_is_active(&audio_decdata)) {
+        /* stage 1: audio adjustment for non-PAL frame rates */
+        if (aframecount != 0 && aframecount % TC_LEAP_FRAME == 0) {
+            abytes = vob->im_a_size + vob->a_leap_bytes;
+        } else {
+            abytes = vob->im_a_size;
+        }
+
+        if (verbose >= TC_THREADS)
+            tc_log_msg(__FILE__, "(A) %10s [%ld] %i bytes",
+                       "requesting", aframecount, abytes);
+
+        /* stage 2: register new blank frame */
+        ptr = aframe_register(aframecount);
+        if (ptr == NULL) {
+            if (verbose >= TC_THREADS)
+                tc_log_msg(__FILE__, "(A) frame registration interrupted!");
+            break;
+        }
+
+        ptr->attributes = 0;
+        MARK_TIME_RANGE(ptr, vob);
+
+        if (verbose >= TC_THREADS)
+            tc_log_msg(__FILE__, "(A) new frame registered and marked, now syncing...");
+
+        /* stage 3: fill the frame with data */
+        /* stage 3.1: resync audio by discarding frames, if needed */
+        if (vob->sync > 0) {
+            // discard vob->sync frames
+            while (vob->sync--) {
+                GET_AUDIO_FRAME;
+
+                if (ret == -1)
+                    break;
+            }
+            vob->sync++;
+        }
+
+        /* stage 3.2: grab effective audio data */
+        if (vob->sync == 0) {
+            GET_AUDIO_FRAME;
+        }
+
+        /* stage 3.3: silence at last */
+        if (vob->sync < 0) {
+            if (verbose >= TC_DEBUG)
+                tc_log_msg(__FILE__, " zero padding %d", vob->sync);
+            memset(ptr->audio_buf, 0, abytes);
+            ptr->audio_len  = abytes;
+            ptr->audio_size = abytes;
+            vob->sync++;
+        }
+        /* stage 3.x final note: all this stuff can be done in a cleaner way... */
+
+        if (verbose >= TC_THREADS)
+            tc_log_msg(__FILE__, "(A) syncing done, new frame ready to be filled...");
+
+        if (ret < 0) {
+            if (verbose >= TC_DEBUG)
+                tc_log_msg(__FILE__, "(A) data read failed - end of stream");
+
+            ptr->audio_len  = 0;
+            ptr->audio_size = 0;
+            if (!tc_has_more_audio_in_file(vob)) {
+                ptr->attributes = TC_FRAME_IS_END_OF_STREAM;
+            } else {
+                ptr->attributes = TC_FRAME_IS_SKIPPED;
+            }
+        }
+
+        // init frame buffer structure with import frame data
+        ptr->a_rate = vob->a_rate;
+        ptr->a_bits = vob->a_bits;
+        ptr->a_chan = vob->a_chan;
+
+        /* stage 4: account filled frame and process it if needed */
+        if (TC_FRAME_NEED_PROCESSING(ptr)) {
+            ptr->tag = TC_AUDIO|TC_PRE_S_PROCESS;
+            tc_filter_process((frame_list_t *)ptr);
+        }
+
+        /* stage 5: push frame to next transcoding layer */
+        aframe_push_next(ptr, next);
+
+        if (verbose >= TC_THREADS)
+            tc_log_msg(__FILE__, "(A) %10s [%ld] %i bytes", "received",
+                                 aframecount, ptr->audio_size);
+
+        if (ret < 0) {
+            tc_import_thread_stop(&audio_decdata);
+            im_ret = TC_IM_THREAD_DONE;
+            break;
+        }
+        aframecount++;
+    }
+    return stop_cause(im_ret);
+}
+
+#undef GET_AUDIO_FRAME
+#undef MARK_TIME_RANGE
+
+/*************************************************************************/
+/*        ladies and gentlemens, the thread routines                     */
+/*************************************************************************/
+
+/* audio decode thread wrapper */
+static void *audio_import_thread(void *_vob)
+{
+    static int ret = 0;
+    ret = audio_import_loop(_vob);
+    if (verbose >= TC_CLEANUP)
+        tc_log_msg(__FILE__, "audio decode loop ends with code 0x%i", ret);
+    pthread_exit(&ret);
+}
+
+/* video decode thread wrapper */
+static void *video_import_thread(void *_vob)
+{
+    static int ret = 0;
+    ret = video_import_loop(_vob);
+    if (verbose >= TC_CLEANUP)
+        tc_log_msg(__FILE__, "video decode loop ends with code 0x%i", ret);
+    pthread_exit(&ret);
+}
+
+
+/*************************************************************************/
+/*               main API functions                                      */
+/*************************************************************************/
+
+int tc_import_status()
+{
+    return tc_import_video_status() && tc_import_audio_status();
+}
+
+int tc_import_video_running(void)
+{
+    return tc_import_thread_is_active(&video_decdata);
+}
+
+int tc_import_audio_running(void)
+{
+    return tc_import_thread_is_active(&audio_decdata);
+}
+
+int tc_import_video_status(void)
+{
+    return vframe_have_more() || tc_import_thread_is_active(&video_decdata);
+}
+
+int tc_import_audio_status(void)
+{
+    return aframe_have_more() || tc_import_thread_is_active(&audio_decdata);
+}
+
+
+void tc_import_threads_cancel(void)
+{
+    void *status = NULL;
+    int vret, aret;
+
+    if (tc_decoder_delay)
+        tc_log_info(__FILE__, "sleeping for %i seconds to cool down", tc_decoder_delay);
+    sleep(tc_decoder_delay);
+    tc_log_info(__FILE__, "cancelling the import threads");
+
+    tc_import_thread_stop(&video_decdata);
+    tc_import_thread_stop(&audio_decdata);
+
+    tc_framebuffer_interrupt_import();
+
+    vret = pthread_join(video_decdata.thread_id, &status);
+    if (verbose >= TC_DEBUG) {
+        int *pst = status; /* avoid explicit cast in log below */
+        tc_log_msg(__FILE__, "video thread exit (ret_code=%i)"
+                             " (status_code=%i)", vret, *pst);
+    }
+
+    aret = pthread_join(audio_decdata.thread_id, &status);
+    if (verbose >= TC_DEBUG) {
+        int *pst = status; /* avoid explicit cast in log below */
+        tc_log_msg(__FILE__, "audio thread exit (ret_code=%i)"
+                             " (status_code=%i)", aret, *pst);
+    }
+    return;
+}
+
+
+void tc_import_threads_create(vob_t *vob)
+{
+    int ret;
+
+    tc_import_thread_start(&audio_decdata);
+    ret = pthread_create(&audio_decdata.thread_id, NULL,
+                         audio_import_thread, vob);
+    if (ret != 0)
+        tc_error("failed to start audio stream import thread");
+
+    tc_import_thread_start(&video_decdata);
+    ret = pthread_create(&video_decdata.thread_id, NULL,
+                         video_import_thread, vob);
+    if (ret != 0)
+        tc_error("failed to start video stream import thread");
+}
+
+
+int tc_import_init(vob_t *vob, const char *a_mod, const char *v_mod)
+{
+    transfer_t import_para;
+    int caps;
+
+    a_mod = (a_mod == NULL) ?TC_DEFAULT_IMPORT_AUDIO :a_mod;
+    audio_decdata.im_handle = load_module(a_mod, TC_IMPORT+TC_AUDIO);
+    RETURN_IF_NULL(audio_decdata.im_handle, "audio");
+
+    v_mod = (v_mod == NULL) ?TC_DEFAULT_IMPORT_VIDEO :v_mod;
+    video_decdata.im_handle = load_module(v_mod, TC_IMPORT+TC_VIDEO);
+    RETURN_IF_NULL(video_decdata.im_handle, "video");
+
+    memset(&import_para, 0, sizeof(transfer_t));
+    import_para.flag = verbose;
+    tca_import(TC_IMPORT_NAME, &import_para, NULL);
+
+    caps = check_module_caps(&import_para, vob->im_a_codec, audpairs);
+    RETURN_IF_NOT_SUPPORTED(caps, "audio");
+    
+    memset(&import_para, 0, sizeof(transfer_t));
+    import_para.flag = verbose;
+    tcv_import(TC_IMPORT_NAME, &import_para, NULL);
+
+    caps = check_module_caps(&import_para, vob->im_v_codec, vidpairs);
+    RETURN_IF_NOT_SUPPORTED(caps, "video");
+
+    tc_pthread_main = pthread_self();
+
+    return TC_OK;
+}
+
+
+int tc_import_open(vob_t *vob)
+{
+    RETURN_IF_FUNCTION_FAILED(tc_import_audio_open, vob);
+    RETURN_IF_FUNCTION_FAILED(tc_import_video_open, vob);
+
+    return TC_OK;
+}
+
+int tc_import_close(void)
+{
+    RETURN_IF_FUNCTION_FAILED(tc_import_audio_close);
+    RETURN_IF_FUNCTION_FAILED(tc_import_video_close);
+
+    return TC_OK;
+}
+
+void tc_import_shutdown(void)
+{
+    if (verbose >= TC_DEBUG) {
+        tc_log_msg(__FILE__, "unloading audio import module");
+    }
+
+    unload_module(audio_decdata.im_handle);
+    audio_decdata.im_handle = NULL;
+
+    if (verbose >= TC_DEBUG) {
+        tc_log_msg(__FILE__, "unloading video import module");
+    }
+
+    unload_module(video_decdata.im_handle);
+    video_decdata.im_handle = NULL;
+}
+
+
+/*************************************************************************/
+/*             the new multi-input sequential API                        */
+/*************************************************************************/
+
+static void dump_probeinfo(const ProbeInfo *pi, int i, const char *tag)
+{
+#ifdef DEBUG
+    tc_log_warn(__FILE__, "(%s): %ix%i asr=%i frc=%i codec=0x%lX",
+                tag, pi->width, pi->height, pi->asr, pi->frc, pi->codec);
+
+    if (i >= 0) {
+        tc_log_warn(__FILE__, "(%s): #%i %iHz %ich %ibits format=0x%X",
+                    tag, i,
+                    pi->track[i].samplerate, pi->track[i].chan,
+                    pi->track[i].bits, pi->track[i].format);
+    }
+#endif
+}
+
+static int probe_im_stream(const char *src, ProbeInfo *info)
+{
+    static pthread_mutex_t probe_mutex = PTHREAD_MUTEX_INITIALIZER; /* XXX */
+    /* UGLY! */
+    int ret = 1; /* be optimistic! */
+
+    pthread_mutex_lock(&probe_mutex);
+    ret = probe_stream_data(src, seek_range, info);
+    pthread_mutex_unlock(&probe_mutex);
+
+    dump_probeinfo(info, 0, "probed");
+
+    return ret;
+}
+
+static int probe_matches(const ProbeInfo *ref, const ProbeInfo *cand, int i)
+{
+    if (ref->width  != cand->width || ref->height != cand->height
+     || ref->frc    != cand->frc   || ref->asr    != cand->asr
+     || ref->codec  != cand->codec) {
+        tc_log_error(__FILE__, "video parameters mismatch");
+        dump_probeinfo(ref,  -1, "old");
+        dump_probeinfo(cand, -1, "new");
+        return 0;
+    }
+
+    if (i > ref->num_tracks || i > cand->num_tracks) {
+        tc_log_error(__FILE__, "track parameters mismatch (i=%i|ref=%i|cand=%i)",
+                     i, ref->num_tracks, cand->num_tracks);
+        return 0;
+    }
+    if (ref->track[i].samplerate != cand->track[i].samplerate
+     || ref->track[i].chan       != cand->track[i].chan      ) {
+//     || ref->track[i].bits       != cand->track[i].bits      ) { 
+//     || ref->track[i].format     != cand->track[i].format    ) { XXX XXX XXX
+        tc_log_error(__FILE__, "audio parameters mismatch");
+        dump_probeinfo(ref,  i, "old");
+        dump_probeinfo(cand, i, "new");
+        return 0;
+    }       
+
+    return 1;
+}
+
+static void probe_from_vob(ProbeInfo *info, const vob_t *vob)
+{
+    /* copy only interesting fields */
+    if (info != NULL && vob != NULL) {
+        int i = 0;
+
+        info->width    = vob->im_v_width;
+        info->height   = vob->im_v_height;
+        info->codec    = vob->v_codec_flag;
+        info->asr      = vob->im_asr;
+        info->frc      = vob->im_frc;
+
+        for (i = 0; i < TC_MAX_AUD_TRACKS; i++) {
+            memset(&(info->track[i]), 0, sizeof(ProbeTrackInfo));
+        }
+        i = vob->a_track;
+
+        info->track[i].samplerate = vob->a_rate;
+        info->track[i].chan       = vob->a_chan;
+        info->track[i].bits       = vob->a_bits;
+        info->track[i].format     = vob->a_codec_flag;
+    }
+}
+
+/* ok, that sucks. I know. I can't do any better now. */
+static const char *current_in_file(vob_t *vob, int kind)
+{
+    if (kind == TC_VIDEO)
+    	return vob->video_in_file;
+    if (kind == TC_AUDIO)
+    	return vob->audio_in_file;
+    return NULL; /* cannot happen */
+}
+
+#define RETURN_IF_PROBE_FAILED(ret, src) do {                        \
+    if (ret == 0) {                                                  \
+        tc_log_error(PACKAGE, "probing of source '%s' failed", src); \
+        status = TC_IM_THREAD_PROBE_ERROR;                           \
+    }                                                                \
+} while (0)
+
+/* black magic in here? Am I looking for troubles? */
+#define SWAP(type, a, b) do { \
+    type tmp = a;             \
+    a = b;                    \
+    b = tmp;                  \
+} while (0)
+
+
+/*************************************************************************/
+
+typedef struct tcmultiimportdata_ TCMultiImportData;
+struct tcmultiimportdata_ {
+    int             kind;
+
+    TCDecoderData   *decdata;
+    vob_t           *vob;
+
+    ProbeInfo       infos;
+
+    int             (*open)(vob_t *vob);
+    int             (*import_loop)(vob_t *vob);
+    int             (*close)(void);
+
+    int             (*next)(vob_t *vob);
+};
+
+
+#define MULTIDATA_INIT(MEDIA, VOB, KIND) do {                           \
+    MEDIA ## _multidata.kind         = KIND;                          \
+                                                                      \
+    MEDIA ## _multidata.vob          = VOB;                           \
+    MEDIA ## _multidata.decdata      = &(MEDIA ## _decdata);          \
+                                                                      \
+    MEDIA ## _multidata.open         = tc_import_ ## MEDIA ## _open;  \
+    MEDIA ## _multidata.import_loop  = MEDIA ## _import_loop;         \
+    MEDIA ## _multidata.close        = tc_import_ ## MEDIA ## _close; \
+    MEDIA ## _multidata.next         = tc_next_ ## MEDIA ## _in_file; \
+} while (0)
+
+#define MULTIDATA_FINI(MEDIA) do { \
+    ; /* nothing */ \
+} while (0)
+
+
+
+static TCMultiImportData audio_multidata;
+static TCMultiImportData video_multidata;
+
+/*************************************************************************/
+
+static void *multi_import_thread(void *_sid)
+{
+    static int status = TC_IM_THREAD_UNKNOWN; /* can't we be more specific? */
+
+    TCMultiImportData *sid = _sid;
+    int ret = TC_OK, track_id = sid->vob->a_track;
+    ProbeInfo infos;
+    ProbeInfo *old = &(sid->infos), *new = &infos;
+    const char *fname = NULL;
+    long int i = 1;
+
+    while (tc_running() && tc_import_thread_is_active(sid->decdata)) {
+        ret = sid->open(sid->vob);
+        if (ret == TC_ERROR) {
+            status = TC_IM_THREAD_EXT_ERROR;
+            break;
+        }
+
+        status = sid->import_loop(sid->vob);
+        /* source should always be closed */
+
+        ret = sid->close();
+        if (ret == TC_ERROR) {
+            status = TC_IM_THREAD_EXT_ERROR;
+            break;
+        }
+
+        ret = sid->next(sid->vob);
+        if (ret == TC_ERROR) {
+            status = TC_IM_THREAD_DONE;
+            break;
+        }
+
+        fname = current_in_file(sid->vob, sid->kind);
+        /* probing coherency check */
+        ret = probe_im_stream(fname, new);
+        RETURN_IF_PROBE_FAILED(ret, fname);
+
+        if (probe_matches(old, new, track_id)) {
+            if (verbose) {
+                tc_log_info(__FILE__, "switching to %s source #%li: %s",
+                            sid->decdata->tag, i, fname);
+            }
+        } else {
+            tc_log_error(PACKAGE, "source '%s' in directory"
+                                  " not compatible with former", fname);
+            status = TC_IM_THREAD_PROBE_ERROR;
+            break;
+        }
+        /* now prepare for next probing round by swapping pointers */
+        SWAP(ProbeInfo*, old, new);
+
+        i++;
+    }
+    status = stop_cause(status);
+
+    tc_framebuffer_interrupt();
+
+    pthread_exit(&status);
+}
+
+/*************************************************************************/
+
+void tc_multi_import_threads_create(vob_t *vob)
+{
+    int ret;
+
+    probe_from_vob(&(audio_multidata.infos), vob);
+    MULTIDATA_INIT(audio, vob, TC_AUDIO);
+    tc_import_thread_start(&audio_decdata);
+    ret = pthread_create(&audio_decdata.thread_id, NULL,
+                         multi_import_thread, &audio_multidata);
+    if (ret != 0) {
+        tc_error("failed to start sequential audio stream import thread");
+    }
+
+    probe_from_vob(&(video_multidata.infos), vob);
+    MULTIDATA_INIT(video, vob, TC_VIDEO);
+    tc_import_thread_start(&video_decdata);
+    ret = pthread_create(&video_decdata.thread_id, NULL,
+                         multi_import_thread, &video_multidata);
+    if (ret != 0) {
+        tc_error("failed to start sequential video stream import thread");
+    }
+
+    tc_info("sequential streams import threads started");
+}
+
+
+void tc_multi_import_threads_cancel(void)
+{
+    MULTIDATA_FINI(audio);
+    MULTIDATA_FINI(video);
+
+    tc_import_threads_cancel();
+}
+
+
+/*************************************************************************/
+
+/*
+ * Local variables:
+ *   c-file-style: "stroustrup"
+ *   c-file-offsets: ((case-label . *) (statement-case-intro . *))
+ *   indent-tabs-mode: nil
+ * End:
+ *
+ * vim: expandtab shiftwidth=4:
+ */
+