/*

 Project Carmack 0.01  (AKA Media Library Prototype 01/02)
 Copyright John Ryland, 2005

*/

using namespace std;

#include <iostream>
#include <list>
#include <map>

#include <assert.h>
#include <math.h>
#include <string.h>
#include <pthread.h>
#include <semaphore.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/soundcard.h>
#include <sys/ioctl.h>
#include <sys/stat.h>

#include <avformat.h>
#include <avcodec.h>


/*

Example sources to support:

file:/home/user/Documents/images/jpeg/picture.jpg
file:/home/user/Documents/audio/mpeg/greatestsong.mp3
file:/home/user/Documents/application/playlist/favourites.pls
file:/home/user/Documents/application/playlist/favourites.mpu
http://www.slashdot.org/somefile.mpg
http://www.streaming_radio_server.net:9000
http://www.streaming_tv_server.net:9000
camera
microphone
camera & microphone


Example outputs to support:

File/URL
UDP packets
TCP/IP packets
OSS
Alsa
QSS
Visualiser
QDirectPainter
QPainter
XShm
DirectDraw
YUV acceleration

*/

/*
1 = registerNewFormat("AAC", ".aac", "An AAC decoder", AUDIO_CODEC);
2 = registerNewFormat("MP3", ".mp3", "MP3 decoder", AUDIO_CODEC);
2 = registerNewFormat("MP3", ".mp3", "MAD decoder", AUDIO_CODEC);
1 = registerNewFormat("AAC", ".aac", "My AAC decoder", AUDIO_CODEC);
3 = registerNewFormat("3DS", ".3ds", "3D Studio File", AUDIO_CODEC);


enum FormatType {
    FRAME_ID_FILE_PROTO,
    FRAME_ID_HTTP_PROTO,
    FRAME_ID_RTSP_PROTO,
    FRAME_ID_RTP_PROTO,
    FRAME_ID_MMS_PROTO,

    FRAME_ID_GIF_FORMAT,
    FRAME_ID_JPG_FORMAT,
    FRAME_ID_PNG_FORMAT,

    FRAME_ID_MP3_FORMAT,
    FRAME_ID_WAV_FORMAT,
    FRAME_ID_GSM_FORMAT,
    FRAME_ID_AMR_FORMAT,

    FRAME_ID_MPG_FORMAT,
    FRAME_ID_AVI_FORMAT,
    FRAME_ID_MP4_FORMAT,
    FRAME_ID_MOV_FORMAT,

    FRAME_ID_FIRST_PACKET_TYPE,
    FRAME_ID_MPEG_AUDIO_PACKET = FRAME_ID_FIRST_PACKET_TYPE,
    FRAME_ID_MPEG1_VIDEO_PACKET,
    FRAME_ID_MPEG2_VIDEO_PACKET,
    FRAME_ID_MPEG4_VIDEO_PACKET,
    FRAME_ID_QT_VIDEO_PACKET,
    FRAME_ID_GSM_AUDIO_PACKET,
    FRAME_ID_AMR_AUDIO_PACKET,
    FRAME_ID_AAC_AUDIO_PACKET,
    FRAME_ID_LAST_PACKET_TYPE = FRAME_ID_AMR_AUDIO_PACKET,
    
    FRAME_ID_VIDEO_PACKET,
    FRAME_ID_AUDIO_PACKET,

    FRAME_ID_YUV420_VIDEO_FRAME,
    FRAME_ID_YUV422_VIDEO_FRAME,
    FRAME_ID_RGB16_VIDEO_FRAME,
    FRAME_ID_RGB24_VIDEO_FRAME,
    FRAME_ID_RGB32_VIDEO_FRAME,

    FRAME_ID_PCM_AUDIO_DATA,

    FRAME_ID_RENDERED_AUDIO,
    FRAME_ID_RENDERED_VIDEO,

    FRAME_ID_URL_SOURCE,
    FRAME_ID_AUDIO_SOURCE,
    FRAME_ID_VIDEO_SOURCE,

    FRAME_ID_MULTIPLE_FORMAT,
    FRAME_ID_ANY_ONE_OF_FORMAT,

    FRAME_ID_MULTIPLE_PACKET,
    FRAME_ID_ANY_ONE_OF_PACKET,

    FRAME_ID_UNKNOWN
};
*/

typedef struct FRAME_GENERIC {
/*    
    int generalId;
    int specificId;
    int streamId;
*/    
    int bytes;
    char* bits;
    int pts;
};

/*
enum videoCodecId {
    FRAME_ID_MPEG1_VIDEO_PACKET,
    FRAME_ID_MPEG2_VIDEO_PACKET,
    FRAME_ID_MPEG4_VIDEO_PACKET,
    FRAME_ID_QT_VIDEO_PACKET
};

typedef struct FRAME_VIDEO_PACKET {
    int codecId;
    int bytes;
    char* bits;
};

enum videoFrameFormat {
    FRAME_ID_YUV420_VIDEO_FRAME,
    FRAME_ID_YUV422_VIDEO_FRAME,
    FRAME_ID_RGB16_VIDEO_FRAME,
    FRAME_ID_RGB24_VIDEO_FRAME,
    FRAME_ID_RGB32_VIDEO_FRAME    
};

typedef struct FRAME_VIDEO_FRAME {
    int format;
    int width;
    int height;
    int bytes;
    char* bits;
};

struct UpPCMPacket {
    int freq;
    int bitsPerSample;
    int size;
    char data[1];
};

struct DownPCMPacket {
    
};

*/

#define WIDTH 160
#define HEIGHT 120

// Utils
class Thread {
public:
    Thread();
    int start( void* arg );

protected:
    int run( void* arg );
    static void* entryPoint( void* );
    virtual void setup() { };
    virtual void execute( void* ) = 0;
    void* arg() const { return arg_; }
    void setArg( void* a ) { arg_ = a; }
   
private:
    pthread_t tid_;
    void* arg_;
};

Thread::Thread() {}

int Thread::start( void* arg )
{
    setArg(arg);
    return pthread_create( &tid_, 0, Thread::entryPoint, this );
}

int Thread::run( void* arg )
{
    printf(" (pid: %i)", getpid() );
    setup();
    execute( arg );
}

void* Thread::entryPoint( void* pthis )
{
    Thread* pt = (Thread*)pthis;
    pt->run( pt->arg() );
}



// Format
class Format {
public:
    Format() : s( 0 ) { }
    Format(const Format &other) : s( other.s ) { }
    Format(const char *str) : s( str ) { }
    bool operator==(const Format& other) {
        return !strcmp(other.s, s);
    }
    operator const char *() {
        return s;
    }
    bool operator==(const char *other) {
        return !strcmp(s, other);
    }
    bool operator<(const Format& other) const {
        return strcmp(other.s, s) < 0;
    }
private:
    const char *s;
};



// Frame
class Frame {
public:
    Frame() { }
    
    Frame( const char* id, void* data )
        : counter( 0 ), type( id ), bits( data )
    {
        pthread_mutex_init( &mutex, NULL );
    }
    
    void ref() const
    {
        pthread_mutex_lock( &mutex );
        ++counter;
        pthread_mutex_unlock( &mutex );
    }
    
    void deref() const
    {
        pthread_mutex_lock( &mutex );
        --counter;
        pthread_mutex_unlock( &mutex );
    }
    
    int refcount() const 
    {
        int ret;
        pthread_mutex_lock( &mutex );
        ret = counter;
        pthread_mutex_unlock( &mutex );
        return ret;
    }
    
    Format id() const { return type; }
    void* data() const { return bits; }
        
private:
    mutable pthread_mutex_t mutex;
    mutable int counter;
    Format type;
    void *bits;
};


struct PCMData {
    int size;
    char data[65536];
};


struct YUVFrame {
    int width;
    int height;
    enum PixelFormat fmt;
    AVFrame *pic;
/*
    uchar *y;
    uchar *u;
    uchar *v;
    int scanlineWidth[3];
*/
};

/*
struct StreamPacket {
    void *private; // AVPacket *pkt;
    int streamId;
    int size;
    char *data;
};
*/

/*
struct StreamPacket {
    int streamId;
    Frame frame;
};
*/

class Module;

enum Commands { Init, Pull, Deref, Process, Simulate, ConnectToModule, ConnectedFrom };

typedef Module *Address;

struct Command {
    Address address;
    Commands command;
    const void *arg;
};

// CommandQueue
class CommandQueue {
public:
    CommandQueue( int size );
    
    void add( const Command & );
    const Command &remove();
    
private:
    int max;
    const Command **commands;
    int in, out;
    
    pthread_mutex_t mutex;
    sem_t free;
    sem_t used;
};

