---

kdenserver.hh

/*
 * PIAVE - PIAVE Is A Video Editor
 *
 * Copyright (C) 2002 Rolf Dubitzky, rolf@dubitzky.de
 *
 */

/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

/* \file
 * Here lives the server functionality of piave.
 *
 * This functionality is at the moment only used by kdenlive.  
 *
 * "Server" contains all functionality that would in principle be common
 * between serves for other GUIs, clients.
 *
 * "KdenLiveServer" implements the xml based protokoll to talk to kdenlive
 *
 */

#if ! defined ( KDENSERVER_HH )
#define KDENSERVER_HH

// std
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>

// std++
#include <iostream>
#include <string>
#include <algorithm>
#include <functional>
#include <list>

// piave
#include "server.hh"
#include "libpiave/piave_base.hh"
#include "libpiave/storybase.hh"
#include "libpiave/player.hh"
#include "libpiave/ringbuffer.hh"
#include "libpiave/VEML.hh"

namespace PIAVE {

    class KdenLiveServer : public Server
    {

      private:

        struct CommandQueue
        {
            enum AccessMode { block, non_block };
            PtrRingBuffer< VEMLCmnd > dropQ;
            PtrRingBuffer< VEMLCmnd > stdQ;
            pthread_mutex_t lock;               /* mutex ensuring exclusive access to buffer */
            pthread_cond_t  notempty;   /* signaled when buffer is not empty */
            pthread_cond_t  notfull;    /* signaled when buffer is not full */
            CommandQueue() {
                pthread_mutex_init( &lock, NULL );
                pthread_cond_init( &notempty, NULL );
                pthread_cond_init( &notfull, NULL );
            }
            void kick();
            void push( const VEMLCmnd * c );
            const VEMLCmnd * pop( AccessMode a );
        };

      public:
        KdenLiveServer(  unsigned short port );
        virtual ~KdenLiveServer();

        /* this function is only for temporary tests
         * the storyboard should be read from socket 
         */
        void setStoryBoard( StoryBoard * s ) { _theStoryBoard = s; }

        /*   to get an overview what is implemented
         */
        void printAllVEML( std::ostream & o ) const ;

        /* */
        void inc_seek_pos();
        void dec_seek_pos();
        void push_cmnd( const std::string & c );

        // tmporary ... start thread or not?  FIXME
        bool _listenForSDLEvents;

      protected:
        /*   main entry point
         */
        void startProcessCommandsLoop();

      private:
        /* the two thread routines: producer and consumer
         * these are static wrappes for the member functions
         */
        static void * _listen_for_commands( void * );
        static void * _listen_for_SDL_events( void * );
        static void * _process_commands( void * );

        /* Process any commands that have been recieved, send any
         * acknowledgements that are required. 
         */
        virtual void listenForCommands();
        virtual void listenForSDLEvents();
        virtual void processCommands();

        /* 
         * available VEML commands: 
         */
        virtual PropertyNode * veml_createVideoXWindow( const VEMLCmnd * cmd );
        virtual PropertyNode * veml_closeVideoXWindow( const VEMLCmnd * cmd  );
        virtual PropertyNode * veml_seek( const VEMLCmnd * cmd  );
        virtual PropertyNode * veml_play( const VEMLCmnd * cmd  );
        virtual PropertyNode * veml_quit( const VEMLCmnd * cmd  );
        virtual PropertyNode * veml_stop( const VEMLCmnd * cmd  );
        virtual PropertyNode * veml_getFileProperties( const VEMLCmnd * cmd );
        virtual PropertyNode * veml_render( const VEMLCmnd * cmd );
        virtual PropertyNode * veml_ping( const VEMLCmnd * cmd );
        virtual PropertyNode * veml_setSceneList( const VEMLCmnd * cmd );
        virtual PropertyNode * veml_getCapabilities( const VEMLCmnd * cmd );

        /*   
         */

      private:
        OutAVStreamIFace        * _screenOut;
        OutAudioStreamIFace     * _audioOut;

        StoryBoard              * _theStoryBoard;

        /*  this is the main map of known commands
         *  by appending commands to this map the cmnd will become
         *  recognizable by the precoessCommands thread
         */
        VEMLCmndMap        _allVEMLCommands;

        /* the listen thread puts commands in this buffer
         * the process thread reads commands from this buffer
         */
        CommandQueue _q;

        Player _player;
        Time _seek_pos;

        // the child threads
        pthread_t _main_thread;
        pthread_t _listen_thread;
        pthread_t _listen_SDL_thread;
        pthread_t _process_thread;

    };
};

#endif

---