plugins loading and failing

8 files changed, 698 insertions, 61 deletions

diff --git a/interfaces02.h b/interfaces02.h
new file mode 100644
index 0000000..f0b8ef7
--- /dev/null
+++ b/interfaces02.h
@@ -0,0 +1,22 @@
+/*
+
+
+*/
+
+namespace rotor {
+	class base_object{
+		int ID;
+	};
+	class base_input: public abstract_object{
+		
+	};
+	class base_output: public abstract_object{
+		
+	};
+	class base_node: public abstract_object{
+		
+	};
+	class patch_bay{ //the whole thing
+		
+	};
+}
diff --git a/rotord/Makefile b/rotord/Makefile
index d828a1c..f96f587 100644
--- a/rotord/Makefile
+++ b/rotord/Makefile
@@ -1,8 +1,8 @@
 # The pre-processor and compiler options.
-MY_CFLAGS = 
+MY_CFLAGS = -I ../ffmpeg -fpermissive
 
 # The linker options.
-MY_LIBS   = -lPocoNet -lPocoXML -lPocoUtil -lPocoFoundation -lvamp-hostsdk -lsndfile
+MY_LIBS   = -lPocoNet -lPocoXML -lPocoUtil -lPocoFoundation -lvamp-hostsdk -lsndfile -lavcodec
 
 # The pre-processor options used by the cpp (man cpp for more).
 CPPFLAGS  = -Wall