CommandQueue::CommandQueue( int size )
    : max( size ), in( 0 ), out( 0 )
{
    commands = new const Command*[max];
    pthread_mutex_init( &mutex, NULL );
    sem_init( &free, 0, max );
    sem_init( &used, 0, 0 );
}

void CommandQueue::add( const Command &command )
{
    while( sem_wait( &free ) != 0 );
    pthread_mutex_lock( &mutex );
    
    commands[in] = &command;
    in = ( in + 1 ) % max;
    
    pthread_mutex_unlock( &mutex );
    sem_post( &used );
}

const Command &CommandQueue::remove()
{
    while( sem_wait( &used ) != 0 );
    pthread_mutex_lock( &mutex );
    
    const Command *command = commands[out];
    out = ( out + 1 ) % max;
    
    pthread_mutex_unlock( &mutex );
    sem_post( &free );
    
    return *command;
}


class PipelineManager : public Thread {
public:
    PipelineManager();
    void addSource( Format frameType );
    void addDestination( Format frameType );
    void clearTargets();
    void connectTogether(Module *m1, Module *m2, const Frame &f);
    void makeConnections(Module *start);
    void start( Frame *frame ) { Thread::start( (void *)frame ); }
    void execute( void *p );
    void unconnectedRoute( Module *m, const Frame &f );
private:
    list<Module*> sourceModules;
    list<Module*> destinationModules;
    list<Format> source;
    list<Format> destination;
};


PipelineManager *pipelineMgr = 0;



class ModuleFactory {
public:
    ModuleFactory() { }

    virtual const char *name() = 0;
    
    virtual list<Address> threadAffinity() = 0;
    virtual bool isBlocking() = 0;
    virtual Format inputFormat() = 0;
    virtual Format outputFormat() = 0;
    virtual bool supportsInputFormat( Format ) = 0;
    virtual bool supportsOutputFormat( Format ) = 0;
    
    virtual Module *createInstance() = 0;
};



// Modules
class Module {
public:
    Module() { }
    
    virtual const char *name() = 0;
    virtual Format inputFormat() = 0;
    virtual Format outputFormat() = 0;
//    virtual bool constFrameProcessing() = 0;

//    virtual bool supportsInputType( Format ) = 0;
    virtual bool supportsOutputType( Format ) = 0;
    
//    virtual list<int> inputFormats() { list<int> t; t.push_back(FRAME_ID_UNKNOWN); return t; }
//    virtual list<int> outputFormats() { list<int> t; t.push_back(FRAME_ID_UNKNOWN); return t; }

    virtual bool isBlocking() = 0;//{ return false; }
    virtual list<Address> threadAffinity() = 0;

//    virtual void command( Command command, const void *arg, bool priorityFlag ) = 0;
    virtual void command( Commands command, const void *arg ) = 0;
    
    virtual void connectTo( Module *next, const Frame &f ) = 0;
    virtual void connectedFrom( Module *next, const Frame &f ) = 0;
};


class DispatchInterface {
public:
    virtual void dispatch( Command *command ) = 0;
};


/*
class ModulesThread : public Thread, public DispatchInterface {
public:
    void execute( void* )
    {
        for (;;) {
            CommandStruct *command = buffer.remove();
            command->module->command( command->command, command->arg );
        }
    }
    
    void dispatch( CommandStruct *command )
    {
        buffer.add( command );
    }

private:
    CommandQueue buffer;
};
*/

class ProcessBoundryThing : public DispatchInterface {
public:
    void dispatch( Command *command )
    {
    }
};


class ModuleMapper {
public:
    void addModule( Module *module )
    {
        modules.push_back(module);
    }

    void addMapping( Address address, DispatchInterface *dispatcher )
    {
        dispatchAddressMap[address] = dispatcher;
    }

    Module *findModuleWithInputFormat( Format format )
    {
        for ( list<Module *>::iterator it = modules.begin(); it != modules.end(); ++it ) {
            if ( (*it)->inputFormat() == format ) {
                return (*it);
            }
        }
        return 0;
    }

    Module *findModuleWithOutputFormat( Format format )
    {
        for ( list<Module *>::iterator it = modules.begin(); it != modules.end(); ++it ) {
            if ( (*it)->outputFormat() == format ) {
                return (*it);
            }
        }
    }
    
    DispatchInterface *lookup( Address address )
    {
        return dispatchAddressMap[address];
    }

    void dispatchCommand( Address address, Commands command, const void *arg )
    {
        Command *cmd = new Command;
        cmd->command = command;
        cmd->arg = arg;
        cmd->address = address;
//        lookup( cmd->address )->dispatch( cmd ); 
        address->command( cmd->command, cmd->arg ); 
    }

private:
    list<Module*> modules;    
    map<Address,DispatchInterface*> dispatchAddressMap;
    multimap<Format,Module*> inputFormatModuleMap;
    multimap<Format,Module*> outputFormatModuleMap;
};
    

ModuleMapper *moduleMapper()
{
    static ModuleMapper *staticModuleMapper = 0;
    return staticModuleMapper ? staticModuleMapper : staticModuleMapper = new ModuleMapper;
}

static void staticDispatch( Address address, Commands command, const void *arg )
{
    moduleMapper()->dispatchCommand( address, command, arg );
}

    
class SimpleModule : public Module {
public:
    SimpleModule() : next( 0 ) { }
    
    bool isBlocking() { return false; }
    list<Address> threadAffinity() { }
    
    bool supportsOutputType(Format type)
    {
        return outputFormat() == type;
    }
    
    virtual void init() = 0;
    
    void command( Commands command, const void *arg )
    {
        switch (command) {
            case Process:
                process( *((Frame *)arg) );
                break;
            case Simulate:
                simulate( *((Frame *)arg) );
                break;
            case Deref:
                ((Frame *)arg)->deref();
                break;
            case Init:
                init();
                break;
        }
    }

    void dispatch( Address address, Commands command, const void *arg )
    {
        if ( address )
            staticDispatch( address, command, arg );
        else if ( pipelineMgr && ( command == Process || command == Simulate ) )
            pipelineMgr->unconnectedRoute( this, *(const Frame *)arg );            
    }

    virtual void derefFrame( Frame *frame )
    {
        dispatch( prev, Deref, frame );
    }
    
    virtual void process( const Frame &frame )
    {
        dispatch( next, Process, &frame );
    }
    
    virtual void simulate( const Frame &frame )
    {
        process( frame );
    }
        
    void connectTo( Address n, const Frame &f )
    { 
        next = n;
    }   
    
    void connectedFrom( Address n, const Frame &f )
    { 
        prev = n;
    }   
    
    Frame *getAvailableFrame()
    {
        Frame *frame;
        list<Frame*>::iterator it;
        for ( it = used.begin(); it != used.end(); ++it ) {
            frame = *it;
            if ( frame->refcount() == 0 ) {
                reuseFrame( frame );
                frame->ref();
                return frame;
            }
        }        
        frame = createNewFrame();
        frame->ref();
        used.push_back( frame );
        return frame;
    }
        
    virtual Frame* createNewFrame()
    { 
        return new Frame;
    }
    
    virtual void reuseFrame( Frame *frame )
    { }

private:
    list<Frame*> used;
    Module *next;
    Module *prev;
};


class RoutingModule : public SimpleModule {
public:
    RoutingModule() { }
    
//    bool supportsOutputType(Format type) { return outputFormat() == type; }
   
    void process( const Frame &frame )
    {
        dispatch( routes[Format(frame.id())], Process, &frame );
    }
    
    void connectTo( Module *next, const Frame &f )
    { 
        setRoute( next->inputFormat(), next );
    }

private:
    void setRoute( Format t, Module* m )
    {
        routes[Format(t)] = m;
    }
    
    map<Format, Module*> routes;
};


class OSSRenderer : public SimpleModule {
public:
    OSSRenderer() { }
    
    void init();
    void process( const Frame &f );

    const char *name() { return "OSS Renderer"; }
    Format inputFormat() { return "FRAME_ID_PCM_AUDIO_DATA"; }
    Format outputFormat() { return "FRAME_ID_RENDERED_AUDIO"; }
    bool isBlocking() { return true; }
    
private:
    int fd;
};


void OSSRenderer::init()
{
    // Initialize OSS
    fd = open( "/dev/dsp", O_WRONLY );
    
    int format = AFMT_S16_LE;
    ioctl( fd, SNDCTL_DSP_SETFMT, &format );
    
    int channels = 2;
    ioctl( fd, SNDCTL_DSP_CHANNELS, &channels );
    
    int speed = 44100;
    ioctl( fd, SNDCTL_DSP_SPEED, &speed );
}

void OSSRenderer::process( const Frame &frame )
{
    // Render PCM to device
    PCMData *pcm = (PCMData*)frame.data();
    if ( write( fd, pcm->data, pcm->size ) == -1 )
        perror( "OSSRenderer::process( Frame )" );
    frame.deref();
}


enum ColorFormat {
    RGB565,
    BGR565,
    RGBA8888,
    BGRA8888
};

class VideoScaleContext {
public:
    AVPicture outputPic1;
    AVPicture outputPic2;
    AVPicture outputPic3;

    VideoScaleContext() {
        //img_convert_init();
	videoScaleContext2 = 0;
	outputPic1.data[0] = 0;
	outputPic2.data[0] = 0;
	outputPic3.data[0] = 0;
    }

    virtual ~VideoScaleContext() {
	free();
    }

    void free() {
	if ( videoScaleContext2 )
	    img_resample_close(videoScaleContext2);
	videoScaleContext2 = 0;
	if ( outputPic1.data[0] )
	    avpicture_free(&outputPic1);
	outputPic1.data[0] = 0;
	if ( outputPic2.data[0] )
	    avpicture_free(&outputPic2);
	outputPic2.data[0] = 0;
	if ( outputPic3.data[0] )
	    avpicture_free(&outputPic3);
	outputPic3.data[0] = 0;
    }

    void init() {
	scaleContextDepth = -1;
	scaleContextInputWidth = -1;
	scaleContextInputHeight = -1;
	scaleContextPicture1Width = -1;
	scaleContextPicture2Width = -1;
	scaleContextOutputWidth = -1;
	scaleContextOutputHeight = -1;
	scaleContextLineStride = -1;
    }

    bool configure(int w, int h, int outW, int outH, AVFrame *picture, int lineStride, int fmt, ColorFormat outFmt ) {
	int colorMode = -1;
	switch ( outFmt ) {
	    case RGB565:   colorMode = PIX_FMT_RGB565; break;
	    case BGR565:   colorMode = PIX_FMT_RGB565; break;
	    case RGBA8888: colorMode = PIX_FMT_RGBA32; break;
	    case BGRA8888: colorMode = PIX_FMT_RGBA32; break;
	};
	scaleContextFormat = fmt;
	scaleContextDepth = colorMode;
	if ( scaleContextInputWidth != w || scaleContextInputHeight != h
				|| scaleContextOutputWidth != outW || scaleContextOutputHeight != outH ) {
	    scaleContextInputWidth = w;
	    scaleContextInputHeight = h;
	    scaleContextOutputWidth = outW;
	    scaleContextOutputHeight = outH;
	    scaleContextLineStride = lineStride;
	    free();
	    if ( !(videoScaleContext2 = img_resample_init(outW, outH, w, h)) )
		return false;
	    if ( avpicture_alloc(&outputPic1, PIX_FMT_YUV420P, scaleContextOutputWidth, scaleContextOutputHeight) < 0 )
		return false;
	    if ( avpicture_alloc(&outputPic2, scaleContextDepth, scaleContextOutputWidth, scaleContextOutputHeight) < 0 )
		return false;
	    if ( avpicture_alloc(&outputPic3, PIX_FMT_YUV420P, scaleContextOutputWidth, scaleContextOutputHeight) < 0 )
		return false;
	}
	return true;
    }

    void convert(uint8_t *output, AVFrame *picture) {
	if ( !videoScaleContext2 || !picture || !outputPic1.data[0] || !outputPic2.data[0] )
	    return;

        // XXXXXXXXX This sucks ATM, converts to YUV420P, scales, then converts to output format
        // first conversion needed because img_resample assumes YUV420P, doesn't seem to
        // behave with packed image formats

        img_convert(&outputPic1, PIX_FMT_YUV420P, (AVPicture*)picture, scaleContextFormat, scaleContextInputWidth, scaleContextInputHeight);
        
        img_resample(videoScaleContext2, &outputPic3, &outputPic1);
	
        img_convert(&outputPic2, scaleContextDepth, &outputPic3, PIX_FMT_YUV420P, scaleContextOutputWidth, scaleContextOutputHeight);
        
        //img_resample(videoScaleContext2, &outputPic1, (AVPicture*)picture);
	//img_convert(&outputPic2, scaleContextDepth, &outputPic1, scaleContextFormat, scaleContextOutputWidth, scaleContextOutputHeight);

	int offset = 0;
	for ( int i = 0; i < scaleContextOutputHeight; i++ ) {
	    memcpy( output, outputPic2.data[0] + offset, outputPic2.linesize[0] );
	    output += scaleContextLineStride;
	    offset += outputPic2.linesize[0]; 
	}
    }

private:
    ImgReSampleContext *videoScaleContext2;
    int scaleContextDepth;
    int scaleContextInputWidth;
    int scaleContextInputHeight;
    int scaleContextPicture1Width;
    int scaleContextPicture2Width;
    int scaleContextOutputWidth;
    int scaleContextOutputHeight;
    int scaleContextLineStride;
    int scaleContextFormat;
};


struct FFMpegStreamPacket {
    AVPacket *packet;
};


class MpegEncodeModule : public SimpleModule {
public:
    MpegEncodeModule() : videoCodecContext( 0 )
    {           
    }
    
    void init()
    {        
printf("S %i\n", __LINE__);
        av_register_all();
        
        videoCodecContext = avcodec_alloc_context();

        AVCodec *codec = avcodec_find_encoder(CODEC_ID_MPEG1VIDEO);
        assert( codec );

/*        
        if ( avcodec_open( videoCodecContext,  &mpeg1video_encoder ) < 0 ) {
            printf("error opening context\n");
            videoCodecContext = 0;
        }
*/

/*
        videoCodecContext->bit_rate = 400000;
        videoCodecContext->gop_size = 10;
        videoCodecContext->max_b_frames = 1;
*/
        videoCodecContext->width = WIDTH;
        videoCodecContext->height = HEIGHT;
        videoCodecContext->frame_rate = 25;
        videoCodecContext->frame_rate_base= 1;
        videoCodecContext->pix_fmt=PIX_FMT_YUV420P;
        videoCodecContext->codec_type = CODEC_TYPE_VIDEO;
        videoCodecContext->codec_id = CODEC_ID_MPEG1VIDEO;
        
        assert( avcodec_open( videoCodecContext, codec ) >= 0 );
        
printf("S %i\n", __LINE__);
    }

    void process( const Frame &frame ) 
    {
printf("T %i\n", __LINE__);
        YUVFrame *yuvFrame = (YUVFrame*)frame.data();
        AVFrame *picture = yuvFrame->pic;

        if ( !videoCodecContext ) {
            printf("can't process video data without a context\n");
            return;
        }
        
        Frame *f = getAvailableFrame();
        
        FFMpegStreamPacket *ffmpeg = (FFMpegStreamPacket*)f->data();
        AVPacket *packet = ffmpeg->packet;
        
printf("T %i\n", __LINE__);

// 160*120*4 = 76800

        printf(" %i x %i   %i %i %i \n", yuvFrame->width, yuvFrame->height, picture->linesize[0], picture->linesize[1], picture->linesize[2] ); 
        
        AVFrame tmpPic;
        if ( avpicture_alloc((AVPicture*)&tmpPic, PIX_FMT_YUV420P, yuvFrame->width, yuvFrame->height) < 0 )
            printf("blah1\n");
        img_convert((AVPicture*)&tmpPic, PIX_FMT_YUV420P, (AVPicture*)picture, yuvFrame->fmt,
                                     yuvFrame->width, yuvFrame->height );
        
        printf(" %i x %i   %i %i %i \n", yuvFrame->width, yuvFrame->height, tmpPic.linesize[0], tmpPic.linesize[1], tmpPic.linesize[2] ); 
        
        static int64_t pts = 0;
        tmpPic.pts = AV_NOPTS_VALUE;
        pts += 5000;
         
//        int ret = avcodec_encode_video( videoCodecContext, (uchar*)av_malloc(1000000), 1024*256, &tmpPic );
        packet->size = avcodec_encode_video( videoCodecContext, packet->data, packet->size, &tmpPic );
        
        if ( videoCodecContext->coded_frame ) {
            packet->pts = videoCodecContext->coded_frame->pts;
            if ( videoCodecContext->coded_frame->key_frame )
                packet->flags |= PKT_FLAG_KEY;
        }
        
printf("T %i\n", __LINE__);
        
        cerr << "encoded: " << packet->size << " bytes" << endl;
printf("T %i\n", __LINE__);

        frame.deref();
        
        SimpleModule::process( *f );
    }
    