diff --git a/rotord/avCodec.cpp b/rotord/avCodec.cpp
new file mode 100644
index 0000000..61c201b
--- /dev/null
+++ b/rotord/avCodec.cpp
@@ -0,0 +1,574 @@
+#include "avCodec.h"
+
+#define INBUF_SIZE 4096
+#define AUDIO_INBUF_SIZE 20480
+#define AUDIO_REFILL_THRESH 4096
+
+/* check that a given sample format is supported by the encoder */
+static int avCodec::check_sample_fmt(AVCodec *codec, enum AVSampleFormat sample_fmt)
+{
+    const enum AVSampleFormat *p = codec->sample_fmts;
+
+    while (*p != AV_SAMPLE_FMT_NONE) {
+        if (*p == sample_fmt)
+            return 1;
+        p++;
+    }
+    return 0;
+}
+
+/* just pick the highest supported samplerate */
+static int avCodec::select_sample_rate(AVCodec *codec)
+{
+    const int *p;
+    int best_samplerate = 0;
+
+    if (!codec->supported_samplerates)
+        return 44100;
+
+    p = codec->supported_samplerates;
+    while (*p) {
+        best_samplerate = FFMAX(*p, best_samplerate);
+        p++;
+    }
+    return best_samplerate;
+}
+
+/* select layout with the highest channel count */
+static int avCodec::select_channel_layout(AVCodec *codec)
+{
+    const uint64_t *p;
+    uint64_t best_ch_layout = 0;
+    int best_nb_channells   = 0;
+
+    if (!codec->channel_layouts)
+        return AV_CH_LAYOUT_STEREO;
+
+    p = codec->channel_layouts;
+    while (*p) {
+        int nb_channels = av_get_channel_layout_nb_channels(*p);
+
+        if (nb_channels > best_nb_channells) {
+            best_ch_layout    = *p;
+            best_nb_channells = nb_channels;
+        }
+        p++;
+    }
+    return best_ch_layout;
+}
+
+/*
+ * Audio encoding example
+ */
+static void avCodec::audio_encode_example(const char *filename)
+{
+    AVCodec *codec;
+    AVCodecContext *c= NULL;
+    AVFrame *frame;
+    AVPacket pkt;
+    int i, j, k, ret, got_output;
+    int buffer_size;
+    FILE *f;
+    uint16_t *samples;
+    float t, tincr;
+
+    printf("Encode audio file %s\n", filename);
+
+    /* find the MP2 encoder */
+    codec = avcodec_find_encoder(AV_CODEC_ID_MP2);
+    if (!codec) {
+        fprintf(stderr, "Codec not found\n");
+        exit(1);
+    }
+
+    c = avcodec_alloc_context3(codec);
+    if (!c) {
+        fprintf(stderr, "Could not allocate audio codec context\n");
+        exit(1);
+    }
+
+    /* put sample parameters */
+    c->bit_rate = 64000;
+
+    /* check that the encoder supports s16 pcm input */
+    c->sample_fmt = AV_SAMPLE_FMT_S16;
+    if (!check_sample_fmt(codec, c->sample_fmt)) {
+        fprintf(stderr, "Encoder does not support sample format %s",
+                av_get_sample_fmt_name(c->sample_fmt));
+        exit(1);
+    }
+
+    /* select other audio parameters supported by the encoder */
+    c->sample_rate    = select_sample_rate(codec);
+    c->channel_layout = select_channel_layout(codec);
+    c->channels       = av_get_channel_layout_nb_channels(c->channel_layout);
+
+    /* open it */
+    if (avcodec_open2(c, codec, NULL) < 0) {
+        fprintf(stderr, "Could not open codec\n");
+        exit(1);
+    }
+
+    f = fopen(filename, "wb");
+    if (!f) {
+        fprintf(stderr, "Could not open %s\n", filename);
+        exit(1);
+    }
+
+    /* frame containing input raw audio */
+    frame = avcodec_alloc_frame();
+    if (!frame) {
+        fprintf(stderr, "Could not allocate audio frame\n");
+        exit(1);
+    }
+
+    frame->nb_samples     = c->frame_size;
+    frame->format         = c->sample_fmt;
+    frame->channel_layout = c->channel_layout;
+
+    /* the codec gives us the frame size, in samples,
+     * we calculate the size of the samples buffer in bytes */
+    buffer_size = av_samples_get_buffer_size(NULL, c->channels, c->frame_size,
+                                             c->sample_fmt, 0);
+    samples = (uint16_t*)av_malloc(buffer_size);
+    if (!samples) {
+        fprintf(stderr, "Could not allocate %d bytes for samples buffer\n",
+                buffer_size);
+        exit(1);
+    }
+    /* setup the data pointers in the AVFrame */
+    ret = avcodec_fill_audio_frame(frame, c->channels, c->sample_fmt,
+                                   (const uint8_t*)samples, buffer_size, 0);
+    if (ret < 0) {
+        fprintf(stderr, "Could not setup audio frame\n");
+        exit(1);
+    }
+
+    /* encode a single tone sound */
+    t = 0;
+    tincr = 2 * M_PI * 440.0 / c->sample_rate;
+    for(i=0;i<200;i++) {
+        av_init_packet(&pkt);
+        pkt.data = NULL; // packet data will be allocated by the encoder
+        pkt.size = 0;
+
+        for (j = 0; j < c->frame_size; j++) {
+            samples[2*j] = (int)(sin(t) * 10000);
+
+            for (k = 1; k < c->channels; k++)
+                samples[2*j + k] = samples[2*j];
+            t += tincr;
+        }
+        /* encode the samples */
+        ret = avcodec_encode_audio2(c, &pkt, frame, &got_output);
+        if (ret < 0) {
+            fprintf(stderr, "Error encoding audio frame\n");
+            exit(1);
+        }
+        if (got_output) {
+            fwrite(pkt.data, 1, pkt.size, f);
+            av_free_packet(&pkt);
+        }
+    }
+
+    /* get the delayed frames */
+    for (got_output = 1; got_output; i++) {
+        ret = avcodec_encode_audio2(c, &pkt, NULL, &got_output);
+        if (ret < 0) {
+            fprintf(stderr, "Error encoding frame\n");
+            exit(1);
+        }
+
+        if (got_output) {
+            fwrite(pkt.data, 1, pkt.size, f);
+            av_free_packet(&pkt);
+        }
+    }
+    fclose(f);
+
+    av_freep(&samples);
+    avcodec_free_frame(&frame);
+    avcodec_close(c);
+    av_free(c);
+}
+
+/*
+ * Audio decoding.
+ */
+static void avCodec::audio_decode_example(const char *outfilename, const char *filename)
+{
+    AVCodec *codec;
+    AVCodecContext *c= NULL;
+    int len;
+    FILE *f, *outfile;
+    uint8_t inbuf[AUDIO_INBUF_SIZE + FF_INPUT_BUFFER_PADDING_SIZE];
+    AVPacket avpkt;
+    AVFrame *decoded_frame = NULL;
+
+    av_init_packet(&avpkt);
+
+    printf("Decode audio file %s to %s\n", filename, outfilename);
+
+    /* find the mpeg audio decoder */
+    codec = avcodec_find_decoder(AV_CODEC_ID_MP2);
+    if (!codec) {
+        fprintf(stderr, "Codec not found\n");
+        exit(1);
+    }
+
+    c = avcodec_alloc_context3(codec);
+    if (!c) {
+        fprintf(stderr, "Could not allocate audio codec context\n");
+        exit(1);
+    }
+
+    /* open it */
+    if (avcodec_open2(c, codec, NULL) < 0) {
+        fprintf(stderr, "Could not open codec\n");
+        exit(1);
+    }
+
+    f = fopen(filename, "rb");
+    if (!f) {
+        fprintf(stderr, "Could not open %s\n", filename);
+        exit(1);
+    }
+    outfile = fopen(outfilename, "wb");
+    if (!outfile) {
+        av_free(c);
+        exit(1);
+    }
+
+    /* decode until eof */
+    avpkt.data = inbuf;
+    avpkt.size = fread(inbuf, 1, AUDIO_INBUF_SIZE, f);
+
+    while (avpkt.size > 0) {
+        int got_frame = 0;
+
+        if (!decoded_frame) {
+            if (!(decoded_frame = avcodec_alloc_frame())) {
+                fprintf(stderr, "Could not allocate audio frame\n");
+                exit(1);
+            }
+        } else
+            avcodec_get_frame_defaults(decoded_frame);
+
+        len = avcodec_decode_audio4(c, decoded_frame, &got_frame, &avpkt);
+        if (len < 0) {
+            fprintf(stderr, "Error while decoding\n");
+            exit(1);
+        }
+        if (got_frame) {
+            /* if a frame has been decoded, output it */
+            int data_size = av_samples_get_buffer_size(NULL, c->channels,
+                                                       decoded_frame->nb_samples,
+                                                       c->sample_fmt, 1);
+            fwrite(decoded_frame->data[0], 1, data_size, outfile);
+        }
+        avpkt.size -= len;
+        avpkt.data += len;
+        avpkt.dts =
+        avpkt.pts = AV_NOPTS_VALUE;
+        if (avpkt.size < AUDIO_REFILL_THRESH) {
+            /* Refill the input buffer, to avoid trying to decode
+             * incomplete frames. Instead of this, one could also use
+             * a parser, or use a proper container format through
+             * libavformat. */
+            memmove(inbuf, avpkt.data, avpkt.size);
+            avpkt.data = inbuf;
+            len = fread(avpkt.data + avpkt.size, 1,
+                        AUDIO_INBUF_SIZE - avpkt.size, f);
+            if (len > 0)
+                avpkt.size += len;
+        }
+    }
+
+    fclose(outfile);
+    fclose(f);
+
+    avcodec_close(c);
+    av_free(c);
+    avcodec_free_frame(&decoded_frame);
+}
+
+/*
+ * Video encoding example
+ */
+static void avCodec::video_encode_example(const char *filename, int codec_id)
+{
+    AVCodec *codec;
+    AVCodecContext *c= NULL;
+    int i, ret, x, y, got_output;
+    FILE *f;
+    AVFrame *frame;
+    AVPacket pkt;
+    uint8_t endcode[] = { 0, 0, 1, 0xb7 };
+
+    printf("Encode video file %s\n", filename);
+
+    /* find the mpeg1 video encoder */
+    codec =avcodec_find_encoder(codec_id);
+    if (!codec) {
+        fprintf(stderr, "Codec not found\n");
+        exit(1);
+    }
+
+    c = avcodec_alloc_context3(codec);
+    if (!c) {
+        fprintf(stderr, "Could not allocate video codec context\n");
+        exit(1);
+    }
+
+    /* put sample parameters */
+    c->bit_rate = 400000;
+    /* resolution must be a multiple of two */
+    c->width = 352;
+    c->height = 288;
+    /* frames per second */
+    c->time_base= (AVRational){1,25};
+    c->gop_size = 10; /* emit one intra frame every ten frames */
+    c->max_b_frames=1;
+    c->pix_fmt = AV_PIX_FMT_YUV420P;
+
+    if(codec_id == AV_CODEC_ID_H264)
+        av_opt_set(c->priv_data, "preset", "slow", 0);
+
+    /* open it */
+    if (avcodec_open2(c, codec, NULL) < 0) {
+        fprintf(stderr, "Could not open codec\n");
+        exit(1);
+    }
+
+    f = fopen(filename, "wb");
+    if (!f) {
+        fprintf(stderr, "Could not open %s\n", filename);
+        exit(1);
+    }
+
+    frame = avcodec_alloc_frame();
+    if (!frame) {
+        fprintf(stderr, "Could not allocate video frame\n");
+        exit(1);
+    }
+    frame->format = c->pix_fmt;
+    frame->width  = c->width;
+    frame->height = c->height;
+
+    /* the image can be allocated by any means and av_image_alloc() is
+     * just the most convenient way if av_malloc() is to be used */
+    ret = av_image_alloc(frame->data, frame->linesize, c->width, c->height,
+                         c->pix_fmt, 32);
+    if (ret < 0) {
+        fprintf(stderr, "Could not allocate raw picture buffer\n");
+        exit(1);
+    }
+
+    /* encode 1 second of video */
+    for(i=0;i<25;i++) {
+        av_init_packet(&pkt);
+        pkt.data = NULL;    // packet data will be allocated by the encoder
+        pkt.size = 0;
+
+        fflush(stdout);
+        /* prepare a dummy image */
+        /* Y */
+        for(y=0;y<c->height;y++) {
+            for(x=0;x<c->width;x++) {
+                frame->data[0][y * frame->linesize[0] + x] = x + y + i * 3;
+            }
+        }
+
+        /* Cb and Cr */
+        for(y=0;y<c->height/2;y++) {
+            for(x=0;x<c->width/2;x++) {
+                frame->data[1][y * frame->linesize[1] + x] = 128 + y + i * 2;
+                frame->data[2][y * frame->linesize[2] + x] = 64 + x + i * 5;
+            }
+        }
+
+        frame->pts = i;
+
+        /* encode the image */
+        ret = avcodec_encode_video2(c, &pkt, frame, &got_output);
+        if (ret < 0) {
+            fprintf(stderr, "Error encoding frame\n");
+            exit(1);
+        }
+
+        if (got_output) {
+            printf("Write frame %3d (size=%5d)\n", i, pkt.size);
+            fwrite(pkt.data, 1, pkt.size, f);
+            av_free_packet(&pkt);
+        }
+    }
+
+    /* get the delayed frames */
+    for (got_output = 1; got_output; i++) {
+        fflush(stdout);
+
+        ret = avcodec_encode_video2(c, &pkt, NULL, &got_output);
+        if (ret < 0) {
+            fprintf(stderr, "Error encoding frame\n");
+            exit(1);
+        }
+
+        if (got_output) {
+            printf("Write frame %3d (size=%5d)\n", i, pkt.size);
+            fwrite(pkt.data, 1, pkt.size, f);
+            av_free_packet(&pkt);
+        }
+    }
+
+    /* add sequence end code to have a real mpeg file */
+    fwrite(endcode, 1, sizeof(endcode), f);
+    fclose(f);
+
+    avcodec_close(c);
+    av_free(c);
+    av_freep(&frame->data[0]);
+    avcodec_free_frame(&frame);
+    printf("\n");
+}
+
+/*
+ * Video decoding example
+ */
+
+static void avCodec::pgm_save(unsigned char *buf, int wrap, int xsize, int ysize,
+                     char *filename)
+{
+    FILE *f;
+    int i;
+
+    f=fopen(filename,"w");
+    fprintf(f,"P5\n%d %d\n%d\n",xsize,ysize,255);
+    for(i=0;i<ysize;i++)
+        fwrite(buf + i * wrap,1,xsize,f);
+    fclose(f);
+}
+
+static int avCodec::decode_write_frame(const char *outfilename, AVCodecContext *avctx,
+                              AVFrame *frame, int *frame_count, AVPacket *pkt, int last)
+{
+    int len, got_frame;
+    char buf[1024];
+
+    len = avcodec_decode_video2(avctx, frame, &got_frame, pkt);
+    if (len < 0) {
+        fprintf(stderr, "Error while decoding frame %d\n", *frame_count);
+        return len;
+    }
+    if (got_frame) {
+        printf("Saving %sframe %3d\n", last ? "last " : "", *frame_count);
+        fflush(stdout);
+
+        /* the picture is allocated by the decoder, no need to free it */
+        snprintf(buf, sizeof(buf), outfilename, *frame_count);
+        pgm_save(frame->data[0], frame->linesize[0],
+                 avctx->width, avctx->height, buf);
+        (*frame_count)++;
+    }
+    if (pkt->data) {
+        pkt->size -= len;
+        pkt->data += len;
+    }
+    return 0;
+}
+
+static void avCodec::video_decode_example(const char *outfilename, const char *filename)
+{
+    AVCodec *codec;
+    AVCodecContext *c= NULL;
+    int frame_count;
+    FILE *f;
+    AVFrame *frame;
+    uint8_t inbuf[INBUF_SIZE + FF_INPUT_BUFFER_PADDING_SIZE];
+    AVPacket avpkt;
+
+    av_init_packet(&avpkt);
+
+    /* set end of buffer to 0 (this ensures that no overreading happens for damaged mpeg streams) */
+    memset(inbuf + INBUF_SIZE, 0, FF_INPUT_BUFFER_PADDING_SIZE);
+
+    printf("Decode video file %s to %s\n", filename, outfilename);
+
+    /* find the mpeg1 video decoder */
+    codec = avcodec_find_decoder(AV_CODEC_ID_MPEG1VIDEO);
+    if (!codec) {
+        fprintf(stderr, "Codec not found\n");
+        exit(1);
+    }
+
+    c = avcodec_alloc_context3(codec);
+    if (!c) {
+        fprintf(stderr, "Could not allocate video codec context\n");
+        exit(1);
+    }
+
+    if(codec->capabilities&CODEC_CAP_TRUNCATED)
+        c->flags|= CODEC_FLAG_TRUNCATED; /* we do not send complete frames */
+
+    /* For some codecs, such as msmpeg4 and mpeg4, width and height
+       MUST be initialized there because this information is not
+       available in the bitstream. */
+
+    /* open it */
+    if (avcodec_open2(c, codec, NULL) < 0) {
+        fprintf(stderr, "Could not open codec\n");
+        exit(1);
+    }
+
+    f = fopen(filename, "rb");
+    if (!f) {
+        fprintf(stderr, "Could not open %s\n", filename);
+        exit(1);
+    }
+
+    frame = avcodec_alloc_frame();
+    if (!frame) {
+        fprintf(stderr, "Could not allocate video frame\n");
+        exit(1);
+    }
+
+    frame_count = 0;
+    for(;;) {
+        avpkt.size = fread(inbuf, 1, INBUF_SIZE, f);
+        if (avpkt.size == 0)
+            break;
+
+        /* NOTE1: some codecs are stream based (mpegvideo, mpegaudio)
+           and this is the only method to use them because you cannot
+           know the compressed data size before analysing it.
+
+           BUT some other codecs (msmpeg4, mpeg4) are inherently frame
+           based, so you must call them with all the data for one
+           frame exactly. You must also initialize 'width' and
+           'height' before initializing them. */
+
+        /* NOTE2: some codecs allow the raw parameters (frame size,
+           sample rate) to be changed at any frame. We handle this, so
+           you should also take care of it */
+
+        /* here, we use a stream based decoder (mpeg1video), so we
+           feed decoder and see if it could decode a frame */
+        avpkt.data = inbuf;
+        while (avpkt.size > 0)
+            if (decode_write_frame(outfilename, c, frame, &frame_count, &avpkt, 0) < 0)
+                exit(1);
+    }
+
+    /* some codecs, such as MPEG, transmit the I and P frame with a
+       latency of one frame. You must do the following to have a
+       chance to get the last frame of the video */
+    avpkt.data = NULL;
+    avpkt.size = 0;
+    decode_write_frame(outfilename, c, frame, &frame_count, &avpkt, 1);
+
+    fclose(f);
+
+    avcodec_close(c);
+    av_free(c);
+    avcodec_free_frame(&frame);
+    printf("\n");
+}
\ No newline at end of file
diff --git a/rotord/avCodec.h b/rotord/avCodec.h
new file mode 100644
index 0000000..7e1815a
--- /dev/null
+++ b/rotord/avCodec.h
@@ -0,0 +1,35 @@
+// libav includes
+// from /usr/include
+
+extern "C" {
+	#ifndef __STDC_CONSTANT_MACROS
+	#  define __STDC_CONSTANT_MACROS
+	#endif
+	
+	#ifndef UINT64_C
+	#define UINT64_C(c) (c ## ULL)
+	#endif
+
+	#include <math.h>
+	
+	#include "libavcodec/avcodec.h"
+
+	#include "libavutil/opt.h"
+	#include "libavutil/channel_layout.h"
+	#include "libavutil/common.h"
+	#include "libavutil/imgutils.h"
+	#include "libavutil/mathematics.h"
+	#include "libavutil/samplefmt.h"
+}
+
+namespace avCodec {
+	static int check_sample_fmt(AVCodec *codec, enum AVSampleFormat sample_fmt);
+	static int select_sample_rate(AVCodec *codec);
+	static int select_channel_layout(AVCodec *codec);
+	static void audio_encode_example(const char *filename);
+	static void audio_decode_example(const char *outfilename, const char *filename);
+	static void video_encode_example(const char *filename, int codec_id);
+	static void pgm_save(unsigned char *buf, int wrap, int xsize, int ysize,char *filename);
+	static int decode_write_frame(const char *outfilename, AVCodecContext *avctx,AVFrame *frame, int *frame_count, AVPacket *pkt, int last);
+	static void video_decode_example(const char *outfilename, const char *filename);
+}
\ No newline at end of file
diff --git a/rotord/rotord.cpp b/rotord/rotord.cpp
index e794b7d..e6460c6 100755
--- a/rotord/rotord.cpp
+++ b/rotord/rotord.cpp
@@ -1,5 +1,34 @@
 #include "rotord.h"
 