    Frame* createNewFrame()
    { 
        FFMpegStreamPacket *packet = new FFMpegStreamPacket;
        packet->packet = new AVPacket;
        packet->packet->data = new unsigned char[65536];
        packet->packet->size = 65536;
        packet->packet->pts = AV_NOPTS_VALUE;
        packet->packet->flags = 0;
        return new Frame( "FRAME_ID_MPEG1_VIDEO_PACKET", packet );
    }
    
    void reuseFrame( Frame *frame )
    {
        FFMpegStreamPacket *packet = (FFMpegStreamPacket*)frame->data();
        packet->packet->size = 65536;
        packet->packet->pts = AV_NOPTS_VALUE;
        packet->packet->flags = 0;
        //av_free_packet( packet->packet );
        //delete packet->packet;
    }
    
    const char *name() { return "Mpeg Video Encoder"; }
    Format inputFormat() { return "FRAME_ID_YUV_VIDEO_FRAME"; }
    Format outputFormat() { return "FRAME_ID_MPEG1_VIDEO_PACKET"; }
    bool isBlocking() { return true; }

private:
    AVCodecContext *videoCodecContext;
};


class FFMpegMuxModule : public SimpleModule {
public:
    FFMpegMuxModule() : outputFileContext( 0 )
    {           
    }
    
    void init()
    {
printf("A %i\n", __LINE__);
        av_register_all();
        
        outputFileContext = av_alloc_format_context();
        outputFileContext->oformat = guess_format("avi", 0, 0);
        AVStream *videoStream = av_new_stream( outputFileContext, outputFileContext->nb_streams+1 );
        //AVStream *audioStream = av_new_stream( AVFormatContext, outputFileContext->nb_streams+1 );
printf("A %i\n", __LINE__);

        assert( videoStream );
        assert( outputFileContext->oformat );

        AVCodecContext *video_enc = &videoStream->codec;
        
        AVCodec *codec = avcodec_find_encoder(CODEC_ID_MPEG1VIDEO);
        assert( codec );
        assert( avcodec_open( video_enc, codec ) >= 0 );
        
        video_enc->codec_type = CODEC_TYPE_VIDEO;
        video_enc->codec_id = CODEC_ID_MPEG1VIDEO;//CODEC_ID_MPEG4; // CODEC_ID_H263, CODEC_ID_H263P
//        video_enc->bit_rate = video_bit_rate;
//        video_enc->bit_rate_tolerance = video_bit_rate_tolerance;

        video_enc->frame_rate = 10;//25;//frame_rate; 
        video_enc->frame_rate_base = 1;//frame_rate_base; 
        video_enc->width = WIDTH;//frame_width + frame_padright + frame_padleft;
        video_enc->height = HEIGHT;//frame_height + frame_padtop + frame_padbottom;

        video_enc->pix_fmt = PIX_FMT_YUV420P;
        
        if( av_set_parameters( outputFileContext, NULL ) < 0 ) {
            cerr << "Invalid output format parameters\n";
         exit(1);
        }
    
printf("A %i\n", __LINE__);
//        strcpy( outputFileContext->comment, "Created With Project Carmack" );
//        strcpy( outputFileContext->filename, "blah.avi" );
        
//        if ( url_fopen( &outputFileContext->pb, outputFileContext->filename, URL_WRONLY ) < 0 ) {
        if ( url_fopen( &outputFileContext->pb, "blah2.avi", URL_WRONLY ) < 0 ) {
            printf( "Couldn't open output file: %s\n", outputFileContext->filename );
            exit( 1 );
        }
printf("A %i\n", __LINE__);

        if ( av_write_header( outputFileContext ) < 0 ) {
            printf( "Could not write header for output file %s\n", outputFileContext->filename );
            exit( 1 );
        }

printf("A %i\n", __LINE__);
    }

    void process( const Frame &frame ) 
    {
printf("B %i\n", __LINE__);
        AVPacket *pkt = ((FFMpegStreamPacket*)frame.data())->packet;
        //av_dup_packet( pkt ); 

        if ( !outputFileContext ) {
            printf("can't process video data without a context\n");
            return;
        }
        
/*
            pkt.stream_index= ost->index;
            pkt.data= audio_out;
            pkt.size= ret;
            if(enc->coded_frame)
                pkt.pts= enc->coded_frame->pts;
            pkt.flags |= PKT_FLAG_KEY;
*/          
printf("B %i\n", __LINE__);
        if ( pkt->data ) {
printf("B %i\n", __LINE__);
            av_interleaved_write_frame(outputFileContext, pkt);
        } else {
            printf( "End of data\n" );
            av_write_trailer(outputFileContext);
            exit( 0 );
        }
printf("B %i\n", __LINE__);
        
        frame.deref();
    }
    
    const char *name() { return "AVI Muxer"; }
    Format inputFormat() { return "FRAME_ID_MPEG1_VIDEO_PACKET"; }
    Format outputFormat() { return "FRAME_ID_URL_SINK"; }
    bool isBlocking() { return true; }

private:
    AVFormatContext *outputFileContext;
};

class Splitter : public SimpleModule {
public:
    Splitter()
    {           
    }
  
    void init()
    {    
    }
   
    void process( const Frame &frame )
    {
        list<Module*>::iterator it = routes.begin();
        while( it != routes.end() ) {
            if ( it != routes.begin() )
                frame.ref();
            dispatch( (*it), Process, &frame );
            ++it;
        }
    }
    
    void connectTo( Module *next, const Frame &f )
    { 
        routes.push_back( next );
    }

    const char *name() { return "Splitter"; }
    Format inputFormat() { return "FRAME_ID_YUV_VIDEO_FRAME"; }
    Format outputFormat() { return "FRAME_ID_YUV_VIDEO_FRAME"; }
    bool isBlocking() { return true; }

private:
    list<Module*> routes;
};

class MpegDecodeModule : public SimpleModule {
public:
    MpegDecodeModule() : videoCodecContext( 0 )
    {           
        currentFrame = 0;
    }
    
    void init()
    {        
        av_register_all();
        
        if ( avcodec_open( videoCodecContext = avcodec_alloc_context(),  &mpeg1video_decoder ) < 0 ) {
            printf("error opening context\n");
            videoCodecContext = 0;
        }
    }

    void process( const Frame &frame ) 
    {
        AVPacket *pkt = ((FFMpegStreamPacket*)frame.data())->packet;

        if ( !videoCodecContext ) {
            printf("can't process video data without a context\n");
            return;
        }
        
        if ( !currentFrame )
            currentFrame = getAvailableFrame();
        
        YUVFrame *yuvFrame = (YUVFrame *)currentFrame->data();
        AVFrame *picture = yuvFrame->pic;
        
        assert( videoCodecContext->pix_fmt == PIX_FMT_YUV420P );
        
//printf("processing video data (%i x %i)\n", videoCodecContext->width, videoCodecContext->height);
        AVPacket *mpeg = pkt;
	unsigned char *ptr = (unsigned char*)mpeg->data;
        int count = 0, ret = 0, gotPicture = 0;
        // videoCodecContext->hurry_up = 2;
        int len = mpeg->size;
//        for ( ; len && ret >= 0; len -= ret, ptr += ret )
            ret = avcodec_decode_video( videoCodecContext, picture, &gotPicture, ptr, len );
        frame.deref();

        if ( gotPicture ) {
            yuvFrame->width = videoCodecContext->width;
            yuvFrame->height = videoCodecContext->height;
            yuvFrame->fmt = videoCodecContext->pix_fmt;
            SimpleModule::process( *currentFrame );
            currentFrame = 0;            
        }
    }
    
    Frame* createNewFrame()
    {
        YUVFrame *yuvFrame = new YUVFrame;
        yuvFrame->pic = avcodec_alloc_frame();
        return new Frame( "FRAME_ID_YUV_VIDEO_FRAME", yuvFrame );
    }
    
    void reuseFrame( Frame *frame )
    {
        YUVFrame *yuvFrame = (YUVFrame *)frame->data();
        av_free( yuvFrame->pic );
        yuvFrame->pic = avcodec_alloc_frame();
    }
    
    const char *name() { return "Mpeg1 Video Decoder"; }
    Format inputFormat() { return "FRAME_ID_MPEG1_VIDEO_PACKET"; }
    Format outputFormat() { return "FRAME_ID_YUV_VIDEO_FRAME"; }
    bool isBlocking() { return true; }

private:
    Frame *currentFrame;
    AVCodecContext *videoCodecContext;
};


class MP3DecodeModule : public SimpleModule {
public:
    MP3DecodeModule() : audioCodecContext( 0 )
    {
    }
    
    void init()
    {
        av_register_all();
        
        if ( avcodec_open( audioCodecContext = avcodec_alloc_context(), &mp3_decoder ) < 0 ) {
            printf("error opening context\n");
            audioCodecContext = 0;
        }
    }
    
    void process( const Frame &frame ) 
    {
        AVPacket *pkt = ((FFMpegStreamPacket*)frame.data())->packet;

        Frame *f = getAvailableFrame();
        PCMData *pcm = (PCMData *)f->data();
        int count = 0, ret = 0, bytesRead;
        AVPacket *mp3 = pkt;
	unsigned char *ptr = (unsigned char*)mp3->data;
        for ( int len = mp3->size; len && ret >= 0; len -= ret, ptr += ret ) {
            ret = avcodec_decode_audio(audioCodecContext, (short*)(pcm->data + count), &bytesRead, ptr, len);
            if ( bytesRead > 0 )
                count += bytesRead;
	}
        frame.deref();

        pcm->size = count;
        SimpleModule::process( *f );
    }
    
    Frame* createNewFrame()
    {
        return new Frame( "FRAME_ID_PCM_AUDIO_DATA", new PCMData );
    }
    
    const char *name() { return "MP3 Decoder"; }
    Format inputFormat() { return "FRAME_ID_MPEG_AUDIO_PACKET"; }
    Format outputFormat() { return "FRAME_ID_PCM_AUDIO_DATA"; }
    bool isBlocking() { return true; }

private:
    AVCodecContext *audioCodecContext;
};


class MP3SourceModule : public SimpleModule {
public:
    MP3SourceModule() : avFormatContext( 0 )
    {
    }

    void init()
    {
	av_register_all();
    }
    
    void process( const Frame &frame ) {
        printf("file: %s\n", (char*)frame.data());
        if ( av_open_input_file(&avFormatContext, (char*)frame.data(), NULL, 0, 0) < 0 || !avFormatContext )
            printf("error opening file"); 
    
        while( avFormatContext ) {
            if ( av_read_packet(avFormatContext, &pkt) < 0 )
                printf("error reading packet\n");
            else {
                SimpleModule::process( Frame( "FRAME_ID_MPEG_AUDIO_PACKET", &pkt ) );
            }
        }
    }

    const char *name() { return "MP3 Reader"; }
    Format inputFormat() { return "FRAME_ID_URL_SOURCE"; }
    Format outputFormat() { return "FRAME_ID_MPEG_AUDIO_PACKET"; }
    bool isBlocking() { return true; }

private:
    AVPacket pkt;
    AVFormatContext *avFormatContext;
};


void ProcessMessages();


class FFMpegSourceModule : public SimpleModule {
public:
    FFMpegSourceModule() : avFormatContext( 0 )
    {
    }

    bool supportsOutputType( Format type )
    {
        return type == "FRAME_ID_MPEG1_VIDEO_PACKET" || type == "FRAME_ID_MPEG_AUDIO_PACKET" || type == "FRAME_ID_MPEG2_VIDEO_PACKET" || type == "FRAME_ID_MPEG4_VIDEO_PACKET";
    }
    
    const char* name() { return "FFMpeg Demuxer Source"; }
    Format inputFormat() { return "FRAME_ID_URL_SOURCE"; }
    Format outputFormat() { return "FRAME_ID_MULTIPLE_PACKET"; }
    bool isBlocking() { return true; }
    list<Module*> threadAffinity() { }

    void init()
    {
	av_register_all();
    }
    
    void process( const Frame &frame )
    {
        printf("file: %s\n", (char*)frame.data());
        
        // Open file
        if ( av_open_input_file(&avFormatContext, (char*)frame.data(), 0, 0, 0) < 0 || !avFormatContext ) {
            printf("error opening file");
            return;
        }
        
        frame.deref();
        
        // Gather stream information
        if ( av_find_stream_info(avFormatContext) < 0 ) {
            printf("error getting stream info\n");
            return;
        }
   
        while( avFormatContext ) {
            AVPacket *pkt = new AVPacket;
//            if ( av_read_packet(avFormatContext, pkt) < 0 ) {
            if ( av_read_frame(avFormatContext, pkt) < 0 ) {
                printf("error reading packet\n");
                av_free_packet( pkt );
                delete pkt;
                exit( 0 ); // EOF ?
            } else {
                AVCodecContext *context = &avFormatContext->streams[pkt->stream_index]->codec;
                Frame *f = getAvailableFrame( context->codec_type );                
                if ( !f )
                    continue;
                FFMpegStreamPacket *packet = (FFMpegStreamPacket*)f->data();
                packet->packet = pkt;
                //av_dup_packet( pkt );

		ProcessMessages();
                
                dispatch( routes[pkt->stream_index], Process, f );
            }
        }
        exit( 0 );
    }

    Frame *getAvailableFrame( int type )
    {       
        Frame *frame;
        list<Frame*>::iterator it;
        for ( it = used[type].begin(); it != used[type].end(); ++it ) {
            frame = *it;
            if ( frame->refcount() == 0 ) {
                reuseFrame( frame );
                frame->ref();
                return frame;
            }
        }
        
        // Create new frame
        frame = createNewFrame( type );
        if ( frame ) {
            frame->ref();
            used[type].push_back( frame );
        }
        return frame;
    }
    
    Frame* createNewFrame( int type )
    { 
        FFMpegStreamPacket *packet = new FFMpegStreamPacket;
        switch( type ) {
            case CODEC_TYPE_AUDIO:
                return new Frame( "FRAME_ID_MPEG_AUDIO_PACKET", packet );
            case CODEC_TYPE_VIDEO:
                return new Frame( "FRAME_ID_MPEG1_VIDEO_PACKET", packet );
        }
        return 0;
    }
    
    void reuseFrame( Frame *frame )
    {
        FFMpegStreamPacket *packet = (FFMpegStreamPacket*)frame->data();
        av_free_packet( packet->packet );
        delete packet->packet;
    }

    void connectTo( Module *next, const Frame &f )
    {
        routes[((FFMpegStreamPacket*)f.data())->packet->stream_index] = next;
    }

private:    
    AVFormatContext *avFormatContext;
    map<int,list<Frame*> > used;    
    map<int, Module*> routes;
};


/*
class VideoCameraSourceModule : public SimpleModule {
public:
    VideoCameraSourceModule()
    {
    }

    void init()
    {
        av_register_all();
    }
    
    void process( const Frame &frame ) {
        AVFormatContext *avFormatContext = 0;
        AVFormatParameters vp1, *vp = &vp1;
        AVInputFormat *fmt1;
        memset(vp, 0, sizeof(*vp));
        fmt1 = av_find_input_format("video4linux");//video_grab_format);
        vp->device = 0;//"/dev/video";//video_device;
        vp->channel = 0;//video_channel;
        vp->standard = "pal";//"ntsc";//video_standard;
        vp->width = WIDTH;
        vp->height = HEIGHT;
        vp->frame_rate = 50;
        vp->frame_rate_base = 1;
        if (av_open_input_file(&avFormatContext, "", fmt1, 0, vp) < 0) {
            printf("Could not find video grab device\n");
            exit(1);
        }
        if ((avFormatContext->ctx_flags & AVFMTCTX_NOHEADER) && av_find_stream_info(avFormatContext) < 0) {
            printf("Could not find video grab parameters\n");
            exit(1);
        }
        // Gather stream information
        if ( av_find_stream_info(avFormatContext) < 0 ) {
            printf("error getting stream info\n");
            return;
        }
        
//        AVCodecContext *videoCodecContext = avcodec_alloc_context();
        AVCodecContext *videoCodecContext = &avFormatContext->streams[0]->codec;
        AVCodec *codec = avcodec_find_decoder(avFormatContext->streams[0]->codec.codec_id);
        
        if ( !codec ) {
            printf("error finding decoder\n");
            return;
        }
        
        printf("found decoder: %s\n", codec->name);
        
        avFormatContext->streams[0]->r_frame_rate      = vp->frame_rate;
        avFormatContext->streams[0]->r_frame_rate_base = vp->frame_rate_base;
        
        videoCodecContext->width = vp->width;
        videoCodecContext->height = vp->height;

//        if ( avcodec_open( videoCodecContext, &rawvideo_decoder ) < 0 ) {
        if ( avcodec_open( videoCodecContext, codec ) < 0 ) {  // is rawvideo_decoder
            printf("error opening context\n");
            videoCodecContext = 0;
        }
        
        if ( !videoCodecContext ) {
            printf("can't process video data without a context\n");
            return;
        }
    
        AVPacket pkt;
        while( avFormatContext ) {
            if ( av_read_frame(avFormatContext, &pkt) < 0 )
                printf("error reading packet\n");
            else {            
                AVFrame *picture = avcodec_alloc_frame();
                YUVFrame *yuvFrame = new YUVFrame;
                yuvFrame->pic = picture;
                Frame *currentFrame = new Frame( "FRAME_ID_YUV_VIDEO_FRAME", yuvFrame );
                currentFrame->ref();
                
                int gotPicture = 0;
                avcodec_decode_video( videoCodecContext, picture, &gotPicture, pkt.data, pkt.size );

                if ( gotPicture ) {
                    yuvFrame->fmt = videoCodecContext->pix_fmt; // is PIX_FMT_YUV422
                    yuvFrame->width = videoCodecContext->width;
                    yuvFrame->height = videoCodecContext->height;
//                    printf("showing frame: %i %ix%i\n", yuvFrame->fmt, yuvFrame->width, yuvFrame->height );
                    SimpleModule::process( *currentFrame );
                }            
            }
        }
    }

    const char *name() { return "Video Camera Source"; }
    Format inputFormat() { return "FRAME_ID_VIDEO_CAMERA_SOURCE"; }
    Format outputFormat() { return "FRAME_ID_YUV_VIDEO_FRAME"; }
    bool isBlocking() { return true; }
};
*/