+/*
+ultimately- audio analysis request will spawn a task - there will be another call that will check progress
+
+audio analysis will be saved - to a file? into a db?
+
+for now - dump analysis into the http request
+
+architecture - running rendering process
+
+main vamp library segmenter, beat detector
+
+http://127.0.0.1:9000/vamp/qm-vamp-plugins/qm-segmenter/01.wav
+
+Running plugin: "qm-segmenter"...
+Using block size = 26460, step size = 8820
+Plugin accepts 1 -> 1 channel(s)
+Sound file has 2 (will mix/augment if necessary)
+Output is: "segmentation"
+Done
+./rotord: symbol lookup error: /usr/local/lib/vamp/qm-vamp-plugins.so: undefined symbol: clapack_dgetrf
+
+next:
+load a movie and retreive frames
+save a movie
+
+how do we deal with frames in libavcodec - can we request a frame by number
+how do we deal with resolution
+*/
+
 RotorRequestHandler::RotorRequestHandler(const std::string& format): _format(format){
 }
 
@@ -32,7 +61,7 @@ void AudioAnalyserHandler::handleRequest(HTTPServerRequest& request,HTTPServerRe
         response.setChunkedTransferEncoding(true);
         response.setContentType("text/html");
 	
-	string audioData=vampHost::
+	//string audioData=vampHost::runPlugin();
 
         std::ostream& ostr = response.send();
         ostr << "<html><head><title>RotorServer powered by "
@@ -40,12 +69,10 @@ void AudioAnalyserHandler::handleRequest(HTTPServerRequest& request,HTTPServerRe
         ostr << "</head>";
         ostr << "<body><p style=\"text-align: center; "
                 "font-size: 48px;\">";
-        ostr << dt;
+	vampHost::runPlugin("",settings.soname,settings.filtername, "",0, settings.inputFile, ostr,true);
         ostr << "</p></body></html>";
 }
 
-AudioAnalyserFactory::AudioAnalyserFactory(const vampHost::Settings& _settings): settings(_settings){
-}
 
 HTTPRequestHandler* RotorRequestHandlerFactory::createRequestHandler(const HTTPServerRequest& request){
 	Application& app = Application::instance();
@@ -71,7 +98,9 @@ HTTPRequestHandler* RotorRequestHandlerFactory::createRequestHandler(const HTTPS
 	else if (segments[0]=="vamp"&&segments.size()>3) {
 			// vamp/plugin/filter/filename
 			// how do deal with error condition?
-		return new RotorRequestHandler(_format);
+		
+		//Settings(string _so="",string _filter="",string _id="",string _input="");
+		return new AudioAnalyserHandler(vampHost::Settings(segments[1],segments[2],segments[3]));
 		//string audioData=runPlugin(string myname, string soname, string id,
 		//      string output, int outputNo, string wavname,
 		//      string outfilename, bool useFrames);
@@ -127,7 +156,7 @@ int RotorServer::main(const std::vector<std::string>& args){
 		unsigned short port = (unsigned short) config().getInt("port", 9980);
 		std::string format(config().getString("format", DateTimeFormat::SORTABLE_FORMAT));
 		ServerSocket svs(port);
-		HTTPServer srv(new RotorRequestHandlerFactory(format), svs, new HTTPServerParams);
+		HTTPServer srv(new RotorRequestHandlerFactory(format),svs, new HTTPServerParams);
 		srv.start();
 		waitForTerminationRequest();
 		srv.stop();
diff --git a/rotord/rotord.h b/rotord/rotord.h
index 20ea2c6..a90bd75 100755
--- a/rotord/rotord.h
+++ b/rotord/rotord.h
@@ -39,6 +39,7 @@ using Poco::Util::OptionCallback;
 using Poco::Util::HelpFormatter;
 
 #include "vampHost.h"
+#include "avCodec.h"
 
 class RotorRequestHandler: public HTTPRequestHandler
 {
@@ -68,15 +69,6 @@ class AudioAnalyserHandler: public HTTPRequestHandler
 		vampHost::Settings settings;
 };
 
-class AudioAnalyserFactory: public HTTPRequestHandlerFactory
-{
-	public:
-		AudioAnalyserFactory(const vampHost::Settings& _settings);
-		HTTPRequestHandler* createRequestHandler(const HTTPServerRequest& request);
-	private:
-		vampHost::Settings settings;
-};
-
 
 
 class RotorServer: public Poco::Util::ServerApplication
diff --git a/rotord/vampHost.cpp b/rotord/vampHost.cpp
index 8423c54..54ce77b 100644
--- a/rotord/vampHost.cpp
+++ b/rotord/vampHost.cpp
@@ -1,8 +1,8 @@
 #include "vampHost.h"
 
-int vampHost::runPlugin(string myname, string soname, string id,
-              string output, int outputNo, string wavname,
-              string outfilename, bool useFrames)
+int vampHost::runPlugin(string myname, string soname, string id, string output,
+	int outputNo, string inputFile, ostream& out, bool useFrames)
+
 {
     PluginLoader *loader = PluginLoader::getInstance();
 
@@ -12,34 +12,19 @@ int vampHost::runPlugin(string myname, string soname, string id,
     SF_INFO sfinfo;
     memset(&sfinfo, 0, sizeof(SF_INFO));
 
-    sndfile = sf_open(wavname.c_str(), SFM_READ, &sfinfo);
+    sndfile = sf_open(inputFile.c_str(), SFM_READ, &sfinfo);
     if (!sndfile) {
         cerr << myname << ": ERROR: Failed to open input file \""
-             << wavname << "\": " << sf_strerror(sndfile) << endl;
+             << inputFile << "\": " << sf_strerror(sndfile) << endl;
         return 1;
     }
 
-    ofstream *out = 0;
-    if (outfilename != "") {
-        out = new ofstream(outfilename.c_str(), ios::out);
-        if (!*out) {
-            cerr << myname << ": ERROR: Failed to open output file \""
-                 << outfilename << "\" for writing" << endl;
-            delete out;
-            return 1;
-        }
-    }
-
     Plugin *plugin = loader->loadPlugin
         (key, sfinfo.samplerate, PluginLoader::ADAPT_ALL_SAFE);
     if (!plugin) {
         cerr << myname << ": ERROR: Failed to load plugin \"" << id
              << "\" from library \"" << soname << "\"" << endl;
         sf_close(sndfile);
-        if (out) {
-            out->close();
-            delete out;
-        }
         return 1;
     }
 
@@ -192,7 +177,7 @@ int vampHost::runPlugin(string myname, string soname, string id,
 
         rt = RealTime::frame2RealTime(currentStep * stepSize, sfinfo.samplerate);
 
-        printFeatures
+        vampHost::printFeatures
             (RealTime::realTime2Frame(rt + adjustment, sfinfo.samplerate),
              sfinfo.samplerate, outputNo, plugin->process(plugbuf, rt),
              out, useFrames);
@@ -213,7 +198,7 @@ int vampHost::runPlugin(string myname, string soname, string id,
 
     rt = RealTime::frame2RealTime(currentStep * stepSize, sfinfo.samplerate);
 
-    printFeatures(RealTime::realTime2Frame(rt + adjustment, sfinfo.samplerate),
+    vampHost::printFeatures(RealTime::realTime2Frame(rt + adjustment, sfinfo.samplerate),
                   sfinfo.samplerate, outputNo,
                   plugin->getRemainingFeatures(), out, useFrames);
 
@@ -221,16 +206,12 @@ int vampHost::runPlugin(string myname, string soname, string id,
 
 done:
     delete plugin;
-    if (out) {
-        out->close();
-        delete out;
-    }
     sf_close(sndfile);
     return returnValue;
 }
 
 void vampHost::printFeatures(int frame, int sr, int output,
-              Plugin::FeatureSet features, ofstream *out, bool useFrames)
+              Plugin::FeatureSet features, ostream& out, bool useFrames)
 {
     for (unsigned int i = 0; i < features[output].size(); ++i) {
 
@@ -243,15 +224,15 @@ void vampHost::printFeatures(int frame, int sr, int output,
                     (features[output][i].timestamp, sr);
             }
 
-            (out ? *out : cout) << displayFrame;
+            out << displayFrame;
 
             if (features[output][i].hasDuration) {
                 displayFrame = RealTime::realTime2Frame
                     (features[output][i].duration, sr);
-                (out ? *out : cout) << "," << displayFrame;
+                out << "," << displayFrame;
             }
 
-            (out ? *out : cout)  << ":";
+            out  << ":";
 
         } else {
 
@@ -261,21 +242,22 @@ void vampHost::printFeatures(int frame, int sr, int output,
                 rt = features[output][i].timestamp;
             }
 
-            (out ? *out : cout) << rt.toString();
+            out << rt.toString();
 
             if (features[output][i].hasDuration) {
                 rt = features[output][i].duration;
-                (out ? *out : cout) << "," << rt.toString();
+                out<< "," << rt.toString();
             }
 
-            (out ? *out : cout) << ":";
+            out << ":";
         }
 
         for (unsigned int j = 0; j < features[output][i].values.size(); ++j) {
-            (out ? *out : cout) << " " << features[output][i].values[j];
+            out<< " " << features[output][i].values[j];
         }
-        (out ? *out : cout) << " " << features[output][i].label;
+        out << " " << features[output][i].label;
 
-        (out ? *out : cout) << endl;
+        out << endl;
     }
+    
 }
\ No newline at end of file
diff --git a/rotord/vampHost.h b/rotord/vampHost.h
index 6bc6b75..03a375e 100755
--- a/rotord/vampHost.h
+++ b/rotord/vampHost.h
@@ -28,16 +28,19 @@ using Vamp::HostExt::PluginInputDomainAdapter;
 namespace vampHost {
 	
 	class Settings{
-		Settings(string _so="",string _filter="",string _id="",string _input="");
-		string soname;
-		string filtername;
-		string id;
-		string inputFile;
-		string output;
+		public:
+			Settings(string _so="",string _filter="",string _input="") {
+				soname=_so;
+				filtername=_filter;
+				inputFile=_input;
+			}
+			string soname;
+			string filtername;
+			string inputFile;
 	};
 
 
-	void printFeatures(int, int, int, Plugin::FeatureSet, ofstream *, bool frames);
-	int runPlugin(string myname, string soname, string id, string output,int outputNo, string inputFile, string outfilename, bool frames);
+	void printFeatures(int, int, int, Plugin::FeatureSet, ostream &, bool frames);
+	int runPlugin(string myname, string soname, string id, string output,int outputNo, string inputFile, ostream& out, bool frames);
 
 }
\ No newline at end of file