/*
class Consumer : public RoutingModule {
public:
    Consumer( CommandQueue* b, Format format )
        : RoutingModule(), buffer( b ), formatId( format )
    { }
    
    void init()
    {
    }
    
    void start()
    {
        for (;;) {
            const Command &command = buffer->remove();
            RoutingModule::command( command.command, command.arg );
        }
    }
    
    const char* name() { return "Consumer"; }
    Format inputFormat() { return formatId; }
    Format outputFormat() { return formatId; }

private:
    CommandQueue *buffer;
    Format formatId;
};

class ConsumerThread : public Thread {
public:
    ConsumerThread( Consumer *c )
        : consumer( c )
    { }
    
    void execute( void* )
    {
        consumer->start();
    }
    
private:
    Consumer *consumer;
};


class ThreadBoundryModule : public RoutingModule {
public:
    ThreadBoundryModule( int size, Format format )
        : RoutingModule(), readCommandQueue( size ), consumer( &readCommandQueue, format ),
            consumerThread( &consumer ), formatId( format )
    {
    }

    void init()
    {
    }

    void connectTo( Module *m, const Frame &f )
    {
        consumer.connectTo( m, f );
        consumerThread.start(0);
    }

    void process( const Frame &frame )
    {
        readCommandQueue.add( frame );
    }
    
    const char *name() { return "Thread Boundry Module"; }
    Format inputFormat() { return formatId; }
    Format outputFormat() { return formatId; }
    
private:
    CommandQueue readCommandQueue;
    Consumer consumer;
    ConsumerThread consumerThread;
    Format formatId;
};
*/

PipelineManager::PipelineManager()
{
}

/*
void PipelineManager::newModule( Module *m )
{
    printf("adding module: %s\n", m->name() );

    allModules.push_front( m );

    // update source modules list
    for ( list<Format>::iterator it = source.begin(); it != source.end(); ++it ) {
        if ( (*it) == m->inputFormat() ) {
            sourceModules.push_front( m );
            // Just add it once
            break;
        }
    }
    
    // update destination modules list
    for ( list<Format>::iterator it = destination.begin(); it != destination.end(); ++it ) {
        if ( (*it) == m->outputFormat() ) {
            destinationModules.push_front( m );
            // Just add it once
            break;
        }
    }
}
*/

void PipelineManager::addSource( Format frameType )
{
    // update source modules list
    Module *m = moduleMapper()->findModuleWithInputFormat( frameType );    
    if ( m ) {
        printf("adding source: %s\n", (const char *)frameType );
        source.push_front( frameType );
        sourceModules.push_front( m );
    } else {
        printf("No source for %s found!!!\n", (const char *)frameType );
    }
}

void PipelineManager::addDestination( Format frameType )
{
    Module *m = moduleMapper()->findModuleWithOutputFormat( frameType );    
    if ( m ) {
        printf("adding destination: %s\n", (const char *)frameType );
        destination.push_front( frameType );
        destinationModules.push_front( m );
    } else {
        printf("No destination for %s found!!!\n", (const char *)frameType );
    }
}

void PipelineManager::clearTargets()
{
    sourceModules.clear();
    destinationModules.clear();
    source.clear();
    destination.clear();
}
    
void PipelineManager::connectTogether( Module *m1, Module *m2, const Frame &f )
{
/*
    //printf(" [%s] -> [%s] %s", m1->outputFormat(), m2->inputFormat(), m2->name() );
    printf(" -> %s", m2->name() );
    
    staticDispatch( m2, Init, 0 );

    if ( m2->isBlocking() || m1->isBlocking() ) {
        ThreadBoundryModule *threadModule = new ThreadBoundryModule( 32, m2->inputFormat() );
        threadModule->init();
        m1->connectTo( threadModule, f );
        threadModule->connectTo( m2, f );
    } else {
        m1->connectTo( m2, f );
    }
*/
}

/*
    Connects together module with a module that can process the frame
    and then gets the module to process this first frame
*/
void PipelineManager::unconnectedRoute( Module *m, const Frame &f )
{
    Module *m2 = moduleMapper()->findModuleWithInputFormat( f.id() );
    if ( m2 ) {    
        //connectTogether( m, m2, f );
        printf("Connecting together: %s -> %s\n", m->name(), m2->name() );
        staticDispatch( m2, Init, 0 );
        m->connectTo( m2, f );
        m2->connectedFrom( m, f );
        staticDispatch( m2, Process, &f );
    } else {
        printf("Didn't find route for %s\n", m->name());
    }
}

void PipelineManager::makeConnections( Module *start )
{
/*
    printf("making connections:\n");

    Frame frame( "UNKNOWN", 0 );
    Module *currentModule = start;
    Format dstFmt = destination.front();
    
    dispatch( currentModule, Init, 0 );
    printf("  %s (pid: %i)", currentModule->name(), getpid() );
    
    while ( currentModule->outputFormat() != dstFmt ) {       
        Module *m = moduleMapper()->findModuleWithInputFormat( currentModule->outputFormat() );
        if ( m ) {
            connectTogether( currentModule, m, frame );
            currentModule = m;
        } else {
            break;
        }
    }    
    printf("\n");
*/
}


void PipelineManager::execute( void *d )
{
    printf("starting...\n");
    for ( list<Module *>::iterator it = sourceModules.begin(); it != sourceModules.end(); ++it ) {
        //makeConnections( (*it) );
        staticDispatch( (*it), Init, 0 );
        staticDispatch( (*it), Process, d );
    }
}









#include <windows.h>
#include <ddraw.h>

enum display_method { USE_WINDOWS_API, USE_DIRECT_DRAW };

// Generic Global Variables
HWND                 MainWnd_hWnd;
HINSTANCE	     g_hInstance;
HDC                  hdc;
HPALETTE             oldhpal;
RECT                 r;

// DirectDraw specific Variables
LPDIRECTDRAW         lpDD = NULL;
LPDIRECTDRAWSURFACE  lpDDSPrimary = NULL;  // DirectDraw primary surface
LPDIRECTDRAWSURFACE  lpDDSOne = NULL;      // Offscreen surface #1
DDSURFACEDESC        ddsd;

// Standard Windows API specific Variables
HDC                  hdcMemory;
HBITMAP              hbmpMyBitmap, hbmpOld;

// User decided variables
int                  _method__;   // API or DirectDraw
int                  _do_full_;   // Full screen
int                  _do_flip_;   // Page flipping
int                  _double__;   // Double window size
int                  _on_top__;   // Always on top
int                  _rate____;   // Calculate frame rate

// Interface Variables
unsigned char       *DoubleBuffer;

// Resolution Variables
int                  width;
int                  height;
int                  bytes_per_pixel;


#define fatal_error(message)   _fatal_error(message, __FILE__, __LINE__)
void _fatal_error(char *message, char *file, int line);

// Fatal error handler (use the macro version in header file)
void _fatal_error(char *message, char *file, int line)
{
	char error_message[1024];
	sprintf(error_message, "%s, in %s at line %d", message, file, line);
	puts(error_message);
	MessageBox(NULL, error_message, "Fatal Error!", MB_OK);
	exit(EXIT_FAILURE);
}


class MSWindowsWindow {
};


class DirectDrawWindow {
};


// Flip/Blt Doublebuffer to screen (updating &doublebuffer if necassery)
void MyShowDoubleBuffer(void)
{
	if (_method__ == USE_DIRECT_DRAW) {

		if (_do_flip_) {
			// Page flipped DirectDraw
			if (IDirectDrawSurface_Lock(lpDDSPrimary, NULL, &ddsd, 0, NULL) != DD_OK)
				fatal_error("Error Locking a DirectDraw Surface (DDSurfaceLock)");
			DoubleBuffer = (unsigned char *)ddsd.lpSurface;
			if (IDirectDrawSurface_Unlock(lpDDSPrimary, NULL) != DD_OK)
				fatal_error("Error Unlocking a DirectDraw Surface (DDSurfaceUnlock)");

			if(IDirectDrawSurface_Flip(lpDDSPrimary,lpDDSOne,0)==DDERR_SURFACELOST) {
				IDirectDrawSurface_Restore(lpDDSPrimary);
				IDirectDrawSurface_Restore(lpDDSOne);
			}

		} else {
			// Non Page flipped DirectDraw
			POINT pt;
			HDC   hdcx;
			ShowCursor(0);

			if (_do_full_) {
				if(IDirectDrawSurface_BltFast(lpDDSPrimary,0,0,lpDDSOne,&r,DDBLTFAST_NOCOLORKEY)==DDERR_SURFACELOST)
					IDirectDrawSurface_Restore(lpDDSPrimary),
						IDirectDrawSurface_Restore(lpDDSOne);
			} else {
				GetDCOrgEx(hdcx = GetDC(MainWnd_hWnd), &pt);
				ReleaseDC(MainWnd_hWnd, hdcx);
				IDirectDrawSurface_BltFast(lpDDSPrimary,pt.x,pt.y,lpDDSOne,&r,DDBLTFAST_NOCOLORKEY);
			}

			ShowCursor(1);
		}
	} else {
		// Using Windows API
		// BltBlt from memory to screen using standard windows API
		SetBitmapBits(hbmpMyBitmap, width*height*bytes_per_pixel, DoubleBuffer);
		if (_double__)
			StretchBlt(hdc, 0, 0, 2*width, 2*height, hdcMemory, 0, 0, width, height, SRCCOPY);
		else
			BitBlt(hdc, 0, 0, width, height, hdcMemory, 0, 0, SRCCOPY);
	}
}

int done = 0;

// Shut down application
void MyCloseWindow(void)
{
	if (done == 0)
	{
		done = 1;

		if (_method__ == USE_DIRECT_DRAW) {
			ShowCursor(1);
			if(lpDD != NULL) {
				if(lpDDSPrimary != NULL)
					IDirectDrawSurface_Release(lpDDSPrimary);
				if (!_do_flip_)
					if(lpDDSOne != NULL)
						IDirectDrawSurface_Release(lpDDSOne);
				IDirectDrawSurface_Release(lpDD);
			}
			lpDD = NULL;
			lpDDSOne = NULL;
			lpDDSPrimary = NULL;
		} else {
			/* release buffer */
			free(DoubleBuffer);
			// Release interfaces to BitBlt functionality
			SelectObject(hdcMemory, hbmpOld);
			DeleteDC(hdcMemory);
		}
		ReleaseDC(MainWnd_hWnd, hdc);
		PostQuitMessage(0);

	}
}

// Do the standard windows message loop thing
void MyDoMessageLoop(void)
{
	MSG msg;
	while(GetMessage(&msg, NULL, 0, 0 ))
	{
		TranslateMessage(&msg);
		DispatchMessage(&msg);
	}
	exit(msg.wParam);
}


void ProcessMessages()
{
	MSG msg;
	while (PeekMessage(&msg, NULL, 0, 0, 1 ))
	{
		TranslateMessage(&msg);
		DispatchMessage(&msg);
	}
}



LRESULT CALLBACK WndProc(HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam)
{
	if ( iMessage == WM_SIZE ) {
		width = lParam & 0xFFFF;
		height = (lParam >> 16) + 4;
		printf("resize: %i x %i   (%i %i)\n", width, height, (uint)lParam & 0xFFFF, lParam >> 16);
	}
	return DefWindowProc(hWnd, iMessage, wParam, lParam);
}



// Setup the application
void MyCreateWindow()
{
	DDSCAPS       ddscaps;
	WNDCLASS      wndclass; // Structure used to register Windows class.
	HINSTANCE     hInstance = 0;//g_hInstance;

	wndclass.style         = 0;
	wndclass.lpfnWndProc   = WndProc;//DefWindowProc;
	wndclass.cbClsExtra    = 0;
	wndclass.cbWndExtra    = 0;
	wndclass.hInstance     = hInstance;
	wndclass.hIcon         = LoadIcon(hInstance, "3D-MAGIC");
	wndclass.hCursor       = LoadCursor(NULL, IDC_ARROW);
	wndclass.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
	wndclass.lpszMenuName  = NULL;
	wndclass.lpszClassName = "DDraw Renderer Module";

	if (!RegisterClass(&wndclass))
		fatal_error("Error Registering Window");

	if (!(MainWnd_hWnd = CreateWindow("DDraw Renderer Module", "Media Player",
					WS_OVERLAPPEDWINDOW | WS_VISIBLE,  /* Window style.     */
					CW_USEDEFAULT, CW_USEDEFAULT,      /* Default position. */

					// take into account window border, and create a larger
					// window if stretching to double the window size.
					(_double__) ? 2*width + 10 : width + 10,
					(_double__) ? 2*height + 30 : height + 30,
					NULL, NULL, hInstance, NULL)))
		fatal_error("Error Creating Window");

	hdc = GetDC(MainWnd_hWnd);

	r.left   = 0;
	r.top    = 0;
	r.right  = width;
	r.bottom = height;

	if (_method__ == USE_DIRECT_DRAW)
	{
		if (DirectDrawCreate(NULL, &lpDD, NULL) != DD_OK)
			fatal_error("Error initialising DirectDraw (DDCreate)");

		if (_do_full_)
		{
			if (IDirectDraw_SetCooperativeLevel(lpDD, MainWnd_hWnd, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN | DDSCL_ALLOWMODEX) != DD_OK)
				fatal_error("Error initialising DirectDraw (DDSetCoopLevel)");
			if (IDirectDraw_SetDisplayMode(lpDD, width, height, 8*bytes_per_pixel) != DD_OK)
				fatal_error("Error initialising DirectDraw (DDSetDisplayMode)");
		}
		else
		{
			if (IDirectDraw_SetCooperativeLevel(lpDD, MainWnd_hWnd, /* DDSCL_EXCLUSIVE | */ DDSCL_NORMAL) != DD_OK)
				fatal_error("Error initialising DirectDraw (DDSetCoopLevel)");

			_do_flip_ = 0;
			bytes_per_pixel = GetDeviceCaps(hdc, BITSPIXEL) >> 3;
		}

		if (_do_flip_)
		{
			ddsd.dwSize = sizeof(ddsd);
			ddsd.dwFlags = DDSD_CAPS | DDSD_BACKBUFFERCOUNT;
			ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_FLIP | DDSCAPS_COMPLEX;
			ddsd.dwBackBufferCount = 1;
			if (IDirectDraw_CreateSurface(lpDD, &ddsd, &lpDDSPrimary, NULL) != DD_OK)
				fatal_error("Error Creating a Primiary DirectDraw Surface (DDCreateSurface)");

			// Get the pointer to the back buffer
			ddscaps.dwCaps = DDSCAPS_BACKBUFFER;
			if (IDirectDrawSurface_GetAttachedSurface(lpDDSPrimary, &ddscaps, &lpDDSOne) != DD_OK)
				fatal_error("Error Creating a Primiary DirectDraw Surface (DDCreateSurface)");
		}
		else
		{
			ddsd.dwSize = sizeof(ddsd);
			ddsd.dwFlags=DDSD_CAPS;
			ddsd.ddsCaps.dwCaps=DDSCAPS_PRIMARYSURFACE;
			if (IDirectDraw_CreateSurface(lpDD,&ddsd,&lpDDSPrimary,NULL) != DD_OK)
				fatal_error("Error Creating a Primiary DirectDraw Surface (DDCreateSurface)");

			ddsd.dwSize=sizeof(ddsd);
			ddsd.dwFlags=DDSD_CAPS|DDSD_HEIGHT|DDSD_WIDTH;
			ddsd.ddsCaps.dwCaps=DDSCAPS_OFFSCREENPLAIN;
			ddsd.dwWidth=width;
			ddsd.dwHeight=height;
			if (IDirectDraw_CreateSurface(lpDD,&ddsd,&lpDDSOne,NULL) != DD_OK)
				fatal_error("Error Creating a DirectDraw Off Screen Surface (DDCreateSurface)");

			if (lpDDSOne == NULL)
				fatal_error("Error Creating a DirectDraw Off Screen Surface (DDCreateSurface)");
		}

		// Get pointer to buffer surface
		if (IDirectDrawSurface_Lock(lpDDSOne, NULL, &ddsd, 0, NULL) != DD_OK)
			fatal_error("Error Locking a DirectDraw Surface (DDSurfaceLock)");
		DoubleBuffer = (unsigned char *)ddsd.lpSurface;
		if (IDirectDrawSurface_Unlock(lpDDSOne, NULL) != DD_OK)
			fatal_error("Error Unlocking a DirectDraw Surface (DDSurfaceUnlock)");

		if (_do_flip_)
			ShowCursor(0);
	}
	else /* Windows API */
	{
		bytes_per_pixel = GetDeviceCaps(hdc, BITSPIXEL) >> 3;

		DoubleBuffer = (unsigned char *)malloc(width*height*bytes_per_pixel);
		if (DoubleBuffer == NULL)
			fatal_error("Unable to allocate enough main memory for an offscreen Buffer");

		// Initialise interface to BitBlt function
		hdcMemory = CreateCompatibleDC(hdc);
		hbmpMyBitmap = CreateCompatibleBitmap(hdc, width, height);
		hbmpOld = (HBITMAP)SelectObject(hdcMemory, hbmpMyBitmap);

		{
			HPALETTE hpal;
			PALETTEENTRY mypal[64*3+16];
			int i;
			LOGPALETTE *plgpl;

			plgpl = (LOGPALETTE*) LocalAlloc(LPTR,
					sizeof(LOGPALETTE) + (16+3*64)*sizeof(PALETTEENTRY));

			plgpl->palNumEntries = 64*3+16;
			plgpl->palVersion = 0x300;

			for (i = 16; i < 64+16; i++)
			{
				plgpl->palPalEntry[i].peRed    = mypal[i].peRed    = LOBYTE(i << 2);
				plgpl->palPalEntry[i].peGreen  = mypal[i].peGreen  = 0;
				plgpl->palPalEntry[i].peBlue   = mypal[i].peBlue   = 0;
				plgpl->palPalEntry[i].peFlags  = mypal[i].peFlags  = PC_RESERVED;

				plgpl->palPalEntry[i+64].peRed    = mypal[i+64].peRed    = 0;
				plgpl->palPalEntry[i+64].peGreen  = mypal[i+64].peGreen  = LOBYTE(i << 2);
				plgpl->palPalEntry[i+64].peBlue   = mypal[i+64].peBlue   = 0;
				plgpl->palPalEntry[i+64].peFlags  = mypal[i+64].peFlags  = PC_RESERVED;

				plgpl->palPalEntry[i+128].peRed    = mypal[i+128].peRed    = 0;
				plgpl->palPalEntry[i+128].peGreen  = mypal[i+128].peGreen  = 0;
				plgpl->palPalEntry[i+128].peBlue   = mypal[i+128].peBlue   = LOBYTE(i << 2);
				plgpl->palPalEntry[i+128].peFlags  = mypal[i+128].peFlags  = PC_RESERVED;
			}

			hpal = CreatePalette(plgpl);
			oldhpal = SelectPalette(hdc, hpal, FALSE);

			RealizePalette(hdc);

		}

	}
}



class DirectDrawRenderer : public SimpleModule {
	public:
		DirectDrawRenderer() {
			width = 320 + 32;
			height = 240;
			_method__ = 0;   // API or DirectDraw
			_do_full_ = 0;   // Full screen
			_do_flip_ = 0;   // Page flipping
			_double__ = 0;   // Double window size
			_on_top__ = 0;   // Always on top
			_rate____ = 0;   // Calculate frame rate
		}
		void init() {
			MyCreateWindow();
		}
		void process( const Frame &f ) {
			const Frame *frame = &f;
			if ( frame && frame->refcount() ) {


//printf("width: %i height: %i\n", width, height);


		free(DoubleBuffer);
		SelectObject(hdcMemory, hbmpOld);
		DeleteDC((HDC)hbmpMyBitmap);
		//DeleteDC(hdcMemory);
		
		DoubleBuffer = (unsigned char *)malloc(width*height*bytes_per_pixel);
		if (DoubleBuffer == NULL)
			fatal_error("Unable to allocate enough main memory for an offscreen Buffer");
		
		// Initialise interface to BitBlt function
		hbmpMyBitmap = CreateCompatibleBitmap(hdc, width, height);
		hbmpOld = (HBITMAP)SelectObject(hdcMemory, hbmpMyBitmap);


				YUVFrame *picture = (YUVFrame *)frame->data();
				if (!videoScaleContext.configure(picture->width, picture->height, width, height,
							picture->pic, width * 4, picture->fmt, RGBA8888))
					return;
				videoScaleContext.convert(DoubleBuffer, picture->pic);
				MyShowDoubleBuffer();
				frame->deref();
			}
		}
		const char *name() { return "YUV Renderer"; }
		Format inputFormat() { return "FRAME_ID_YUV_VIDEO_FRAME"; }
		Format outputFormat() { return "FRAME_ID_RENDERED_VIDEO"; }
		bool isBlocking() { return true; }
	private:
		VideoScaleContext videoScaleContext;
};








Module *a, *b, *c, *d;


void registerModules()
{
    moduleMapper()->addModule( new OSSRenderer );
//    moduleMapper()->addModule( d = new YUVRenderer );
    moduleMapper()->addModule( d = new DirectDrawRenderer );
    moduleMapper()->addModule( new MP3DecodeModule );
//    moduleMapper()->addModule( new FFMpegMuxModule );
    moduleMapper()->addModule( new MpegDecodeModule );
//    moduleMapper()->addModule( new MP3SourceModule );
//    moduleMapper()->addModule( new StreamDemuxModule );
    moduleMapper()->addModule( c = new MpegEncodeModule );
//    moduleMapper()->addModule( b = new Splitter );
    moduleMapper()->addModule( new FFMpegSourceModule );
//    moduleMapper()->addModule( a = new VideoCameraSourceModule );
}

void playFile( const char *filename )
{
    pipelineMgr->addSource( "FRAME_ID_URL_SOURCE" );
    pipelineMgr->addDestination( "FRAME_ID_RENDERED_AUDIO" );
    pipelineMgr->addDestination( "FRAME_ID_RENDERED_VIDEO" );

    int length = strlen(filename) + 1;
    Frame file( "FRAME_ID_URL_SOURCE", memcpy(new char[length], filename, length) );
    file.ref();
    
    //pipelineMgr->start( &file );
    pipelineMgr->execute( &file );
}


void displayCamera()
{
    pipelineMgr->addSource( "FRAME_ID_VIDEO_CAMERA_SOURCE" );
    pipelineMgr->addDestination( "FRAME_ID_RENDERED_VIDEO" );
    pipelineMgr->start( new Frame( "FRAME_ID_VIDEO_CAMERA_SOURCE", 0 ) );
}

void reEncodeFile( const char *filename )
{
    pipelineMgr->addSource( "FRAME_ID_URL_SOURCE" );
    pipelineMgr->addDestination( "FRAME_ID_URL_SINK" );

    int length = strlen(filename) + 1;
    Frame file( "FRAME_ID_URL_SOURCE", memcpy(new char[length], filename, length) );
    file.ref();
    
    pipelineMgr->start( &file );
}

void recordVideo()
{
    pipelineMgr->addSource( "FRAME_ID_VIDEO_CAMERA_SOURCE" );
    pipelineMgr->addDestination( "FRAME_ID_URL_SINK" );
    pipelineMgr->addDestination( "FRAME_ID_RENDERED_VIDEO" );
    pipelineMgr->start( new Frame( "FRAME_ID_VIDEO_CAMERA_SOURCE", 0 ) );
}

int main( int argc, char** argv )
{
    registerModules();
    pipelineMgr = new PipelineManager;
/*    
    Frame f;
    printf("Connecting together: %s -> %s\n", a->name(), b->name() );
    staticDispatch( b, Init, 0 );
    a->connectTo( b, f );
//    b->connectedFrom( a, f );
    
    printf("Connecting together: %s -> %s\n", b->name(), c->name() );
    staticDispatch( c, Init, 0 );
    b->connectTo( c, f );
    
    printf("Connecting together: %s -> %s\n", b->name(), d->name() );
    staticDispatch( d, Init, 0 );
    b->connectTo( d, f );
*/
    playFile( (argc > 1) ? argv[1] : "test.mpg" );
    //reEncodeFile( (argc > 1) ? argv[1] : "test.mpg" );
    //displayCamera();
    //recordVideo();
}