Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.

BUG:215923


git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdemultimedia@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

63 files changed, 5899 insertions, 0 deletions

diff --git a/mpeglib/example/yaf/Makefile.am b/mpeglib/example/yaf/Makefile.am
new file mode 100644
index 00000000..7144955a
--- /dev/null
+++ b/mpeglib/example/yaf/Makefile.am
@@ -0,0 +1,15 @@
+#  yaflib - Makefile.am
+
+SUBDIRS		=	yafcore yafxplayer yafsplay yafmpgplay \
+			yaftplay yafvorbis yafyuv yafcdda
+
+
+
+EXTRA_DIST	=	README
+
+
+
+
+
+
+
diff --git a/mpeglib/example/yaf/README b/mpeglib/example/yaf/README
new file mode 100644
index 00000000..4fe128b0
--- /dev/null
+++ b/mpeglib/example/yaf/README
@@ -0,0 +1,4 @@
+
+Someday this directory will be replaced with a simple readline
+interface.
+
diff --git a/mpeglib/example/yaf/yafcdda/Makefile.am b/mpeglib/example/yaf/yafcdda/Makefile.am
new file mode 100644
index 00000000..2930f348
--- /dev/null
+++ b/mpeglib/example/yaf/yafcdda/Makefile.am
@@ -0,0 +1,35 @@
+#  splay-yaf - Makefile.am
+
+INCLUDES		=	-I../../include $(all_includes)
+
+
+bin_PROGRAMS		=	yaf-cdda
+
+yaf_cdda_SOURCES	=	cdda_control.cpp
+
+
+noinst_HEADERS		=	
+
+yaf_cdda_LDFLAGS	=	$(all_libraries) $(KDE_RPATH)
+
+
+yaf_cdda_LDADD		=	../yafxplayer/libyafxplayer.la \
+				../yafcore/libyafcore.la \
+				../../../lib/libmpeg.la \
+				$(THIS_LIB_LIBS)
+
+
+
+
+
+
+				
+
+
+
+
+
+
+
+
+
diff --git a/mpeglib/example/yaf/yafcdda/cdda_control.cpp b/mpeglib/example/yaf/yafcdda/cdda_control.cpp
new file mode 100644
index 00000000..5bac58e2
--- /dev/null
+++ b/mpeglib/example/yaf/yafcdda/cdda_control.cpp
@@ -0,0 +1,184 @@
+/*
+  generic interactive controller 
+  Copyright (C) 2000  Martin Vogt
+
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of the GNU Library General Public License as published by
+  the Free Software Foundation.
+
+  For more information look at the file COPYRIGHT in this package
+
+ */
+
+
+
+
+// Set for local include
+#define DIRECT_INCLUDE
+
+#include "../yafcore/yaf_control.h"
+#include "../yafxplayer/inputDecoderYAF.h"
+
+
+
+
+
+
+#include <iostream>
+using namespace std;
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+#if defined(HAVE_GETOPT_H) 
+#include <getopt.h>
+#endif
+
+// we include our plugin here
+#include "../../../lib/decoder/cddaPlugin.h"
+
+#if defined(HAVE_GETOPT_H) 
+#include <getopt.h>
+#endif
+
+
+                                          
+
+
+void control_divx(InputInterface* input,OutputInterface* output,
+		  InputDecoder* decoder) {
+
+
+  cout<< "Command:0 Msg:protocol yaf-0.1" << endl;
+  cout<< "Command:0 Msg:implements xplayer" << endl;
+  cout<< "Command:0 Msg:decoder cdparanoia " << endl;
+  cout<< "Command:0 Msg:mimetypes audio/cdda;" << endl;
+  cout<< "Command:0 Msg:comment cdparanoia by Monty <[email protected]>" << endl;
+  cout<< "Command:0 Msg:comment yaf port by [email protected]"<<endl;
+  cout<< "Command:0 Msg:comment based on sources from audiocd"<<endl;
+  cout<< "Command:0 Msg:comment enter 'help' " << endl;
+ 
+
+  
+ 
+  
+  yaf_control(input,output,decoder);
+}
+
+
+void usage() {
+  cout << "yaf-cdda is a interactive frontend for the cdda decoder"<<endl;
+  cout << "Usage : yaf-cdda [ahy] [url]"<<endl;
+  cout << endl;
+  cout << "-a : no internal audio device"<<endl;
+  cout << "-h : help"<<endl;
+  cout << "-y : autoplay off"<<endl;
+  cout << endl;
+  cout << "THIS SOFTWARE COMES WITH ABSOLUTELY NO WARRANTY! " \
+       << "USE AT YOUR OWN RISK!"<<endl;
+  cout << endl;
+  cout << "for more help type 'help' in interactive mode"<<endl;
+}
+
+
+
+
+int main(int argc, char** argv) {
+  int c;
+  int lInternalAudio=true;
+
+  pow(6.0,3.0);            // fixes bug in __math.h
+  InputInterface input;
+  OutputInterface output(&cout);
+
+
+  YafOutputStream* yafOutput=new YafOutputStream(&input);
+  CDDAPlugin* plugin=new CDDAPlugin();
+
+  plugin->setOutputPlugin(yafOutput);
+  InputDecoderYAF decoder(plugin,yafOutput);
+
+  
+
+  while(1) { 
+    c = getopt (argc, argv, "2al:L:scb:mhpywd:");
+    if (c == -1) break;
+    switch(c) {
+    case 'a': {    
+      lInternalAudio=false;
+      break;
+    }
+    case 'h': {
+      usage();
+      exit(0);
+    }
+    case 'y': {
+      decoder.setAutoPlay(false);
+      break;
+    }
+    case '2': {
+      plugin->config("-2","true",NULL);
+      break;
+    }
+    case 'm': {
+      plugin->config("-m","true",NULL);
+      break;
+    }
+    case 'c': {
+      plugin->config("-c","true",NULL);
+      break;
+    }
+    case 'w': {
+      plugin->config("-w","true",NULL);
+      break;
+    }
+    case 's': {
+      yafOutput->config("-s","true",NULL);
+      break;
+    }
+    case 'b': {
+      yafOutput->config("-b",optarg,NULL);
+      break;
+    }    
+    case 'd': {
+      yafOutput->config("yufDump",optarg,NULL);
+      break;
+    }    
+    case 'p': {
+      yafOutput->config("-p",optarg,NULL);
+      break;
+    }    
+    case 'l': {
+      plugin->config("AudioLayer",optarg,NULL);
+      cout << "trying to configure" << endl;
+      break;
+    }
+    case 'L': {
+      plugin->config("VideoLayer",optarg,NULL);
+      break;
+    }
+
+
+    default:
+      printf ("?? getopt returned character code 0%o ??\n", c);
+      usage();
+      exit(-1);
+    }
+  }
+
+  if (optind < argc ) {
+    Buffer buffer(300);
+    buffer.append("open ");
+    buffer.append(argv[optind]);
+    buffer.append("\n");
+    input.addInputLine(&buffer);
+
+  }
+  yafOutput->internalDevice(lInternalAudio);
+  control_divx(&input,&output,&decoder);
+  delete plugin;
+  delete yafOutput;
+
+}
+
+
diff --git a/mpeglib/example/yaf/yafcore/Makefile.am b/mpeglib/example/yaf/yafcore/Makefile.am
new file mode 100644
index 00000000..95119cb5
--- /dev/null
+++ b/mpeglib/example/yaf/yafcore/Makefile.am
@@ -0,0 +1,44 @@
+#  libyafshared - Makefile.am
+
+INCLUDES		=	-I../../include $(all_includes)
+
+EXTRA_DIST		=	PROTOCOL.v01 yafCommand.defs yafRuntime.defs
+
+
+lib_LTLIBRARIES		=	libyafcore.la
+
+noinst_HEADERS		=	commandTableYAF.h multiReader.h \
+				runtimeTableYAF.h \
+				outputDecoder.h \
+				commandLine.h \
+				commandTable.h lineStack.h \
+				parser.h
+
+
+libyafcore_la_SOURCES	=	buffer.cpp \
+				lineStack.cpp \
+				commandLine.cpp \
+				parser.cpp \
+				outputInterface.cpp \
+				inputInterface.cpp \
+				commandTable.cpp \
+				commandTableYAF.cpp \
+				runtimeTableYAF.cpp \
+				inputDecoder.cpp \
+				outputDecoder.cpp \
+				yaf_control.cpp \
+				multiReader.cpp
+
+libyafcore_la_LDFLAGS	=	$(all_libraries) $(KDE_RPATH) \
+				-no-undefined -avoid-version
+
+libyafcore_la_LIBADD	=	-lkdefakes $(THIS_LIB_LIBS)
+
+
+
+
+yafcoredir		=	$(includedir)/$(THIS_LIB_NAME)/util/yaf/yafcore
+
+yafcore_HEADERS		=	inputInterface.h outputInterface.h \
+				buffer.h inputDecoder.h yaf_control.h
+
diff --git a/mpeglib/example/yaf/yafcore/PROTOCOL.v01 b/mpeglib/example/yaf/yafcore/PROTOCOL.v01
new file mode 100644
index 00000000..fce6f1c5
--- /dev/null
+++ b/mpeglib/example/yaf/yafcore/PROTOCOL.v01
@@ -0,0 +1,243 @@
+
+This text describes how the interactive interface for mpg123 works.
+******************************************************************
+
+
+Interaction means, that the user can enters commands during
+the mpg123 decoder is running.
+For example, he can stops decoding and can jump to a special
+framenumber.
+
+The current frontends (e.g. tk3play) already allow this, but they are 
+a bit difficult for a user because he must enter
+numbers for special command instead of a more
+readable command like "open xyz.mp3"
+
+Then the tk3 interface can't produce return codes for the commands
+In this interface every command the user 
+sends to the decoder produces a return Message.
+(for now this messages always defaults to "success")
+
+Why the return codes?
+This allows a controlling GUI (which is a "user" in some way)
+to get a notification if e.g. the file cannot be opened
+by the decoder (wrong format, etc...)
+
+How does it work?
+****************
+Every command the user enters on stdin (cin) produces a return code.
+Thus if the user (or a GUI) sends "open xyz" he gets 
+a message whether this succeded or not.
+ 
+
+E.g:
+
+The user starts mpg123 in interacive mode and enters the first command:
+
+>open foo.mp3
+
+This command and is internally converted to the string:
+
+"Command:101 Msg:open foo.mp3"
+
+The control then writes to stdout :
+"Command:101 Ret:(file not found) Msg:open foo.mp3"
+
+
+The brackets behind "Ret:" belongs to the protocol
+they are delimeters for the return string. 
+
+Or, in the case the command was successfull, the user enters :
+play
+
+is translated to 
+"Command:102 Msg:play"
+return is:
+"Command:102 Ret:(ok) Msg:play"
+
+
+For what is the "Command:xyz" string good for?
+**********************************************
+
+This string is the current Command number. If a controlling
+GUI sends "Command:x Msg:open foo.mp3" it can search the outout
+from mpg123 for a string : "Command:x ........" This
+ist the return value of the decoder for the command "open foo.mp3"
+
+The command-number must be unique >= 40.
+All Command < 40 are runtime Commands.
+Runtime Commands always have the format :
+
+Command:<nr> Msg: <...>
+
+Example for runtime Commands:
+++++++++++++++++++++++++++++
+
+In the output stream of mpg123 there may be different message.
+For example mpg123 produces runtime information (time, currentframe or
+something like this).
+
+"Command:0 Msg:info1 p I 2.0 III 22050 Joint-Stereo 2 64 209"
+"Command:0 Msg:info1 p I 2.0 III 22050 Joint-Stereo 2 64 209"
+"Command:0 Msg:info1 p I 2.0 III 22050 Joint-Stereo 2 64 209"
+
+The Command number zero means that this output does not belong
+to any special input command.(The part after Msg: is decoder specific)
+
+There are more pre-definied Command Numbers:
+Nr    Description                  Example
+
+0 : Runtime info in general        Command:0 Msg:live long and prosper->SIGSEV
+1 : Debug info                     Command:1 Msg:search the bug
+
+Note:
+The debug Command is the only command which has *no* identifer
+after Msg: All other Commands < 40 needs a Message-identifer after
+Msg.
+In the example for Command 0 the Message identifer is "life"
+and the "real" Message is "long and prosper->SIGSEV".
+This mechanism allows to extend the runtime info sytem only
+with identifiers and not with numbers 
+Why? 
+Because the protocol should be easy to read. 
+(One of the ideas behind this protocol)
+Eg:
+
+Command:0 Msg:currentFrame 23
+is more "readable" than an extension with numbers 
+eg:
+Command:0 Msg:2 23
+
+In this example "2" mean that the 23 is the currentFrame Number.
+
+
+
+
+Runtime Commands may be processed by the frontend:
++++++++++++++++++++++++++++++++++++++++++++++++++
+
+Maybe there are errors during playing:
+
+"Command:0 Msg:exception p internal error- ignoring RIFF Header"
+
+The frontend checks the kind of runtime command:
+
+Frontend knows that there was an error(exception) but the status says (p)
+that the decoder continues playing (p)
+and for a more precise description (for the user)
+"error- ignoring RIFF Header"
+
+
+Back to the question:
+++++++++++++++++++++
+The frontend cannot be sure that the next message by the decoder
+is the return message of the previous sended command "open foo.mp3"
+This is the reason for the command number. They synchonise the 
+input (open foo.mp3) with the output.
+With a command number the GUI can filter the output for the return code.
+
+
+
+Restriction of the proctocol:
+****************************
+You cannot send binary data because a "\n" is interpreted as
+something like "end of input"
+This means that you cannot open a file in the mpg decoder
+which has "\n" in its name.
+Hm. Is this a restriction? Yes.
+An alternative would be to extend the Protocol to something
+like :
+
+Size:<Integer> Command:... Msg....
+
+(Maybe in the future)
+
+
+
+How is  this implemented?
+*************************
+
+
+In the source there are two classes:
+
+* InputInterface
+* OutputInterface
+
+
+First Example
+*************
+
+Let's say we want to write a Command-Line-Frontend for mpg123,
+which is included in the mpg123 source.
+(see the file: mpg123_control.c)
+
+What we must do?
+The Input for the decoder is the command by the user and
+the output is the output by the decoder.
+
+The user should not have to write the real syntax of the
+protocol. Thus he should not write:
+
+Command:1 Msg:open file.mp3
+
+But simply : open file.mp3
+
+The Inputinterface must translate the wrong input
+(in the view of the protocol) into the right
+protocolSyntax.
+(here: Command:<xyz> Msg:open file.mp3)
+
+This input is then passed to the decoder.
+The decoder translates the part after "Msg:" and 
+trys to open file.mp3, but in this example he cannot find it.
+Now he can send the return value with the valid Command number.
+Command:<xyz> Ret:(file not found) Msg:open file.mp3
+
+When the decoder returns from the "translations"
+we send the return-Msg (stored in the decoder)
+to the outputstream.
+For this we set in the Outputinterface the current Command number
+And then we send the return message and again the command
+which produced the return message.
+
+"Command:<Number> Ret:(file not found) Msg:eopn foo.mp3"
+
+Second Example
+**************
+
+Write a Gui frontend which starts mpg123 as a seperate process
+(how kmpg does).
+kmpg starts a new mpg123 with the compiled in yaf-interface.
+the yaf-interface is a commandline interface, but this is
+not what we want. We need another behaviour. 
+mpg123 must expect protocol data and not "user written" inputs.
+Thus kmpg must set the mpg123 frontend in another internal state 
+which expects protocol data.
+The first command which kmpg sends to the mpg123 frontend
+is : "protocol"
+This sets the InputInterface of mpg123 in a protocol-raw-modus.
+A user can type this on the command line as well, but
+then he must also generate the right protocol syntax.
+
+Then kmpg opens a file and send 
+e.g:
+Command:1 Msg:open abc.mp3
+
+Then the mpg123 output is sent back:
+
+Command:1 Ret:(ok) Msg:open abc.mp3
+
+
+DEBUGGING
+*********
+
+In the file InputInterface and OutputInterface are debug switches.
+If they are set the incoming/outgoing
+stream is copied to the files 
+instream.dbg
+outstream.dbg
+
+tail -f instream.dbg outstream.dbg
+
+monitors the interaction between a frontend and the decoder.
+
diff --git a/mpeglib/example/yaf/yafcore/README b/mpeglib/example/yaf/yafcore/README
new file mode 100644
index 00000000..c3cfd130
--- /dev/null
+++ b/mpeglib/example/yaf/yafcore/README
@@ -0,0 +1,27 @@
+
+yaf - <y>et <a>nother <f>rontend
+
+yaf is a simple protocol for communication over streams.
+
+Its purpose is to offer an extensible interface 
+for the communitcation between the kmpg GUI and the mpg123 decoder.
+
+
+DESCRIPTION
+
+The basic idea is, that the GUI and the decoder (splay) work
+together over their file streams (cin,cout)
+This means, that kmpg sends string-messages to "stdout"
+and splay receive these messages as "stdin".
+The results of splay (runtime Information, error
+codes) are send to "stdout" and kmpg receive them as "stdin"
+
+The protocol is "human readable" just enter "help"
+or "help <command>" on the prompt and you will see.
+These directory includes classes for dealing with this
+text protocol. In normal developement you can completly 
+ingore these classe.
+
+For more info look in the file PROTOCOL
+
+
diff --git a/mpeglib/example/yaf/yafcore/buffer.cpp b/mpeglib/example/yaf/yafcore/buffer.cpp
new file mode 100644
index 00000000..3c58f0ee
--- /dev/null
+++ b/mpeglib/example/yaf/yafcore/buffer.cpp
@@ -0,0 +1,156 @@
+/*
+  This class implements a dynamic string buffer
+  Copyright (C) 1998  Martin Vogt
+
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of the GNU Library General Public License as published by
+  the Free Software Foundation.
+
+  For more information look at the file COPYRIGHT in this package
+
+ */
+
+
+
+#include "buffer.h"
+
+
+
+Buffer::Buffer(int size) {
+  nSize=size;
+  msg=(char*) malloc(sizeof(char)*(nSize+1));
+  msg[nSize]='\0';
+  clear();
+
+}
+
+
+Buffer::~Buffer() {
+  free (msg);
+}
+
+
+void Buffer::clear() {
+  msg[0]='\0';
+}
+
+void Buffer::append(int value) {
+  Buffer buf(30);
+  sprintf(buf.getData(),"%d",value);
+  append(buf.getData());
+}
+
+
+
+
+void Buffer::append(char* appendMsg) {
+  char* appendPos=getAppendPos();
+  int nlen=strlen(appendMsg);
+  if (appendPos == NULL) return;
+  
+  append(appendMsg,nlen);
+}
+ 
+
+void Buffer::append(const char* appendMsg) {
+  append((char*)appendMsg);
+}
+
+ 
+void Buffer::append(char* buffer,int buflen) {
+  int nlen=len();
+  int nBedarf;
+
+  if (buflen+nlen <= nSize) {
+    char* appendPos=getAppendPos();
+    strncpy(appendPos,buffer,buflen);
+    appendPos[buflen]='\0';
+    return;
+  }
+  nBedarf=(nlen+buflen)-nSize;
+  grow(nBedarf);
+  append(buffer,buflen);
+}
+ 
+char* Buffer::getAppendPos() {
+  int i;
+  // this Array has nSize+1 entries!
+  // and it *is* granted that msg[nSize]=0;  (think so)
+  for (i=0;i<=nSize;i++) {
+    if (msg[i] == '\0') return &(msg[i]);
+  }
+  // should never reach this point
+  return NULL;
+}
+
+
+void Buffer::setData(char* msg) {
+  if (strlen(msg) == 0) {
+    clear();
+    return;
+  }
+  clear();
+  append(msg);
+}
+
+char* Buffer::getData() {
+  return msg;
+}
+
+
+int  Buffer::len() {
+  return strlen(msg);
+}  
+
+int Buffer::getSize() {
+  return nSize;
+}
+
+void Buffer::grow(int size) {
+  int i;
+  int newSize=nSize+size;
+  char* tmp=(char*) malloc(sizeof(char)*(newSize+1));
+  tmp[newSize]='\0';
+  for(i=0;i<=nSize;i++) {
+    tmp[i]=msg[i];
+  }
+ 
+  nSize=newSize;
+  free(msg);
+  msg=tmp;
+
+}
+
+
+int Buffer::find(char zeichen) {
+  int i;
+  int nlen=len();
+  for(i=0;i<nlen;i++) {
+    if (msg[i] == zeichen) return i;
+  }
+  return -1;
+}
+
+
+
+void Buffer::forward(int bytes) {
+  int i;
+  int aktPos;
+  int nlen=len();
+  if (bytes > nlen) {
+    bytes=nlen;
+  }
+  i=0;
+  aktPos=bytes;
+  while(aktPos <= nlen) {
+    msg[i]=msg[aktPos];
+    i++;
+    aktPos++;
+  }
+}
+
+
+
+void Buffer::print() {
+  printf("Buffer:%s\n",msg);
+}
diff --git a/mpeglib/example/yaf/yafcore/buffer.h b/mpeglib/example/yaf/yafcore/buffer.h
new file mode 100644
index 00000000..7c1a3d5c
--- /dev/null
+++ b/mpeglib/example/yaf/yafcore/buffer.h
@@ -0,0 +1,64 @@
+/*
+  This class implements a static string buffer
+  Copyright (C) 1998  Martin Vogt
+
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of the GNU Library General Public License as published by
+  the Free Software Foundation.
+
+  For more information look at the file COPYRIGHT in this package
+
+ */
+
+
+
+
+#ifndef __BUFFER_H
+#define __BUFFER_H
+
+
+extern "C" {
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+	   }
+#include <kdemacros.h>
+  
+class KDE_EXPORT Buffer {
+
+  char* msg;
+  int nSize;
+
+ public:
+  Buffer(int size);
+  ~Buffer();
+
+  void clear();
+  void append(int value);     // appends values as string
+  void append(char* msg);
+  void append(const char* msg);
+  
+  void append(char* buffer,int buflen);
+
+  int find(char zeichen);
+  int len();
+
+  void setData(char* msg);
+  char* getData();
+
+  int getSize();
+  void grow(int size);
+
+  void forward(int bytes);
+  void print();
+ private:
+  char* getAppendPos();
+  void read(FILE stream);
+
+};
+
+
+#endif
+
+
+
diff --git a/mpeglib/example/yaf/yafcore/commandLine.cpp b/mpeglib/example/yaf/yafcore/commandLine.cpp
new file mode 100644
index 00000000..e3ae8252
--- /dev/null
+++ b/mpeglib/example/yaf/yafcore/commandLine.cpp
@@ -0,0 +1,86 @@
+/*
+  An abstraction of a Command-Line
+  Copyright (C) 1998  Martin Vogt
+
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of the GNU Library General Public License as published by
+  the Free Software Foundation.
+
+  For more information look at the file COPYRIGHT in this package
+
+ */
+
+
+
+#include "commandLine.h"
+#include <iostream>
+using namespace std;  
+
+CommandLine::CommandLine(){
+  int i;
+  for (i=0; i < 10; i++) {
+    command[i].identifier=new Buffer(20);
+    command[i].value=new Buffer(100);
+  }
+  commandCount=0;
+
+}
+
+CommandLine::~CommandLine(){
+
+  int i;
+  for (i=0; i < 10; i++) {
+    delete command[i].value;
+    delete command[i].identifier;
+
+  }
+
+}
+
+
+int CommandLine::getCommandCount() {
+  return commandCount;
+}
+
+void CommandLine::setCommandCount(int commandCount){
+  this->commandCount=commandCount;
+}
+
+
+char* CommandLine::getIdentifier(int i){
+  return (command[i].identifier)->getData();
+}
+
+void CommandLine::clear() {
+  int i;
+  for (i=0; i < 10; i++) {
+    command[i].identifier->clear();
+    command[i].value->clear();
+  }
+  commandCount=0;
+}
+
+char* CommandLine::getValue(int i) {
+   return (command[i].value)->getData();
+}
+
+void CommandLine::setIdentifier(int i,char* identifier){
+  (command[i].identifier)->setData(identifier);
+}
+
+
+void CommandLine::setValue(int i,char* value) {
+  (command[i].value)->setData(value);
+}
+
+void CommandLine::printCommand() {
+  int i;
+  for(i=0;i<commandCount;i++) {
+    cout << "Command:" << i << "\n";
+    cout << "identifier:" << (command[i].identifier)->getData() << "\n";
+    cout << "value:" << (command[i].value)->getData() << "\n";
+  }
+}
+
+
+
diff --git a/mpeglib/example/yaf/yafcore/commandLine.h b/mpeglib/example/yaf/yafcore/commandLine.h
new file mode 100644
index 00000000..677c1018
--- /dev/null
+++ b/mpeglib/example/yaf/yafcore/commandLine.h
@@ -0,0 +1,60 @@
+/*
+  An abstraction of a Command-Line
+  Copyright (C) 1998  Martin Vogt
+
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of the GNU Library General Public License as published by
+  the Free Software Foundation.
+
+  For more information look at the file COPYRIGHT in this package
+
+ */
+
+
+
+
+
+#ifndef __BASICMESSAGE_H
+#define __BASICMESSAGE_H
+
+
+#include "buffer.h"
+
+
+struct BasicMessageStruct {
+
+  Buffer* identifier;
+  Buffer* value;
+
+};
+    
+typedef struct BasicMessageStruct tBasicMessage;
+
+
+class CommandLine {
+  
+
+  int commandCount;
+  tBasicMessage command[40];
+
+ public:
+
+  CommandLine();
+  ~CommandLine();
+
+  int getCommandCount();
+  void setCommandCount(int commandCount);
+
+  char* getIdentifier(int i);
+  char* getValue(int i);
+
+  void setIdentifier(int i,char* identifier);
+  void setValue(int i,char* value);
+
+  void printCommand();
+  void clear();
+};
+
+#endif
+
+
diff --git a/mpeglib/example/yaf/yafcore/commandTable.cpp b/mpeglib/example/yaf/yafcore/commandTable.cpp
new file mode 100644
index 00000000..10e36dc3
--- /dev/null
+++ b/mpeglib/example/yaf/yafcore/commandTable.cpp
@@ -0,0 +1,256 @@
+/*
+  valid Commands for Input/Output
+  Copyright (C) 1998  Martin Vogt
+
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of the GNU Library General Public License as published by
+  the Free Software Foundation.
+
+  For more information look at the file COPYRIGHT in this package
+
+ */
+
+
+
+#include "commandTable.h"
+#include <iostream>
+
+using namespace std;
+
+
+CommandTable::CommandTable(){
+  nCommandDesc=0;
+}
+
+CommandTable::~CommandTable(){
+}
+
+
+const char* CommandTable::getCommand(int nr) {
+  int i;
+  const char* back="";
+  for(i=0;i<nCommandDesc;i++) {
+    if (commandDesc[i].number == nr) {
+      return commandDesc[i].longName;
+    }
+  }
+  return back;
+}
+
+
+const char* CommandTable::getCommand(const char* name) {
+  int i;
+  int comp;
+  unsigned int nlen;
+  const char* back="";
+  for(i=0;i<nCommandDesc;i++) {
+    nlen=strlen(commandDesc[i].longName);
+    comp=strncmp(commandDesc[i].longName,name,nlen);
+    if (comp == 0) {
+      if (strlen(name) == nlen) {
+	return commandDesc[i].longName;
+      } else if ((strlen(name) > nlen) && (name[nlen]==' ')) {
+	return commandDesc[i].longName;
+      }
+    }
+
+    if (strlen(commandDesc[i].shortName) > 0) {
+      nlen=strlen(commandDesc[i].shortName);
+      comp=strncmp(commandDesc[i].shortName,name,nlen);    
+
+      if (comp == 0) {
+	if (strlen(name) == nlen) {
+	  return commandDesc[i].shortName;
+	} else if ((strlen(name) > nlen) && (name[nlen]==' ')) {
+	  return commandDesc[i].shortName;
+	}
+      }
+    }
+  }
+  return back;
+}
+
+
+int CommandTable::getNr(const char* command) {
+  int i;
+  int comp;
+  int back=-1;
+  unsigned int nlen;
+  for(i=0;i<nCommandDesc;i++) {
+    nlen=strlen(commandDesc[i].longName);
+    comp=strncmp(commandDesc[i].longName,command,nlen);
+    if (comp == 0) {
+      if (strlen(command) == nlen) {
+	return commandDesc[i].number;
+      } else if ((strlen(command) > nlen) && (command[nlen]==' ')) {
+	  return commandDesc[i].number;
+      }
+    }
+
+    if (strlen(commandDesc[i].shortName) > 0) {
+      nlen=strlen(commandDesc[i].shortName);
+      comp=strncmp(commandDesc[i].shortName,command,nlen);    
+
+      if (comp == 0) {
+	if (strlen(command) == nlen) {
+	  return commandDesc[i].number;
+	} else if((strlen(command) > nlen) && (command[nlen]==' ')){
+	  return commandDesc[i].number;
+	}
+      }
+    }
+  }
+  return back;
+}  
+
+
+const char* CommandTable::getArgs(const char* command,const char* wholeLine) {
+  unsigned int i;
+  unsigned int n;
+  const char* back;
+  back=wholeLine;
+  n=strlen(command);
+  if (n==0) return back;
+  for(i=0;i<n;i++) {
+    back++;
+  }
+  // we must take care that after every command there may be a
+  // space
+  if (strlen(wholeLine) > n) {
+    back++;
+  }
+  return back;
+}
+
+
+
+void CommandTable::print() {
+  int i;
+  cout << "internal Help System V. 0.2\n";
+  cout << "known commands are :\n\n";
+  for(i=0;i<nCommandDesc;i++) {
+    print(commandDesc[i].number,false);
+  }
+}
+
+
+int CommandTable::getPos(int commandNr) {
+  int i;
+  int pos=-1;
+  for (i=0;i<nCommandDesc;i++) {
+    if (commandDesc[i].number == commandNr) {
+      pos=i;
+      break;
+    }
+  }
+  return pos;
+}
+
+void CommandTable::print (int command,int lWithHelp) {
+  int i=getPos(command);
+  if (i<0) {
+    cout << "unknown Command\n";
+    return;
+  }
+  if (commandDesc[i].lexternalUse == false) return;
+  
+  cout    << commandDesc[i].longName << "("  ;
+  if (strlen(commandDesc[i].shortName) == 0) {
+    cout << "No";
+  } else {
+    cout <<  commandDesc[i].shortName;
+  }
+  cout << ") Nr :" <<  commandDesc[i].number <<" ";
+  if (lWithHelp==true) {
+    cout <<  commandDesc[i].help ;
+  }
+  cout <<"\n";
+}
+
+
+
+CommandDescription* CommandTable::getCommandDescription(int i) {
+  return &(commandDesc[i]);
+}
+
+
+
+int CommandTable::getCommandCounter() {
+  return nCommandDesc;
+}
+
+
+void CommandTable::join(CommandTable* table) {
+  int i;
+  int n=table->getCommandCounter();
+  CommandDescription* cmdDesc;
+
+  for (i=0;i<n;i++) {
+    cmdDesc=table->getCommandDescription(i);
+    insert(cmdDesc);
+
+  }
+
+}
+
+
+
+    
+
+
+
+void CommandTable::insert(CommandDescription* cmdDesc) {
+  const char* lNameTest;
+  const char* sNameTest;
+  int pos=getPos(cmdDesc->number);
+
+  if (pos != -1) {
+    cout << "number "<< cmdDesc->number 
+	 << " for command "<< cmdDesc->longName << " already defined!" << endl;
+  }
+
+  lNameTest=getCommand(cmdDesc->longName);
+  if (strlen(lNameTest) > 0) {
+    cout << "longName "<< cmdDesc->longName << " already defined."
+         << "Previous definition has number : " 
+	 << getNr(cmdDesc->longName) << endl;
+  }    
+
+  sNameTest=getCommand(cmdDesc->shortName);
+  if (strlen(sNameTest) > 0) {
+    cout << "shortName "<< cmdDesc->shortName << " already defined."
+         << "Previous definition has number : " 
+	 << getNr(cmdDesc->shortName) << endl;
+
+  }    
+
+
+  commandDesc[nCommandDesc].lexternalUse=cmdDesc->lexternalUse;
+  commandDesc[nCommandDesc].lReturn=cmdDesc->lReturn;
+  commandDesc[nCommandDesc].longName=cmdDesc->longName;
+  commandDesc[nCommandDesc].shortName=cmdDesc->shortName;
+  commandDesc[nCommandDesc].number=cmdDesc->number;
+  commandDesc[nCommandDesc].help=cmdDesc->help;
+  nCommandDesc++;
+}
+
+
+int CommandTable::getReturnFlag(int cmdNr) {
+  int i=getPos(cmdNr);
+  CommandDescription* cmdDesc;
+  if (i == -1) {
+    return -1;
+  }
+  cmdDesc=getCommandDescription(i);
+  return cmdDesc->lReturn;
+}
+
+
+
+  
+   
+
+
+
+
+
diff --git a/mpeglib/example/yaf/yafcore/commandTable.h b/mpeglib/example/yaf/yafcore/commandTable.h
new file mode 100644
index 00000000..75dd4325
--- /dev/null
+++ b/mpeglib/example/yaf/yafcore/commandTable.h
@@ -0,0 +1,82 @@
+/*
+  valid Commands for Input/Output
+  Copyright (C) 1998  Martin Vogt
+
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of the GNU Library General Public License as published by
+  the Free Software Foundation.
+
+  For more information look at the file COPYRIGHT in this package
+
+ */
+
+
+
+#ifndef __COMMANDTABLE_H
+#define __COMMANDTABLE_H
+
+
+extern"C" {
+#include <string.h>
+#include <stdio.h>
+}
+
+#include <kdemacros.h>
+
+#define _CT_START 40
+
+
+
+
+
+
+struct CommandDescriptionStruct {
+
+  int lexternalUse;         // written when user enters "help"
+
+  // this field can be used to deliver a delayed return msg
+  int lReturn;              // true generate ret-msg automatically
+
+  const char* longName;
+  const char* shortName;
+  int   number;
+  const char* help;
+};
+
+
+typedef struct CommandDescriptionStruct CommandDescription;
+
+
+class KDE_EXPORT CommandTable {
+
+  int nCommandDesc;
+  CommandDescription commandDesc[50];
+
+ public:
+  CommandTable();
+  virtual ~CommandTable();
+  void insert(CommandDescription* cmdDesc);
+
+
+  int getNr(const char* name);
+  const char* getCommand(const char* name);
+  const char* getCommand(int nr);
+  const char* getArgs(const char* command,const char* wholeLine);
+
+  int getReturnFlag(int cmdNr);
+  void print();
+  void print (int i,int lWithHelp);
+
+  int getCommandCounter();
+  void join(CommandTable* table);  // join two tables (no deep join!)
+
+ private:
+  CommandDescription* getCommandDescription(int i);
+  int getPos(int commandNr);
+};
+
+
+#endif
+
+
+
diff --git a/mpeglib/example/yaf/yafcore/commandTableYAF.cpp b/mpeglib/example/yaf/yafcore/commandTableYAF.cpp
new file mode 100644
index 00000000..d071817b
--- /dev/null
+++ b/mpeglib/example/yaf/yafcore/commandTableYAF.cpp
@@ -0,0 +1,36 @@
+/*
+  valid Commands for yaf (basic yaf commands)
+  Copyright (C) 1998  Martin Vogt
+
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of the GNU Library General Public License as published by
+  the Free Software Foundation.
+
+  For more information look at the file COPYRIGHT in this package
+
+ */
+
+
+#define _USE_YAF_STRUC
+
+#include "commandTableYAF.h"
+
+
+CommandTableYAF::CommandTableYAF(){
+  init();
+}
+
+CommandTableYAF::~CommandTableYAF(){
+}
+
+void CommandTableYAF::init() {
+
+
+  int i;
+  for (i=0;i<YAFCOMMANDS_SIZE;i++) {
+    insert(&yafCommands[i]);
+  }
+	   
+
+}
+
diff --git a/mpeglib/example/yaf/yafcore/commandTableYAF.h b/mpeglib/example/yaf/yafcore/commandTableYAF.h
new file mode 100644
index 00000000..fe12793d
--- /dev/null
+++ b/mpeglib/example/yaf/yafcore/commandTableYAF.h
@@ -0,0 +1,36 @@
+/*
+  valid Commands for yaf (basic yaf commands)
+  Copyright (C) 1998  Martin Vogt
+
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of the GNU Library General Public License as published by
+  the Free Software Foundation.
+
+  For more information look at the file COPYRIGHT in this package
+
+ */
+
+
+
+
+#ifndef __COMMAND_YAF_H
+#define __COMMAND_YAF_H
+
+#include "commandTable.h"
+#include "yafCommand.defs"
+
+
+
+
+
+class CommandTableYAF : public CommandTable {
+
+ public:
+  CommandTableYAF();
+  ~CommandTableYAF();
+  void init();
+
+};
+
+#endif
+
diff --git a/mpeglib/example/yaf/yafcore/inputDecoder.cpp b/mpeglib/example/yaf/yafcore/inputDecoder.cpp
new file mode 100644
index 00000000..e24b7758
--- /dev/null
+++ b/mpeglib/example/yaf/yafcore/inputDecoder.cpp
@@ -0,0 +1,237 @@
+/*
+  process Messages on the decoder
+  Copyright (C) 1998  Martin Vogt
+
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of the GNU Library General Public License as published by
+  the Free Software Foundation.
+
+  For more information look at the file COPYRIGHT in this package
+
+ */
+
+
+#include "inputDecoder.h"
+
+#include "commandTable.h"
+#include "commandTableYAF.h"
+#include "yafRuntime.defs"
+#include "commandLine.h"
+#include <iostream>
+
+using namespace std;
+
+InputDecoder::InputDecoder() {
+  commandTable=new CommandTable();
+  yafCommands=new CommandTableYAF();
+  appendCommandTable(yafCommands);
+  status=_DECODER_STATUS_IDLE;
+  lRuntimeInfo=true;
+  returnBuffer= new Buffer(200);
+  returnLine= new Buffer(200);
+
+  commandCounter=-1;
+  commandCounter=-1;
+  commandId=-1;
+  commandCounterString=NULL;
+  
+}
+
+
+InputDecoder::~InputDecoder(){
+  delete yafCommands;
+  delete returnBuffer;
+  delete returnLine;
+  delete commandTable;
+}
+
+
+
+void InputDecoder::setRuntimeInfo(int lRuntimeInfo) {
+  this->lRuntimeInfo=lRuntimeInfo;
+}
+
+
+int InputDecoder::getRuntimeInfo() {
+  return lRuntimeInfo;
+}
+
+
+void InputDecoder::appendCommandTable(CommandTable* table){
+  commandTable->join(table);
+}
+
+
+
+
+void InputDecoder::processCommandLine(CommandLine* commandLine){
+  CommandTable* ct=commandTable;  // "ct" is shorter
+  commandId=-1;
+
+  // The number of the command (unique for every command)
+  commandCounterString=commandLine->getValue(0);
+  commandCounter=atoi(commandCounterString);
+
+  // the command (longName or shortName )
+  if (commandLine->getCommandCount() == 0) {
+    clearReturnBuffer();
+    appendReturnBuffer("no Msg");
+  }    
+  commandMsg=ct->getCommand(commandLine->getValue(1));
+  if ((commandMsg == NULL) || (strlen(commandMsg) == 0)) {
+    clearReturnBuffer();
+    appendReturnBuffer("unknown Command");
+    commandMsg=commandLine->getValue(1);
+
+    return ;
+  }
+
+  // the int value of the command (faster for compare)
+  commandId=ct->getNr(commandMsg);
+
+  // the Arguments of the command
+  commandArgs=ct->getArgs(commandMsg,(const char*) commandLine->getValue(1));
+
+  retString=processCommand(commandId,commandArgs);
+
+  if ((retString == NULL) || (strlen(retString) == 0)) {
+    retString=(char*)"ok";
+  }
+  clearReturnBuffer();
+  appendReturnBuffer(retString);
+}
+
+
+const char* InputDecoder::processCommand(int command,const char* args){
+
+  if (command == _YAF_I_HELP) {
+    if (strlen(args)==0) {
+      commandTable->print();
+    } else {
+      commandTable->print(commandTable->getNr(args),true);
+    }
+    return "";
+  }
+  if (command == _YAF_I_RUNTIME) {
+    if (strcmp("off",args)==0) {
+      setRuntimeInfo(false);
+      return "";
+    }
+    setRuntimeInfo(true);
+    return "";
+  }
+  if (command == _YAF_I_QUIT) {
+    ::exit(0);
+    return "";
+  }
+  if (command == _YAF_I_WHATIS) {
+    cout << "Yaf <y>et <a>nother <f>rontend" << endl;
+    cout << endl;
+    cout << "Yaf is an interactive command line oriented shell for decoders." \
+	 << endl;
+    cout << endl;
+    cout << "Copyright (C) 1998,1999  Martin Vogt <[email protected]>"\
+	 <<endl;
+    cout << "This program is free software; you can redistribute "\
+         << "it and/or modify"<<endl;
+    cout << "it under the terms of the GNU Library General Public License "\
+         << "as published by"<<endl;
+    cout << "the Free Software Foundation." <<endl;
+
+    cout << "For more information look at the file COPYRIGHT in "\
+	 << "this package" <<endl;
+    cout << endl;
+    cout << "THIS SOFTWARE COMES WITH ABSOLUTELY NO WARRANTY! " \
+         << "USE AT YOUR OWN RISK!"<<endl;
+    return "";
+  }
+      
+  
+  if (command == _YAF_I_PING) {
+    return "";
+  }
+  if (command == _YAF_I_PROTOCOL) {
+    return "";
+  }
+  if (command == _YAF_I_NOPROTOCOL) {
+    return "";
+  }
+
+  return "unknown Command";
+}
+
+
+/**
+   These two functions are entered by the decoder
+   thread  [START]
+*/
+
+
+void InputDecoder::doSomething(){
+  cout << "did something"<<endl;
+}
+
+
+
+int InputDecoder::getDecoderStatus() {
+  return status;
+}
+
+
+
+void InputDecoder::setDecoderStatus(int newState) {
+
+  // First start a new thread with start()!
+  // Their is no recovery if the thread status is set to exit!
+  if (status == _DECODER_STATUS_EXIT) {
+    return;
+  }
+  status=newState;
+}
+
+
+
+void InputDecoder::clearReturnBuffer() {
+  returnBuffer->clear();
+}
+
+
+void InputDecoder::appendReturnBuffer(const char* str) {
+  returnBuffer->append(str);
+}
+
+
+
+const char* InputDecoder::getReturnCode() {
+  // now we send back the return code
+  
+  if ((commandId != -1) && (commandTable->getReturnFlag(commandId)==false)) {
+    return "";
+  }
+
+  returnLine->clear();
+  returnLine->append("Command:");
+
+
+  // The number of the command (unique for every command)
+  // 0: the command nr
+  returnLine->append(commandCounterString);
+  returnLine->append(" Ret:(");
+  returnLine->append(returnBuffer->getData());
+  returnLine->append(") Msg:");
+
+  
+  // now get the part after Msg: (in the inputLine)
+
+  returnLine->append(commandMsg);
+  returnLine->append(" ");
+  returnLine->append(commandArgs);
+
+
+
+  return (const char*)returnLine->getData();
+
+}
+
+  
+
diff --git a/mpeglib/example/yaf/yafcore/inputDecoder.h b/mpeglib/example/yaf/yafcore/inputDecoder.h
new file mode 100644
index 00000000..0a5623a0
--- /dev/null
+++ b/mpeglib/example/yaf/yafcore/inputDecoder.h
@@ -0,0 +1,80 @@
+/*
+  process Messages on the decoder
+  Copyright (C) 1998  Martin Vogt
+
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of the GNU Library General Public License as published by
+  the Free Software Foundation.
+
+  For more information look at the file COPYRIGHT in this package
+
+ */
+
+
+
+
+#ifndef __INPUTDECODER_H
+#define __INPUTDECODER_H
+#include <pthread.h>
+
+#include "outputInterface.h"
+#include <strings.h>
+#include <kdemacros.h>
+
+#define _DECODER_STATUS_IDLE       1
+#define _DECODER_STATUS_WORKING    2
+#define _DECODER_STATUS_EXIT       3
+
+class CommandTable;
+class CommandTableYAF;
+class CommandLine;
+
+class KDE_EXPORT InputDecoder {
+
+  int status;
+  CommandTable* commandTable;
+  CommandTableYAF* yafCommands;
+  Buffer* returnBuffer;
+  Buffer* returnLine;
+  int lRuntimeInfo;
+
+
+
+  
+ public:
+  InputDecoder();
+  virtual ~InputDecoder();
+  
+  void processCommandLine(CommandLine*);
+  virtual const char* processCommand(int command,const char* args);
+  virtual void doSomething();
+
+  virtual void setDecoderStatus(int status);
+  int getDecoderStatus();
+
+  const char* getReturnCode();
+
+  void appendCommandTable(CommandTable* table);
+
+  void setRuntimeInfo(int lRuntimeInfo);
+  int getRuntimeInfo();
+
+
+ private:
+
+  void clearReturnBuffer();
+  void appendReturnBuffer(const char* msg);
+
+
+  int commandCounter;
+  int commandId;
+  const char* commandMsg;
+  const char* commandArgs;
+  const char* retString;
+  char* commandCounterString;
+  
+  
+};
+
+#endif
+
diff --git a/mpeglib/example/yaf/yafcore/inputInterface.cpp b/mpeglib/example/yaf/yafcore/inputInterface.cpp
new file mode 100644
index 00000000..455ddd40
--- /dev/null
+++ b/mpeglib/example/yaf/yafcore/inputInterface.cpp
@@ -0,0 +1,195 @@
+/*
+  This class can wait for an input by the user
+  Copyright (C) 1998  Martin Vogt
+
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of the GNU Library General Public License as published by
+  the Free Software Foundation.
+
+  For more information look at the file COPYRIGHT in this package
+
+ */
+
+#include <config.h>
+
+#include "inputInterface.h"
+#include "multiReader.h"
+#include <iostream>
+
+using namespace std;
+
+InputInterface::InputInterface(){
+
+  currentLine= new Buffer(300);
+  rawLine=new Buffer(300);
+  loopback=new Buffer(300);
+  protocolSyntax=false;
+  currentCommandNumber=42;
+  multiReader=new MultiReader();
+  yafInput=new ifstream("yaf.script");
+  if (yafInput->fail() == false) {
+    cout << "Command:0 Msg:comment found yaf.script. Parsing first"<<endl;
+    insertYafScript(yafInput);
+  }
+  yafInput->close();
+
+}
+
+InputInterface::~InputInterface(){
+  delete yafInput;
+  delete multiReader;
+  delete currentLine;
+  delete rawLine;
+  delete loopback;
+}
+
+
+int InputInterface::addFileDescriptor(int fd) {
+  int back;
+  back=multiReader->add(fd);
+  return back;
+}
+
+
+void InputInterface::removeFileDescriptor(int fd) {
+  multiReader->remove(fd);
+}
+
+
+int InputInterface::getCurrentCommandNumber() {
+  int back=0;
+  back=currentCommandNumber;
+  return back;
+}
+
+void InputInterface::increaseCurrentCommandNumber(){
+  currentCommandNumber++;
+}
+
+int InputInterface::write(int fd,const char* txt) {
+  int back=0;
+
+  int len;
+  loopback->clear();
+  if (protocolSyntax == true) {
+    snprintf(loopback->getData(),300,
+	     "Command:41 Msg:%s",txt);
+  } else {
+    strlcpy(loopback->getData(),txt, loopback->getSize());
+  }
+  len =loopback->len();
+  back=::write(fd,loopback->getData(),len);
+
+  return back;
+}
+
+
+
+void InputInterface::waitForLine() {
+
+  while(multiReader->hasLine() == false) {
+    multiReader->waitForLine();
+  }
+  multiReader->getLine(rawLine);
+  makeValidLine(rawLine->getData());
+
+}
+
+void InputInterface::setProtocolSyntax (int proto) {
+  protocolSyntax=proto;
+}
+
+
+
+void InputInterface::makeValidLine(char* line) {
+
+  int len;
+  len=strlen(line);
+  if (len >= 1) {
+    if (line[len-1] == '\n') {
+      line[len-1]='\0';
+    }
+  }
+  if (strncmp("noprotocol",line,10) == 0){
+    setProtocolSyntax(false);
+    clearLine();
+    increaseCurrentCommandNumber();
+    snprintf(currentLine->getData(),300,
+	     "Command:%d Msg:%s",currentCommandNumber,line);
+    return;
+  }
+  if (strncmp("protocol",line,8) ==  0 ){
+    setProtocolSyntax(true);
+    clearLine();
+    increaseCurrentCommandNumber();
+    snprintf(currentLine->getData(),300,
+	     "Command:%d Msg:%s",currentCommandNumber,line);
+    return;
+  }
+
+  // Now the part if we do _not_ bypass the protocol-state
+
+  if (protocolSyntax == false) {
+    clearLine();
+    increaseCurrentCommandNumber();
+    snprintf(currentLine->getData(),300,
+	     "Command:%d Msg:%s",currentCommandNumber,line);
+  } else {
+    increaseCurrentCommandNumber();
+    strlcpy(currentLine->getData(),line, currentLine->getSize());
+  }
+
+  return;
+}
+
+
+void InputInterface::addInputLine(struct Buffer* buffer) {
+  multiReader->add(buffer);
+}
+
+
+void InputInterface::insertYafScript(ifstream* stream) {
+  char bst;
+  int nBytes=0;
+  Buffer yafScriptBuffer(300);
+
+  if (stream->fail()) return;
+  while (stream->eof()==false) {
+    stream->get(bst);
+    if (stream->eof()) break;
+
+    yafScriptBuffer.append(&bst,1);
+  }
+  nBytes=(yafScriptBuffer.len()-1);  // EOF is a character we dont want
+
+  addInputLine(&yafScriptBuffer);
+}
+
+
+
+int  InputInterface::hasLine() {
+  if (currentLine->len() == 0) return 0;
+  return 1;
+}
+
+void InputInterface::clearLine() {
+  currentLine->clear();
+}
+
+
+char* InputInterface::getLine() {
+  char* back=NULL;
+
+  back=currentLine->getData();
+#ifdef _DEBUG_INPUT
+  ofstream infile("instream.dbg",ios::app);
+  infile << back <<endl;
+  infile.close();
+#endif
+
+
+  return back;
+}
+
+
+
diff --git a/mpeglib/example/yaf/yafcore/inputInterface.h b/mpeglib/example/yaf/yafcore/inputInterface.h
new file mode 100644
index 00000000..f3ea0065
--- /dev/null
+++ b/mpeglib/example/yaf/yafcore/inputInterface.h
@@ -0,0 +1,102 @@
+/*
+  This class can wait for an input by the user
+  Copyright (C) 1998  Martin Vogt
+
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of the GNU Library General Public License as published by
+  the Free Software Foundation.
+
+  For more information look at the file COPYRIGHT in this package
+
+ */
+
+
+
+#ifndef __INPUTINTERFACE_H
+#define __INPUTINTERFACE_H
+
+
+#include "buffer.h"
+#include <fstream>
+#include <kdemacros.h>
+
+extern "C" {
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/time.h>
+#include <errno.h>
+#include <sys/stat.h>
+#include <stdio.h>
+}
+
+// uncomment this for debugging the input stream
+// (written to file instream.dbg)
+//#define _DEBUG_INPUT
+
+#define _TIMEOUT_MS   2000
+
+class MultiReader;
+
+class KDE_EXPORT InputInterface {
+
+  int currentCommandNumber;
+
+  int protocolSyntax;
+  Buffer* currentLine;
+  Buffer* rawLine;
+  MultiReader* multiReader;
+  Buffer* loopback;
+  Buffer* yafScript;
+  std::ifstream* yafInput;
+
+
+ public:
+
+  InputInterface();
+  ~InputInterface();
+
+  int addFileDescriptor(int fd);
+  void removeFileDescriptor(int fd);
+  int write(int fd,const char* txt);
+
+  /**
+     waits until a complete Line is entered 
+  */
+  void waitForLine();
+
+  /**
+    returns true if a complete new InputLine is avaiable
+  */
+
+  int hasLine();
+
+  int getCurrentCommandNumber();
+
+  void increaseCurrentCommandNumber();
+
+  /**
+     clears the input Line
+  */
+  void clearLine();
+  
+
+  /**
+     returns the new Line
+  */
+  char* getLine();
+
+
+  void setProtocolSyntax(int proto);
+  void addInputLine(struct Buffer* buffer);
+
+ private:
+  void makeValidLine(char* line);
+  void insertYafScript(std::ifstream* stream);
+
+  
+};
+
+#endif
+
+
+   
diff --git a/mpeglib/example/yaf/yafcore/lineStack.cpp b/mpeglib/example/yaf/yafcore/lineStack.cpp
new file mode 100644
index 00000000..871665ed
--- /dev/null
+++ b/mpeglib/example/yaf/yafcore/lineStack.cpp
@@ -0,0 +1,95 @@
+/*
+  a class which scans a string and converts it into commandLines
+  Copyright (C) 1998  Martin Vogt
+
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of the GNU Library General Public License as published by
+  the Free Software Foundation.
+
+  For more information look at the file COPYRIGHT in this package
+
+ */
+
+
+
+#include "lineStack.h"
+#include <iostream>
+
+using namespace std;
+
+
+LineStack::LineStack() {
+  stack=new Buffer(1);
+}
+
+
+LineStack::~LineStack() {
+  delete stack;
+}
+
+
+int LineStack::hasLine() {
+  int nPos;
+  nPos=stack->find('\n');
+  if (nPos == -1) return false;
+  return true;
+
+}
+
+
+
+void LineStack::nextLine(Buffer* nextLine) {
+  int nPos;
+  char* retPos;
+  int restLen;
+  char* data=stack->getData();
+  int nSize=stack->getSize();
+
+  nPos=stack->find('\n');
+  if (nPos == -1) {
+    nextLine->clear();
+    return;
+  }
+  retPos=&(data[nPos]);
+  (*retPos)='\0';
+  nextLine->clear();
+  nextLine->setData(data);
+  retPos++;
+  restLen=nSize+1-(nPos+1);
+  if (strlen(retPos) > 0) {
+    strncpy(data,retPos,restLen);
+  } else{
+    stack->clear();
+  }
+}
+
+
+void LineStack::appendBottom(char* buffer) {
+  int n=strlen(buffer);
+  appendBottom(buffer,n);
+}
+
+
+
+void LineStack::appendBottom(char* buffer, int buflen) {
+
+  stack->append(buffer,buflen);
+
+}
+
+void LineStack::appendBottom(LineStack* lStack) {
+  char* data;
+  int len;
+  data=lStack->stack->getData();
+  len=lStack->stack->len();
+  appendBottom(data,len); 
+}
+
+  
+  
+void LineStack::print(char* name) {
+  cout << "LineStack:"<<name<<endl;
+  stack->print();
+}
+
+  
diff --git a/mpeglib/example/yaf/yafcore/lineStack.h b/mpeglib/example/yaf/yafcore/lineStack.h
new file mode 100644
index 00000000..aea1f686
--- /dev/null
+++ b/mpeglib/example/yaf/yafcore/lineStack.h
@@ -0,0 +1,55 @@
+/*
+  a class which scans a string and converts it into commandLines
+  Copyright (C) 1998  Martin Vogt
+
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of the GNU Library General Public License as published by
+  the Free Software Foundation.
+
+  For more information look at the file COPYRIGHT in this package
+
+ */
+
+
+
+
+
+#ifndef __LINESTACK_H
+#define __LINESTACK_H
+
+
+#include "buffer.h"
+
+/* 
+   This class is a hack because I have problems with
+   the io-streams. Why these stupid things cannot buffer
+   a whole line?
+   They behave strange, I hate them.
+*/
+   
+
+
+class LineStack {
+
+ public:
+  LineStack();
+  ~LineStack();
+
+  void appendBottom(char* buffer);
+  void appendBottom(char* buffer,int buflen);
+  void appendBottom(LineStack* stack);
+  
+  int hasLine();
+  void nextLine(Buffer* nextLine);
+
+  void print(char* name);
+ private:
+  char* getReturnPos();
+
+  Buffer* stack;
+};
+
+
+#endif
+  
+  
diff --git a/mpeglib/example/yaf/yafcore/multiReader.cpp b/mpeglib/example/yaf/yafcore/multiReader.cpp
new file mode 100644
index 00000000..41a62263
--- /dev/null
+++ b/mpeglib/example/yaf/yafcore/multiReader.cpp
@@ -0,0 +1,206 @@
+/*
+  This class can waits for input on different istreams
+  Copyright (C) 1998  Martin Vogt
+
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of the GNU Library General Public License as published by
+  the Free Software Foundation.
+
+  For more information look at the file COPYRIGHT in this package
+
+ */
+
+
+
+#include "multiReader.h"
+
+
+
+MultiReader::MultiReader() {
+  int i;
+
+  buffer=new Buffer(201);
+  for(i=0;i<_MAX_INPUT;i++) {
+    lineInputArray[i]=new LineInput;
+    lineInputArray[i]->tmpLineStack=new LineStack();
+    lineInputArray[i]->empty=true;
+  }
+  script=new LineStack();
+}
+
+
+
+MultiReader::~MultiReader() {
+  int i;
+  for(i=0;i<_MAX_INPUT;i++) {
+    delete lineInputArray[i]->tmpLineStack;
+    delete lineInputArray[i];
+  }
+  delete script;
+}
+
+
+
+int MultiReader::add(int fd) {
+  int nPos;
+  nPos=getEmptySlot();
+  
+  if (nPos == -1) {
+    return -1;
+  }
+  lineInputArray[nPos]->fd=fd;
+  lineInputArray[nPos]->empty=false;
+  return nPos;
+}
+
+void MultiReader::add(LineStack* aScript) {
+  script->appendBottom(aScript);
+}
+
+
+void MultiReader::add(Buffer* aScript) {
+  script->appendBottom(aScript->getData(),aScript->len());
+}
+
+
+
+
+void MultiReader::remove (int fd) {
+  int nPos;
+  nPos=getSlot(fd);
+  
+  if (nPos == -1) {
+    return ;
+  }
+  lineInputArray[nPos]->empty=true;
+}
+
+
+
+void MultiReader::waitForLine() {
+  while(hasLine() == false) {
+    doSelect(NULL);
+  }
+}
+
+
+void MultiReader::poll(struct timeval* timeout) {
+  doSelect(timeout);
+}
+
+
+
+void MultiReader::doSelect(struct timeval* timeout) {
+  int i;
+  int ret;
+  fd_set readfds;
+  int nBytes;
+  int maxFd=0;
+
+  FD_ZERO(&readfds);
+  for(i=0;i<_MAX_INPUT;i++) {
+    if (lineInputArray[i]->empty == false) {
+      FD_SET(lineInputArray[i]->fd,&readfds);
+      if (lineInputArray[i]->fd > maxFd) {
+	maxFd=lineInputArray[i]->fd;
+      }
+    }
+  } 
+  ret=select(maxFd+1,&readfds,NULL,NULL,timeout);
+  if (ret < 0) {
+    if (errno < 0) {
+      perror("nach select multireader:");
+      exit(0);
+    }
+  }
+  if (ret == 0) return;
+  
+  for(i=0;i<_MAX_INPUT;i++) {
+    if (lineInputArray[i]->empty == false) {
+      if (FD_ISSET(lineInputArray[i]->fd,&readfds)) {
+	nBytes=read(lineInputArray[i]->fd,buffer->getData(),200);
+	if (nBytes == 0) {
+	  perror("MultiReader:read error!");
+	  exit(-1);
+	}
+	(buffer->getData())[nBytes]='\0';
+	
+	lineInputArray[i]->tmpLineStack->appendBottom(buffer->getData(),
+						      nBytes);
+	FD_CLR(lineInputArray[i]->fd,&readfds);
+      }
+    }
+  } 
+} 
+
+
+
+int MultiReader::hasLine() {
+  int i;
+  LineStack* lineStack;        // owned by class
+  
+  if (script->hasLine() == true) {
+    return true;
+  }
+
+  for(i=0;i<_MAX_INPUT;i++) {
+    if (lineInputArray[i]->empty == false) {
+      lineStack=lineInputArray[i]->tmpLineStack;
+      if (lineStack->hasLine()) {
+	return true;
+      }
+    }
+  } 
+  return false;
+}
+
+
+void MultiReader::getLine(Buffer* buffer) {
+  int i;
+  LineStack* lineStack;        // owned by class
+  buffer->clear();
+
+  if (script->hasLine()==true) {
+    script->nextLine(buffer);
+  } else {
+    for(i=0;i<_MAX_INPUT;i++) {
+      if (lineInputArray[i]->empty == false) {
+	lineStack=lineInputArray[i]->tmpLineStack;
+	
+	if (lineStack->hasLine()) {
+	  lineStack->nextLine(buffer);
+	  return;
+	}
+      }
+    } 
+  }
+  buffer->append("\n");
+}
+
+
+
+
+int MultiReader::getEmptySlot() {
+  int i;
+
+  for(i=0;i<_MAX_INPUT;i++) {
+    if (lineInputArray[i]->empty == true) {
+      return i;
+    }
+  }
+  return -1;  
+}
+
+
+int MultiReader::getSlot(int fd) {
+  int i;
+
+  for(i=0;i<_MAX_INPUT;i++) {
+    if (lineInputArray[i]->empty == false) {
+      if (lineInputArray[i]->fd == fd) {
+	return i;
+      }
+    }
+  }
+  return -1;
+}
diff --git a/mpeglib/example/yaf/yafcore/multiReader.h b/mpeglib/example/yaf/yafcore/multiReader.h
new file mode 100644
index 00000000..79f7dd8b
--- /dev/null
+++ b/mpeglib/example/yaf/yafcore/multiReader.h
@@ -0,0 +1,88 @@
+/*
+  This class can waits for input on different istreams
+  Copyright (C) 1998  Martin Vogt
+
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of the GNU Library General Public License as published by
+  the Free Software Foundation.
+
+  For more information look at the file COPYRIGHT in this package
+
+ */
+
+
+
+
+#ifndef __MULTIREADER_H
+#define __MULTIREADER_H
+
+#include "lineStack.h"
+#include "buffer.h"
+
+extern "C" {
+#include <sys/time.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <errno.h>
+#include <strings.h>
+#include <string.h>
+	   }
+
+/**
+ The purpose of this class is to have a thread safe input method
+ for yaf command.
+ <p>
+ Sometime the decoder thread must send data to the control thread.
+ E.g. the Stream has ended. The decoder thread must inform the
+ control thread that the player should go into the "off" state.
+ A direct call is not thread safe and this is why the decoder
+ thread must use this class. For the control thread it looks
+ like the user has typed "off".
+
+*/
+
+#define _MAX_INPUT 5
+
+typedef struct {
+  LineStack* tmpLineStack;        // owned by class
+  int fd;                         // filedescriptor for input              
+  int empty;
+} LineInput;
+
+
+class MultiReader {
+
+  Buffer* buffer;
+  LineInput* lineInputArray[_MAX_INPUT];
+  LineStack* script;
+
+ public:
+  MultiReader();
+  ~MultiReader();
+
+  int add(int fd);
+  void add(LineStack* aScript);
+  void add(Buffer* aScript);
+  void remove (int fd);
+
+  void waitForLine();
+  void poll(struct timeval* timeout);
+
+  int hasLine();
+  void getLine(Buffer* buffer);
+
+ private:
+
+  void doSelect(struct timeval *timeout);
+
+  int getEmptySlot();
+  int getSlot(int fd);
+  
+
+};
+
+
+
+
+
+#endif
diff --git a/mpeglib/example/yaf/yafcore/outputDecoder.cpp b/mpeglib/example/yaf/yafcore/outputDecoder.cpp
new file mode 100644
index 00000000..0993add0
--- /dev/null
+++ b/mpeglib/example/yaf/yafcore/outputDecoder.cpp
@@ -0,0 +1,144 @@
+/*
+  Default output decoder
+  Copyright (C) 1998  Martin Vogt
+
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of the GNU Library General Public License as published by
+  the Free Software Foundation.
+
+  For more information look at the file COPYRIGHT in this package
+
+ */
+
+#include "outputDecoder.h"
+#include <iostream>
+
+using namespace std;
+
+#define DEBUG cout << "Command:1 Msg:"
+
+
+OutputDecoder::OutputDecoder() {
+  yafCommands=new CommandTableYAF();
+  yafRuntime=new RuntimeTableYAF();
+
+  appendCommandTable(yafCommands);
+  appendRuntimeTable(yafRuntime);
+  
+}
+
+
+
+OutputDecoder::~OutputDecoder() {
+  delete yafCommands;
+  delete yafRuntime;
+}
+
+
+
+void OutputDecoder::appendCommandTable(CommandTable* table) {
+  commandTable.join(table);
+}
+
+
+void OutputDecoder::appendRuntimeTable(CommandTable* table) {
+  runtimeTable.join(table);
+}
+
+
+
+CommandTable* OutputDecoder::getCommandTable() {
+  return &commandTable;
+}
+
+
+CommandTable* OutputDecoder::getRuntimeTable() {
+  return &runtimeTable;
+}
+
+
+
+
+void OutputDecoder::processCommandLine(CommandLine* commandLine){
+  CommandTable* ct=&commandTable;  // ct , rt are shorter..
+  CommandTable* rt=&runtimeTable;
+
+  
+  int command;
+  int commandNr;
+  const char* commandStr;
+  const char* retString;
+  const char* args;
+
+
+  // The number of the command (unique for every command)
+  commandNr=atoi(commandLine->getValue(0));
+
+  // if commandNr is greater zero then we have a return command from decoder
+  if (commandNr >= 40) {
+
+    // the command (longName or shortName )
+    commandStr=ct->getCommand(commandLine->getValue(2));
+    // the int value of the command (faster for compare)
+    command=ct->getNr(commandStr);
+
+    // the Arguments of the command
+    args=ct->getArgs(commandStr,commandLine->getValue(2));
+    retString=commandLine->getValue(1);
+    
+    processReturnCommand(commandNr,command,retString,args);
+    return;
+  }
+
+  // if commandNr < 40 then we have a runtime command from decoder
+
+  if (commandNr < 40) {
+    // the command (longName or shortName )
+    commandStr=rt->getCommand(commandLine->getValue(1));
+    // the int value of the command (faster for compare)
+    command=rt->getNr(commandStr);
+
+    // here I make a hack because it cannot be expected
+    // that during debugging every debug-info has its clean
+    // installed debug-identifer.
+    // hack:
+    // if the commandNr==1 (debug) and we have NO defined
+    // debug identifier then we do not send -1 (as in all other case)
+    // but the number 1 itsself.
+    
+    if ((commandNr == 1) && (command == -1)) {
+     args=rt->getArgs(commandStr,commandLine->getValue(1));
+     processRuntimeCommand(1,args);
+     return;
+    }
+
+    // in *all* other cases the developer should
+    // implement a clean protokoll with identifiers
+    // (this leads to well defined interfaces :-)
+
+    // the Arguments of the command
+    args=rt->getArgs(commandStr,commandLine->getValue(1));
+    
+    processRuntimeCommand(command,args);
+    return;
+  }
+
+
+}
+
+
+
+int OutputDecoder::processRuntimeCommand(int command,const char* args){
+  cout << command <<" * "<< args <<" * "<< endl;
+  return false;
+}
+
+int OutputDecoder::processReturnCommand(int cmdNr,int cmdId,
+					const char* ret,const char* args){
+  cout << cmdNr <<" * "<< cmdId<<" * "<< ret<<" * " << args << endl;
+  return false;
+}
+
+
+
+
diff --git a/mpeglib/example/yaf/yafcore/outputDecoder.h b/mpeglib/example/yaf/yafcore/outputDecoder.h
new file mode 100644
index 00000000..1448258b
--- /dev/null
+++ b/mpeglib/example/yaf/yafcore/outputDecoder.h
@@ -0,0 +1,52 @@
+/*
+  Default output decoder
+  Copyright (C) 1998  Martin Vogt
+
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of the GNU Library General Public License as published by
+  the Free Software Foundation.
+
+  For more information look at the file COPYRIGHT in this package
+
+ */
+
+
+
+#ifndef __OUTPUTDECODER_H
+#define __OUTPUTDECODER_H
+
+#include "commandLine.h"
+
+#include "runtimeTableYAF.h"
+#include "commandTableYAF.h"
+
+
+class OutputDecoder  {
+
+ public:
+  OutputDecoder();
+  virtual ~OutputDecoder();
+
+  void processCommandLine(CommandLine*);
+  virtual int processRuntimeCommand(int command,const char* args);
+  virtual int processReturnCommand(int cmdNr,int cmdId,
+				   const char* ret,const char* args);
+
+  void appendCommandTable(CommandTable* table);
+  void appendRuntimeTable(CommandTable* table);
+
+  CommandTable* getRuntimeTable();
+  CommandTable* getCommandTable();
+
+ private:
+  CommandTable* yafCommands;
+  CommandTable* yafRuntime;
+
+  CommandTable commandTable;
+  CommandTable runtimeTable;
+
+
+};
+
+
+#endif
diff --git a/mpeglib/example/yaf/yafcore/outputInterface.cpp b/mpeglib/example/yaf/yafcore/outputInterface.cpp
new file mode 100644
index 00000000..b57563fd
--- /dev/null
+++ b/mpeglib/example/yaf/yafcore/outputInterface.cpp
@@ -0,0 +1,85 @@
+/*
+  This class sends an output to the outputstream
+  Copyright (C) 1998  Martin Vogt
+
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of the GNU Library General Public License as published by
+  the Free Software Foundation.
+
+  For more information look at the file COPYRIGHT in this package
+
+ */
+
+
+
+#include "outputInterface.h"
+#include <iostream>
+
+using namespace std;
+
+OutputInterface::OutputInterface(ostream* out) {
+  protocolSyntax=false;
+  this->out=out;
+  outBuffer=new Buffer(250);
+  setlinebuf(stdout);
+  pthread_mutex_init(&writeOutMut,NULL);
+}
+
+
+OutputInterface::~OutputInterface() {
+  delete outBuffer;
+}
+
+void OutputInterface::flushBuffer() {
+  if (protocolSyntax) {
+    (*out) << outBuffer->getData() << endl;
+#ifdef _DEBUG_OUTPUT
+  ofstream outfile("outstream.dbg",ios::app);
+  outfile << outBuffer->getData() << endl;
+  outfile.flush();
+  outfile.close();
+#endif
+  return;
+  } else {
+    (*out) << "Command:" << nr << " Msg:" << outBuffer->getData() << endl;
+#ifdef _DEBUG_OUTPUT
+  ofstream outfile("outstream.dbg",ios::app);
+  outfile <<  "Command:" << nr << " Msg:" << outBuffer->getData() << endl;
+  outfile.flush();
+  outfile.close();
+#endif
+  }
+  fflush(NULL);
+}
+
+
+
+void OutputInterface::setProtocolSyntax(int proto) {
+  protocolSyntax=proto;
+}
+
+
+void OutputInterface::setNr(int nr) {
+  this->nr=nr;
+}
+
+void OutputInterface::clearBuffer() {
+  outBuffer->clear();
+}
+
+
+void OutputInterface::appendBuffer(const char* msg) {
+  outBuffer->append(msg);
+}
+
+
+
+void OutputInterface::lock() {
+  pthread_mutex_lock(&writeOutMut);
+}
+
+
+void OutputInterface::unlock() {
+  pthread_mutex_unlock(&writeOutMut);
+}
+
diff --git a/mpeglib/example/yaf/yafcore/outputInterface.h b/mpeglib/example/yaf/yafcore/outputInterface.h
new file mode 100644
index 00000000..0a24fd92
--- /dev/null
+++ b/mpeglib/example/yaf/yafcore/outputInterface.h
@@ -0,0 +1,60 @@
+/*
+  This class sends an output to the outputstream
+  Copyright (C) 1998  Martin Vogt
+
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of the GNU Library General Public License as published by
+  the Free Software Foundation.
+
+  For more information look at the file COPYRIGHT in this package
+
+ */
+
+
+
+
+
+
+#ifndef __OUTPUTINTERFACE_H
+#define __OUTPUTINTERFACE_H
+
+#include <pthread.h>
+#include <fstream>
+#include "buffer.h"
+#include <kdemacros.h>
+
+// uncomment this for debugging the output stream
+// (written to file outstream.dbg)
+//#define _DEBUG_OUTPUT
+
+
+class KDE_EXPORT OutputInterface {
+
+  int protocolSyntax;
+  int nr;
+  Buffer* outBuffer;
+  std::ostream* out;
+  pthread_mutex_t writeOutMut;
+
+
+ public:
+
+  OutputInterface(std::ostream* out);
+  ~OutputInterface();
+
+
+  void flushBuffer();
+  void setProtocolSyntax(int proto);
+  void setNr(int nr);
+  void clearBuffer();
+  void appendBuffer(const char* msg);
+
+  // make this interface threadsafe
+  void lock();
+  void unlock();
+
+};
+
+
+
+#endif
diff --git a/mpeglib/example/yaf/yafcore/parser.cpp b/mpeglib/example/yaf/yafcore/parser.cpp
new file mode 100644
index 00000000..21b27c6b
--- /dev/null
+++ b/mpeglib/example/yaf/yafcore/parser.cpp
@@ -0,0 +1,152 @@
+/*
+  Checks if a valid Command Line is avaiable
+  Copyright (C) 1998  Martin Vogt
+
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of the GNU Library General Public License as published by
+  the Free Software Foundation.
+
+  For more information look at the file COPYRIGHT in this package
+
+ */
+
+
+#include "parser.h"
+
+
+Parser::Parser() {
+  commandLine=new CommandLine();
+  parseString=new Buffer(200);
+}
+
+
+Parser::~Parser() {
+  delete commandLine;
+  delete parseString;
+}
+
+void Parser::setParseString(char* parseString){
+  (this->parseString)->setData(parseString);
+  // clear everything in commandline
+  commandLine->clear();
+}
+
+void Parser::parse() {
+  int commandCounter=0;
+  
+  parse(parseString->getData(),&commandCounter);
+  commandLine->setCommandCount(commandCounter);
+}
+
+
+void Parser::parse(char* strStart,int* nCommand){
+  char* doppelPkt;
+  char* current;
+  char* space;
+
+  if (strlen(strStart) == 0) return;
+
+  doppelPkt=strchr(strStart,':');
+  if (doppelPkt == NULL) return;
+  (*doppelPkt)='\0';
+  commandLine->setIdentifier(*nCommand,strStart);
+  strStart=++doppelPkt;
+  current=strStart;
+
+  // Now two possibilities:
+  // a command with Msg : means the rest ist the value
+  // a command different from Msg means: further processing
+
+  if (strcmp("Msg",commandLine->getIdentifier(*nCommand)) == 0) {
+    commandLine->setValue((*nCommand),current);
+    (*nCommand)++;
+    return;
+  }
+
+  // Now two possibilities:
+  // a command with "Ret:" means string until the the ")" is the value
+  // a command different from "Ret:" means: the string until the first space
+  //                                        ist the value
+  if (strcmp("Ret",commandLine->getIdentifier(*nCommand)) == 0) {
+    char* seperator;
+    seperator=strchr(current,')');
+    if (seperator == NULL) {
+      commandLine->setValue((*nCommand),current);
+      (*nCommand)++;
+      return;
+    } else {
+      (*seperator)='\0';
+      current++;
+      commandLine->setValue((*nCommand),current);
+      (*nCommand)++;    
+      seperator++;  
+      if (strlen(seperator) == 0) return;
+      parse(++seperator,&(*nCommand));
+      return;
+    }
+  }
+ 
+  space=strchr(current,' ');
+  if (space == NULL) {
+    commandLine->setValue((*nCommand),current);
+    (*nCommand)++;
+    return;
+  }    
+  (*space)='\0';
+  commandLine->setValue((*nCommand),current);
+  parse(++space,&(++(*nCommand)));
+}
+
+
+  
+
+int Parser::isOK(){
+  // a Commandline ist valid when it contains :
+
+  // * 2 * (identifer/value)
+  // * first identifier ist "Command"
+  // * second identifier is "Msg"
+  
+
+  // or:
+  // 3 identifier
+  // first: "Command"
+  // second "Ret"
+  // third: "Msg"
+
+  if (commandLine->getCommandCount() == 2){
+    if (strcmp("Command",commandLine->getIdentifier(0)) != 0) return 0;
+    if (strcmp("Msg",commandLine->getIdentifier(1)) != 0) return 0;
+    return 1;
+  }
+
+  if (commandLine->getCommandCount() == 3){
+    if (strcmp("Command",commandLine->getIdentifier(0)) != 0) return 0;
+    if (strcmp("Ret",commandLine->getIdentifier(1)) != 0) return 0;
+    if (strcmp("Msg",commandLine->getIdentifier(2)) != 0) return 0;
+    return 1;
+  }
+ 
+  return 0;
+}
+  
+CommandLine* Parser::getCommandLine(){
+  return commandLine;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/mpeglib/example/yaf/yafcore/parser.h b/mpeglib/example/yaf/yafcore/parser.h
new file mode 100644
index 00000000..d9c46211
--- /dev/null
+++ b/mpeglib/example/yaf/yafcore/parser.h
@@ -0,0 +1,55 @@
+/*
+  Checks if a valid Command Line is avaiable
+  Copyright (C) 1998  Martin Vogt
+
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of the GNU Library General Public License as published by
+  the Free Software Foundation.
+
+  For more information look at the file COPYRIGHT in this package
+
+ */
+
+
+
+
+
+#ifndef __PARSER_H
+#define __PARSER_H
+
+#include "buffer.h"
+#include "commandLine.h"
+
+extern "C" {
+#include <string.h>
+	   }
+
+class Parser {
+  
+
+  Buffer* parseString;
+  CommandLine* commandLine;
+
+ public:
+
+  Parser();
+  ~Parser();
+
+  void setParseString(char* parseString);
+  void parse();
+  int isOK();
+  CommandLine* getCommandLine();
+  
+
+ private:
+  void parse(char* currentPos,int* nCommand);
+
+};
+
+
+#endif
+
+
+
+
+
diff --git a/mpeglib/example/yaf/yafcore/runtimeTableYAF.cpp b/mpeglib/example/yaf/yafcore/runtimeTableYAF.cpp
new file mode 100644
index 00000000..987c10ae
--- /dev/null
+++ b/mpeglib/example/yaf/yafcore/runtimeTableYAF.cpp
@@ -0,0 +1,34 @@
+/*
+  basic runtime command (fits for every decoder)
+  Copyright (C) 1998  Martin Vogt
+
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of the GNU Library General Public License as published by
+  the Free Software Foundation.
+
+  For more information look at the file COPYRIGHT in this package
+
+ */
+
+
+#define _USE_RUNTIME_YAF_STRUC
+
+#include "runtimeTableYAF.h"
+
+
+RuntimeTableYAF::RuntimeTableYAF(){
+  init();
+}
+
+RuntimeTableYAF::~RuntimeTableYAF(){
+}
+
+void RuntimeTableYAF::init() {
+
+  int i;
+  for (i=0;i<YAFRUNTIME_SIZE;i++) {
+    insert(&yafRuntime[i]);
+  }
+
+}
+
diff --git a/mpeglib/example/yaf/yafcore/runtimeTableYAF.h b/mpeglib/example/yaf/yafcore/runtimeTableYAF.h
new file mode 100644
index 00000000..6a77467a
--- /dev/null
+++ b/mpeglib/example/yaf/yafcore/runtimeTableYAF.h
@@ -0,0 +1,35 @@
+/*
+  basic runtime command (fits for every decoder)
+  Copyright (C) 1998  Martin Vogt
+
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of the GNU Library General Public License as published by
+  the Free Software Foundation.
+
+  For more information look at the file COPYRIGHT in this package
+
+ */
+
+
+
+#ifndef __RUNTIME_TABLEYAF_H
+#define __RUNTIME_TABLEYAF_H
+
+#include "commandTable.h"
+#include "yafRuntime.defs"
+
+
+
+
+class RuntimeTableYAF : public CommandTable {
+
+ public:
+  RuntimeTableYAF();
+  ~RuntimeTableYAF();
+  void init();
+
+};
+
+#endif
+
+
diff --git a/mpeglib/example/yaf/yafcore/yafCommand.defs b/mpeglib/example/yaf/yafcore/yafCommand.defs
new file mode 100644
index 00000000..ab2559df
--- /dev/null
+++ b/mpeglib/example/yaf/yafcore/yafCommand.defs
@@ -0,0 +1,89 @@
+/*
+  definition file for basic yaf commands
+  Copyright (C) 1998  Martin Vogt
+
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of the GNU Library General Public License as published by
+  the Free Software Foundation.
+
+  For more information look at the file COPYRIGHT in this package
+
+ */
+
+
+
+
+#ifndef __YAF_COMMAND_DEFS
+#define __YAF_COMMAND_DEFS
+
+#include "commandTable.h"   // defines CommandDesc-Struct...
+
+// Command Numbers
+
+#define _YAF_I_COMMAND 		1			
+#define _YAF_I_MSG     		2
+#define _YAF_I_HELP    		3
+#define _YAF_I_RUNTIME 		4
+#define _YAF_I_QUIT    		5
+#define _YAF_I_PING    		6
+#define _YAF_I_PROTOCOL		7
+#define _YAF_I_NOPROTOCOL	8
+#define _YAF_I_WHATIS		9
+#define _YAF_I_SELECT_A_LAYER   10
+#define _YAF_I_SELECT_V_LAYER   11
+#define _YAF_I_PLAYTIME		12
+#define _YAF_I_WRITE		13
+
+
+
+
+
+
+
+
+#define _YAF_START 40
+
+
+
+// The commands as String. The Syntax is :
+// 
+
+//  { lexternalUse,lReturnMsg,longName,shortName,number,helpText }
+// 
+// lexternal use ist true when the text should be written when 
+// user enters "help"
+
+
+#ifdef _USE_YAF_STRUC
+
+static struct CommandDescriptionStruct yafCommands[]={
+
+  {0,1,"Command","",_YAF_I_COMMAND,"internal identifier"},
+  {0,1,"Msg","",_YAF_I_MSG,"identifier for unstructured String"},
+  {1,1,"help","h",_YAF_I_HELP,"show this help"},
+  {1,1,"ping","",_YAF_I_PING,"command tests if client is alive"},
+  {1,1,"runtime","r",_YAF_I_RUNTIME,"runtime [on|off] shows runtime infos"},
+  {1,1,"protocol","",_YAF_I_NOPROTOCOL,"internal protocol wrapper on [def]"},
+  {1,1,"noprotocol","",_YAF_I_PROTOCOL,"internal protocol wrapper off"},
+  {1,1,"whatis" ,"",_YAF_I_WHATIS,"gives a short introduction" },
+  {1,1,"audioLayer","", _YAF_I_SELECT_A_LAYER,
+	"selects audio layer from stream [0..31]"},
+  {1,1,"videoLayer" ,"", _YAF_I_SELECT_V_LAYER,
+	"selects video layer from stream [0..15]" },
+  {1,1,"playtime","", _YAF_I_PLAYTIME,
+  	"retrives the current playtime" },
+  {1,1,"write","", _YAF_I_WRITE,
+  	"writes stream to disk [on|off] default[off]" },
+  {1,1,"quit","q",_YAF_I_QUIT,"ends program"}
+
+};
+#endif
+
+
+// How much Commands are in the Array :
+#define YAFCOMMANDS_SIZE 13
+
+
+
+#endif
+
diff --git a/mpeglib/example/yaf/yafcore/yafRuntime.defs b/mpeglib/example/yaf/yafcore/yafRuntime.defs
new file mode 100644
index 00000000..2918d178
--- /dev/null
+++ b/mpeglib/example/yaf/yafcore/yafRuntime.defs
@@ -0,0 +1,67 @@
+/*
+  basic Runtime definitions for yaf
+  Copyright (C) 1998  Martin Vogt
+
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of the GNU Library General Public License as published by
+  the Free Software Foundation.
+
+  For more information look at the file COPYRIGHT in this package
+
+ */
+
+
+
+
+#ifndef __YAF_RUNTIME_DEFS
+#define __YAF_RUNTIME_DEFS
+
+#include "../yafcore/commandTable.h"   // defines CommandDesc-Struct...
+
+// Command Numbers
+
+// define the YAF debug -its not a real command, but I know 
+// what I'm doing (see: outputDecoder.cpp)
+
+#define _YAF_DEBUG              1  
+
+
+// For all other commands use the following schema:
+
+#define _YAF_RUN_COMMENT       	_CT_START+1
+#define _YAF_RUN_DECODER       	_CT_START+2
+#define _YAF_RUN_PROTOCOL      	_CT_START+3
+#define _YAF_RUN_IMPLEMENTS     _CT_START+4
+#define _YAF_RUN_EXIT           _CT_START+5
+
+
+#define _YAF_RUN_START		_CT_START+100 
+
+
+
+// The commands as String. The Syntax is :
+// 
+
+//  { lexternalUse,lReturnMsg,longName,shortName,number,helpText }
+// 
+// lexternal use ist true when the text should be written when 
+// user enters "help"
+#ifdef _USE_RUNTIME_YAF_STRUC
+static struct CommandDescriptionStruct yafRuntime[]={
+
+  { 0,1,"comment","",_YAF_RUN_COMMENT,"commands  should not be interpreted"},
+  { 0,1,"decoder", "",_YAF_RUN_DECODER, "Name of decoder"},
+  { 0,1,"implements", "",_YAF_RUN_IMPLEMENTS, "basic behaviour"},
+  { 0,1,"exit", "",_YAF_RUN_EXIT, "yaf protocol terminated"},
+  { 0,1,"protocol", "",_YAF_RUN_PROTOCOL, "yaf protocol version"}
+
+};
+#endif
+
+// How much Commands are in the Array :
+#define YAFRUNTIME_SIZE 5
+
+
+
+#endif
+
diff --git a/mpeglib/example/yaf/yafcore/yaf_control.cpp b/mpeglib/example/yaf/yafcore/yaf_control.cpp
new file mode 100644
index 00000000..6e789588
--- /dev/null
+++ b/mpeglib/example/yaf/yafcore/yaf_control.cpp
@@ -0,0 +1,81 @@
+/*
+  generic interactive controller 
+  Copyright (C) 1998  Martin Vogt
+
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of the GNU Library General Public License as published by
+  the Free Software Foundation.
+
+  For more information look at the file COPYRIGHT in this package
+
+ */
+
+
+
+#include "yaf_control.h"
+#include "parser.h"
+#include <iostream>
+
+using namespace std;
+
+
+void yaf_control(InputInterface* input,
+		 OutputInterface* output,
+		 InputDecoder* decoder) {
+
+  Parser parser;
+  CommandLine* commandLine;
+  struct timeval timeout;
+  const char* retCode;
+  int status;
+  
+  timeout.tv_sec=0;
+  timeout.tv_usec=0;
+
+  output->setProtocolSyntax(true);  // we send "raw" protocol data
+  input->addFileDescriptor(0);
+ 
+  while(1) {
+
+    status=decoder->getDecoderStatus();
+
+    if (status == _DECODER_STATUS_EXIT) {
+      break;
+    }
+    input->waitForLine();
+    
+    if (input->hasLine()) {
+      parser.setParseString(input->getLine());
+      parser.parse();
+      
+      if (parser.isOK()){
+
+		
+	commandLine=parser.getCommandLine();
+
+	decoder->processCommandLine(commandLine);
+	retCode=decoder->getReturnCode();
+
+	// now get the part after Msg: (in the inputLine)
+
+	output->lock();
+	output->clearBuffer();
+	output->appendBuffer(retCode);
+	output->flushBuffer();
+	output->unlock();
+      } else {
+	cout << "Error parsing input:"<<input->getLine()<<endl;
+      }
+
+      input->clearLine();
+    } else {
+      cout << "no line"<<endl;
+    }
+  }
+  input->removeFileDescriptor(0);
+
+}
+
+
+
+
diff --git a/mpeglib/example/yaf/yafcore/yaf_control.h b/mpeglib/example/yaf/yafcore/yaf_control.h
new file mode 100644
index 00000000..890a1bb8
--- /dev/null
+++ b/mpeglib/example/yaf/yafcore/yaf_control.h
@@ -0,0 +1,26 @@
+ 
+
+#ifndef __YAF_CONTROL_H
+#define __YAF_CONTROL_H
+
+
+
+#include "inputInterface.h"
+#include "outputInterface.h"
+#include "inputDecoder.h"
+
+#include <sys/time.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <kdemacros.h>
+
+
+// prototypes
+
+//extern "C" void control_xplayer();
+KDE_EXPORT void yaf_control(InputInterface* input,
+		 OutputInterface* output,
+		 InputDecoder* decoder);
+
+#endif
diff --git a/mpeglib/example/yaf/yafmpgplay/Makefile.am b/mpeglib/example/yaf/yafmpgplay/Makefile.am
new file mode 100644
index 00000000..c9fd9b55
--- /dev/null
+++ b/mpeglib/example/yaf/yafmpgplay/Makefile.am
@@ -0,0 +1,34 @@
+#  mpegplay-yaf - Makefile.am
+
+INCLUDES		=	-I../../include $(all_includes)
+
+EXTRA_DIST		=	stresstest
+
+bin_PROGRAMS		=	yaf-mpgplay
+
+yaf_mpgplay_SOURCES	=	mpg_control.cpp
+
+noinst_HEADERS		=	
+
+
+yaf_mpgplay_LDFLAGS	=	$(all_libraries) $(KDE_RPATH) 
+
+
+yaf_mpgplay_LDADD	=	../yafcore/libyafcore.la \
+				../yafxplayer/libyafxplayer.la \
+				../../../lib/libmpeg.la \
+				$(THIS_LIB_LIBS)
+
+
+
+
+				
+
+
+
+
+
+
+
+
+
diff --git a/mpeglib/example/yaf/yafmpgplay/mpg_control.cpp b/mpeglib/example/yaf/yafmpgplay/mpg_control.cpp
new file mode 100644
index 00000000..ee080a73
--- /dev/null
+++ b/mpeglib/example/yaf/yafmpgplay/mpg_control.cpp
@@ -0,0 +1,197 @@
+/*
+  generic interactive controller 
+  Copyright (C) 1998  Martin Vogt
+
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of the GNU Library General Public License as published by
+  the Free Software Foundation.
+
+  For more information look at the file COPYRIGHT in this package
+
+ */
+
+
+
+
+// Set for local include
+#define DIRECT_INCLUDE
+
+#include "../yafcore/yaf_control.h"
+#include "../yafxplayer/inputDecoderYAF.h"
+
+
+
+
+#include <iostream>
+using namespace std;
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+#if defined(HAVE_GETOPT_H) 
+#include <getopt.h>
+#endif
+
+// we include our plugin here
+#include "../../../lib/decoder/mpgPlugin.h"
+
+#if defined(HAVE_GETOPT_H) 
+#include <getopt.h>
+#endif
+
+
+                                          
+
+
+void control_mpgplay(InputInterface* input,OutputInterface* output,
+		   InputDecoder* decoder) {
+
+
+  cout<< "Command:0 Msg:protocol yaf-0.1" << endl;
+  cout<< "Command:0 Msg:implements xplayer" << endl;
+  cout<< "Command:0 Msg:decoder splay Version:0.8.2" << endl;
+  cout<< "Command:0 Msg:decoder mpeg_play Version:2.4.0" << endl;
+  cout<< "Command:0 Msg:mimetypes video/mpeg;" << endl;
+  cout<< "Command:0 Msg:comment splay by Woo-jae Jung" << endl;
+  cout<< "Command:0 Msg:comment mpeg_play by University of California" << endl;
+  cout<< "Command:0 Msg:comment yaf port by [email protected]"<<endl;
+  cout<< "Command:0 Msg:comment based on sources from mpeg_play and splay"<<endl;
+  cout<< "Command:0 Msg:comment enter 'help' " << endl;
+ 
+
+  
+ 
+  
+  yaf_control(input,output,decoder);
+}
+
+
+void usage() {
+  cout << "yaf-mpgplay is a interactive frontend for the mpeg I decoder"<<endl;
+  cout << "Usage : yaf-mpgplay [2al:L:scb:mhpywd:] [url]"<<endl;
+  cout << endl;
+  cout << "-2 : playing with half frequency."<<endl;
+  cout << "-m : force to mono."<<endl;
+  cout << "-a : no internal audio device"<<endl;
+  cout << "-c : no time calculation"<<endl;
+  cout << "-s : no audio/video sync"<<endl;
+  cout << "-b : audio buffer delay (bytes)[65535 byte]"<<endl;
+  cout << "-p : measure performance (audio is decoded, but not played)"<<endl;
+  cout << "-l : select audio Layer [0]"<<endl;
+  cout << "-L : select video Layer [0]"<<endl;
+  cout << "-w : write streams to disk [demultiplex]"<<endl;
+  cout << "-y : autoplay off"<<endl;
+  cout << "-d : [1..2] dump yuv images 1: single images 2: as stream"<<endl;
+  cout << endl;
+  cout << "THIS SOFTWARE COMES WITH ABSOLUTELY NO WARRANTY! " \
+       << "USE AT YOUR OWN RISK!"<<endl;
+  cout << endl;
+  cout << "for more help type 'help' in interactive mode"<<endl;
+}
+
+
+
+
+int main(int argc, char** argv) {
+  int c;
+  int lInternalAudio=true;
+
+  pow(6.0,3.0);            // fixes bug in __math.h
+  InputInterface input;
+  OutputInterface output(&cout);
+
+
+  
+
+
+  YafOutputStream* yafOutput=new YafOutputStream(&input);
+  MpgPlugin* plugin=new MpgPlugin();
+
+  plugin->setOutputPlugin(yafOutput);
+  InputDecoderYAF decoder(plugin,yafOutput);
+
+  
+
+  while(1) { 
+    c = getopt (argc, argv, "2al:L:scb:mhpywd:");
+    if (c == -1) break;
+    switch(c) {
+    case 'a': {    
+      lInternalAudio=false;
+      break;
+    }
+    case 'h': {
+      usage();
+      exit(0);
+    }
+    case 'y': {
+      decoder.setAutoPlay(false);
+      break;
+    }
+    case '2': {
+      plugin->config("-2","true",NULL);
+      break;
+    }
+    case 'm': {
+      plugin->config("-m","true",NULL);
+      break;
+    }
+    case 'c': {
+      plugin->config("-c","true",NULL);
+      break;
+    }
+    case 'w': {
+      plugin->config("-w","true",NULL);
+      break;
+    }
+    case 's': {
+      yafOutput->config("-s","true",NULL);
+      break;
+    }
+    case 'b': {
+      yafOutput->config("-b",optarg,NULL);
+      break;
+    }    
+    case 'd': {
+      yafOutput->config("yufDump",optarg,NULL);
+      break;
+    }    
+    case 'p': {
+      yafOutput->config("-p",optarg,NULL);
+      break;
+    }    
+    case 'l': {
+      plugin->config("AudioLayer",optarg,NULL);
+      cout << "trying to configure" << endl;
+      break;
+    }
+    case 'L': {
+      plugin->config("VideoLayer",optarg,NULL);
+      break;
+    }
+
+
+    default:
+      printf ("?? getopt returned character code 0%o ??\n", c);
+      usage();
+      exit(-1);
+    }
+  }
+
+  if (optind < argc ) {
+    Buffer buffer(300);
+    buffer.append("open ");
+    buffer.append(argv[optind]);
+    buffer.append("\n");
+    input.addInputLine(&buffer);
+
+  }
+  yafOutput->internalDevice(lInternalAudio);
+  control_mpgplay(&input,&output,&decoder);
+  delete plugin;
+  delete yafOutput;
+
+}
+
+
diff --git a/mpeglib/example/yaf/yafmpgplay/stresstest b/mpeglib/example/yaf/yafmpgplay/stresstest
new file mode 100644
index 00000000..1d73ad92
--- /dev/null
+++ b/mpeglib/example/yaf/yafmpgplay/stresstest
@@ -0,0 +1,24 @@
+#!/bin/sh
+
+declare -i zahl=100
+declare -i zahl1=3
+rm -f jumptable
+echo "sleep 5" >>jumptable
+
+while [ 0 -le $zahl ] ; do 
+ echo "j $zahl" >>jumptable
+ echo "sleep 0" >>jumptable
+ echo "j $zahl1" >>jumptable
+ echo "sleep 0" >>jumptable
+
+ zahl=$[zahl-7]
+ zahl1=$[zahl1+7]
+done
+echo "sleep 20" >>jumptable
+echo "quit" >>jumptable
+
+for i in "/mnt/diskD/mpeg"/* ; do
+ echo "open $i" >yaf.script
+ ./yaf-mpgplay <jumptable
+ sleep 5
+done
diff --git a/mpeglib/example/yaf/yafsplay/Makefile.am b/mpeglib/example/yaf/yafsplay/Makefile.am
new file mode 100644
index 00000000..463ec7db
--- /dev/null
+++ b/mpeglib/example/yaf/yafsplay/Makefile.am
@@ -0,0 +1,35 @@
+#  splay-yaf - Makefile.am
+
+INCLUDES		=	-I../../include $(all_includes)
+
+EXTRA_DIST		=	stresstest
+
+bin_PROGRAMS		=	yaf-splay
+
+yaf_splay_SOURCES	=	splay_control.cpp
+
+
+noinst_HEADERS		=	
+
+yaf_splay_LDFLAGS	=	$(all_libraries) $(KDE_RPATH)
+
+
+yaf_splay_LDADD		=	../yafxplayer/libyafxplayer.la \
+				../yafcore/libyafcore.la \
+				../../../lib/libmpeg.la \
+				$(THIS_LIB_LIBS)
+
+
+
+
+
+				
+
+
+
+
+
+
+
+
+
diff --git a/mpeglib/example/yaf/yafsplay/splay_control.cpp b/mpeglib/example/yaf/yafsplay/splay_control.cpp
new file mode 100644
index 00000000..82be9c11
--- /dev/null
+++ b/mpeglib/example/yaf/yafsplay/splay_control.cpp
@@ -0,0 +1,161 @@
+/*
+  generic interactive controller 
+  Copyright (C) 1998  Martin Vogt
+
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of the GNU Library General Public License as published by
+  the Free Software Foundation.
+
+  For more information look at the file COPYRIGHT in this package
+
+ */
+
+
+
+// Set for local include
+#define DIRECT_INCLUDE
+
+#include "../yafcore/yaf_control.h"
+#include "../yafxplayer/inputDecoderYAF.h"
+
+#include <iostream>
+using namespace std;
+
+#include <math.h>
+
+
+
+// we include our plugin here
+#include "../../../lib/decoder/splayPlugin.h"
+
+#if defined(HAVE_GETOPT_H) 
+#include <getopt.h>
+#endif
+
+
+void control_splay(InputInterface* input,OutputInterface* output,
+		   InputDecoder* decoder) {
+
+
+  cout<< "Command:0 Msg:protocol yaf-0.1" << endl;
+  cout<< "Command:0 Msg:implements xplayer" << endl;
+  cout<< "Command:0 Msg:decoder splay Version:0.8.2" << endl;
+  cout<< "Command:0 Msg:mimetypes audio/mpg1;audio/mpg2;audio/mp3;" << endl;
+  cout<< "Command:0 Msg:comment splay by Woo-jae Jung" << endl;
+  cout<< "Command:0 Msg:comment yaf port by [email protected]"<<endl;
+  cout<< "Command:0 Msg:comment based on sources from eMusic and splay"<<endl;
+  cout<< "Command:0 Msg:comment enter 'help' " << endl;
+ 
+ 
+  
+  yaf_control(input,output,decoder);
+}
+
+
+void usage() {
+  cout << "yaf-splay is a interactive frontend for the splay decoder"<<endl;
+  cout << "Usage : yaf-splay [-2am] [url]"<<endl;
+  cout << endl;
+  cout << "-2 : playing with half frequency."<<endl;
+  cout << "-m : force to mono."<<endl;
+  cout << "-r : autoupdate musicinfo"<<endl;
+  cout << "-a : no internal audio device"<<endl;
+  cout << "-c : no time calculation"<<endl;
+  cout << "-y : autoplay off"<<endl;
+  cout << "-d : only decode"<<endl;
+  cout << endl;
+  cout << "THIS SOFTWARE COMES WITH ABSOLUTELY NO WARRANTY! " \
+       << "USE AT YOUR OWN RISK!"<<endl;
+  cout << endl;
+  cout << "for more help type 'help' in interactive mode"<<endl;
+}
+
+
+
+int main(int argc, char** argv) {
+  int c;
+  int lInternalAudio=true;
+
+
+  pow(6.0,3.0);            // fixes bug in __math.h
+
+
+
+  
+  InputInterface* input=new InputInterface();
+
+  OutputInterface output(&cout);
+
+  YafOutputStream* yafOutput=new YafOutputStream(input);
+
+
+  SplayPlugin* plugin=new SplayPlugin();
+
+  plugin->setOutputPlugin(yafOutput);
+  InputDecoderYAF decoder(plugin,yafOutput);
+  
+
+
+  while(1) { 
+    c = getopt (argc, argv, "2yamhd");
+    if (c == -1) break;
+    switch(c) {
+    case 'a': {    
+      lInternalAudio=false;
+      break;
+    }
+    case 'h': {
+      usage();
+      exit(0);
+    }
+    case '2': {
+      plugin->config("-2","true",NULL);
+      break;
+    }
+    case 'y': {
+      decoder.setAutoPlay(false);
+      break;
+    }
+    case 'm': {
+      plugin->config("-m","true",NULL);
+      break;
+    }
+    case 'r': {
+      plugin->config("runtime","on",NULL);
+      break;
+    }
+    case 'd': {
+      plugin->config("-d","on",NULL);
+      break;
+    }
+    case 'c': {
+      plugin->config("-c","true",NULL);
+      break;
+    }
+    default:
+      printf ("?? getopt returned character code 0%o ??\n", c);
+      usage();
+      exit(-1);
+    }
+  }
+  if (optind < argc ) {
+    Buffer buffer(300);
+    buffer.append("open ");
+    buffer.append(argv[optind]);
+    buffer.append("\n");
+    
+    input->addInputLine(&buffer);
+
+  }
+
+
+
+  yafOutput->internalDevice(lInternalAudio);
+  control_splay(input,&output,&decoder);
+  delete plugin;
+  delete yafOutput;
+  delete input;
+
+}
+
+
diff --git a/mpeglib/example/yaf/yafsplay/stresstest b/mpeglib/example/yaf/yafsplay/stresstest
new file mode 100644
index 00000000..caeba598
--- /dev/null
+++ b/mpeglib/example/yaf/yafsplay/stresstest
@@ -0,0 +1,23 @@
+#!/bin/sh
+
+declare -i zahl=150
+declare -i zahl1=3
+rm -f jumptable
+
+while [ 0 -le $zahl ] ; do 
+ echo "j $zahl" >>jumptable
+ echo "sleep 1" >>jumptable
+ echo "j $zahl1" >>jumptable
+ echo "sleep 1" >>jumptable
+
+ zahl=$[zahl-7]
+ zahl1=$[zahl1+7]
+done
+
+echo "quit" >>jumptable
+
+for i in "/mnt/diskD/rh/mp3/neu3"/* ; do
+ echo "open $i" >yaf.script
+ ./yaf-splay <jumptable
+ sleep 5
+done
diff --git a/mpeglib/example/yaf/yaftplay/Makefile.am b/mpeglib/example/yaf/yaftplay/Makefile.am
new file mode 100644
index 00000000..2d82700d
--- /dev/null
+++ b/mpeglib/example/yaf/yaftplay/Makefile.am
@@ -0,0 +1,32 @@
+#  tplay-yaf - Makefile.am
+
+INCLUDES		=	-I../../include $(all_includes)
+
+
+bin_PROGRAMS		=	yaf-tplay
+
+yaf_tplay_SOURCES	=	tplay_control.cpp
+
+noinst_HEADERS		=	
+
+yaf_tplay_LDFLAGS	=	$(all_libraries) $(KDE_RPATH)
+
+
+yaf_tplay_LDADD		=	../yafcore/libyafcore.la \
+				../yafxplayer/libyafxplayer.la \
+				../../../lib/libmpeg.la \
+				$(THIS_LIB_LIBS)
+
+
+
+
+				
+
+
+
+
+
+
+
+
+
diff --git a/mpeglib/example/yaf/yaftplay/tplay_control.cpp b/mpeglib/example/yaf/yaftplay/tplay_control.cpp
new file mode 100644
index 00000000..6203c727
--- /dev/null
+++ b/mpeglib/example/yaf/yaftplay/tplay_control.cpp
@@ -0,0 +1,135 @@
+/*
+  generic interactive controller 
+  Copyright (C) 1998  Martin Vogt
+
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of the GNU Library General Public License as published by
+  the Free Software Foundation.
+
+  For more information look at the file COPYRIGHT in this package
+
+ */
+
+
+
+// Set for local include
+#define DIRECT_INCLUDE
+
+#include "../yafcore/yaf_control.h"
+#include "../yafxplayer/inputDecoderYAF.h"
+
+#include <iostream>
+using namespace std;
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+
+// we include our plugin here
+#include "../../../lib/decoder/tplayPlugin.h"
+
+
+#if defined(HAVE_GETOPT_H) 
+#include <getopt.h>
+#endif
+
+   
+void control_tplay(InputInterface* input,OutputInterface* output,
+		   InputDecoder* decoder) {
+
+
+  cout<< "Command:0 Msg:protocol yaf-0.1" << endl;
+  cout<< "Command:0 Msg:implements xplayer" << endl;
+  cout<< "Command:0 Msg:decoder tplay Version:0.5.5" << endl;
+  cout<< "Command:0 Msg:mimetypes audio/wav;audio/au;" << endl;
+  cout<< "Command:0 Msg:comment tplay by Ilkka Karvinen" << endl;
+  cout<< "Command:0 Msg:comment yaf port by [email protected]"<<endl;
+  cout<< "Command:0 Msg:comment based on sources from eMusic and tplay"<<endl;
+  cout<< "Command:0 Msg:comment enter 'help' " << endl;
+ 
+
+  
+ 
+  
+  yaf_control(input,output,decoder);
+}
+
+
+void usage() {
+  cout << "yaf-tplay is a interactive frontend for the tplay decoder"<<endl;
+  cout << "Usage : yaf-tplay [-a] [url]"<<endl;
+  cout << endl;
+  cout << "-a : no internal audio device"<<endl;
+  cout << "-y : autoplay off"<<endl;
+  cout << endl;
+  cout << "THIS SOFTWARE COMES WITH ABSOLUTELY NO WARRANTY! " \
+       << "USE AT YOUR OWN RISK!"<<endl;
+  cout << endl;
+  cout << "for more help type 'help' in interactive mode"<<endl;
+}
+
+
+
+int main(int argc, char** argv) {
+  int c;
+  int lInternalAudio=true;
+
+  pow(6.0,3.0);            // fixes bug in __math.h
+  InputInterface input;
+  OutputInterface output(&cout);
+
+  
+
+
+
+  YafOutputStream* yafOutput=new YafOutputStream(&input);
+  TplayPlugin* plugin=new TplayPlugin();
+
+  plugin->setOutputPlugin(yafOutput);
+  InputDecoderYAF decoder(plugin,yafOutput);
+
+
+
+  while(1) { 
+    c = getopt (argc, argv, "2yamh");
+    if (c == -1) break;
+    switch(c) {
+    case 'a': {    
+      lInternalAudio=false;
+      break;
+    }
+    case 'y': {
+      decoder.setAutoPlay(false);
+      break;
+    }
+    case 'h': {
+      usage();
+      exit(0);
+    }
+    default:
+      printf ("?? getopt returned character code 0%o ??\n", c);
+      usage();
+      exit(-1);
+    }
+  }
+  if (optind < argc ) {
+    Buffer buffer(300);
+    buffer.append("open ");
+    buffer.append(argv[optind]);
+    buffer.append("\n");
+    
+    input.addInputLine(&buffer);
+
+  }
+
+  yafOutput->internalDevice(lInternalAudio);
+  control_tplay(&input,&output,&decoder);
+  delete plugin;
+  delete yafOutput;
+
+}
+
+
+
+
+
diff --git a/mpeglib/example/yaf/yafvorbis/Makefile.am b/mpeglib/example/yaf/yafvorbis/Makefile.am
new file mode 100644
index 00000000..f0a01965
--- /dev/null
+++ b/mpeglib/example/yaf/yafvorbis/Makefile.am
@@ -0,0 +1,33 @@
+#  splay-yaf - Makefile.am
+
+INCLUDES		=	-I../../include -I../../include/vorbis/include $(all_includes)
+
+EXTRA_DIST		=	
+
+bin_PROGRAMS		=	yaf-vorbis
+
+yaf_vorbis_SOURCES	=	vorbis_control.cpp
+
+noinst_HEADERS		=	
+
+yaf_vorbis_LDFLAGS	=	$(all_libraries) $(KDE_RPATH) 
+
+yaf_vorbis_LDADD	=	 \
+				../yafcore/libyafcore.la \
+				../yafxplayer/libyafxplayer.la \
+				../../../lib/libmpeg.la \
+				$(THIS_LIB_LIBS)
+
+
+
+
+				
+
+
+
+
+
+
+
+
+
diff --git a/mpeglib/example/yaf/yafvorbis/vorbis_control.cpp b/mpeglib/example/yaf/yafvorbis/vorbis_control.cpp
new file mode 100644
index 00000000..1e8c2b09
--- /dev/null
+++ b/mpeglib/example/yaf/yafvorbis/vorbis_control.cpp
@@ -0,0 +1,150 @@
+/*
+  generic interactive controller 
+  Copyright (C) 2000  Martin Vogt
+
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of the GNU Library General Public License as published by
+  the Free Software Foundation.
+
+  For more information look at the file COPYRIGHT in this package
+
+ */
+
+
+// Set for local include
+#define DIRECT_INCLUDE
+
+#include "../yafcore/yaf_control.h"
+#include "../yafxplayer/inputDecoderYAF.h"
+
+
+
+#include <iostream>
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+// for dynamic loading
+#include <dlfcn.h>
+
+#include "../../../lib/decoder/vorbisPlugin.h"
+
+#if defined(HAVE_GETOPT_H) 
+#include <getopt.h>
+#endif
+
+using namespace std;
+
+void control_vorbis(InputInterface* input,OutputInterface* output,
+		   InputDecoder* decoder) {
+
+
+  cout<< "Command:0 Msg:protocol yaf-0.1" << endl;
+  cout<< "Command:0 Msg:implements xplayer" << endl;
+  cout<< "Command:0 Msg:decoder vorbis Version:20000223" << endl;
+  cout<< "Command:0 Msg:mimetypes audio/ogg;" << endl;
+  cout<< "Command:0 Msg:comment vorbis by Monty http://www.xiph.org/" << endl;
+  cout<< "Command:0 Msg:comment yaf port by [email protected]"<<endl;
+  cout<< "Command:0 Msg:comment based on sources from vorbis"<<endl;
+  cout<< "Command:0 Msg:comment enter 'help' " << endl;
+ 
+
+  
+ 
+  
+  yaf_control(input,output,decoder);
+}
+
+
+void usage() {
+  cout << "yaf-vorbis is a interactive frontend for the vorbis decoder"<<endl;
+  cout << "Usage : yaf-vorbis [url]"<<endl;
+  cout << endl;
+  cout << "-a : no internal audio device"<<endl;
+  cout << "-y : autoplay off"<<endl;
+  cout << endl;
+  cout << "THIS SOFTWARE COMES WITH ABSOLUTELY NO WARRANTY! " \
+       << "USE AT YOUR OWN RISK!"<<endl;
+  cout << endl;
+  cout << "for more help type 'help' in interactive mode"<<endl;
+}
+
+
+
+int main(int argc, char** argv) {
+  int c;
+  int lInternalAudio=true;
+
+
+  pow(6.0,3.0);            // fixes bug in __math.h
+  InputInterface* input=new InputInterface();
+  OutputInterface output(&cout);
+
+  YafOutputStream* yafOutput=new YafOutputStream(input);
+
+
+  VorbisPlugin* plugin=new VorbisPlugin();
+
+  plugin->setOutputPlugin(yafOutput);
+  InputDecoderYAF decoder(plugin,yafOutput);
+
+
+
+  while(1) { 
+    c = getopt (argc, argv, "2amhy");
+    if (c == -1) break;
+    switch(c) {
+    case 'a': {    
+      lInternalAudio=false;
+      break;
+    }
+    case 'h': {
+      usage();
+      exit(0);
+    }
+    case '2': {
+      plugin->config("-2","true",NULL);
+      break;
+    }
+    case 'y': {
+      decoder.setAutoPlay(false);
+      break;
+    }
+    case 'm': {
+      plugin->config("-m","true",NULL);
+      break;
+    }
+    case 'r': {
+      plugin->config("runtime","on",NULL);
+      break;
+    }
+    case 'c': {
+      plugin->config("-c","true",NULL);
+      break;
+    }
+    default:
+      printf ("?? getopt returned character code 0%o ??\n", c);
+      usage();
+      exit(-1);
+    }
+  }
+  if (optind < argc ) {
+    Buffer buffer(300);
+    buffer.append("open ");
+    buffer.append(argv[optind]);
+    buffer.append("\n");
+    
+    input->addInputLine(&buffer);
+
+  }
+
+
+
+  yafOutput->internalDevice(lInternalAudio);
+  control_vorbis(input,&output,&decoder);
+  delete plugin;
+  delete yafOutput;
+
+}
+
+
diff --git a/mpeglib/example/yaf/yafxplayer/Makefile.am b/mpeglib/example/yaf/yafxplayer/Makefile.am
new file mode 100644
index 00000000..e49e999e
--- /dev/null
+++ b/mpeglib/example/yaf/yafxplayer/Makefile.am
@@ -0,0 +1,37 @@
+#  libxplayer - Makefile.am
+
+INCLUDES			=	-I../../include $(all_includes)
+
+AM_CPPFLAGS			=	-DDIRECT_INCLUDE
+
+EXTRA_DIST			=	xplayerCommand.defs  xplayerRuntime.defs
+
+lib_LTLIBRARIES			=	libyafxplayer.la
+
+
+noinst_HEADERS			=	commandTableXPlayer.h  runtimeTableXPlayer.h \
+					xplayer_control.h
+
+
+libyafxplayer_la_SOURCES	=	commandTableXPlayer.cpp \
+					inputDecoderXPlayer.cpp \
+					xplayer_control.cpp \
+					runtimeTableXPlayer.cpp \
+					inputDecoderYAF.cpp yafOutputStream.cpp
+
+
+libyafxplayer_la_LDFLAGS	=	$(all_libraries) $(KDE_RPATH) \
+					-no-undefined -avoid-version
+
+libyafxplayer_la_LIBADD		=	../../../lib/libmpeg.la \
+					../yafcore/libyafcore.la \
+					$(THIS_LIB_LIBS)
+
+
+
+yafxplayerdir			=	$(includedir)/$(THIS_LIB_NAME)/util/yaf/yafxplayer
+
+yafxplayer_HEADERS		=	inputDecoderYAF.h \
+					inputDecoderXPlayer.h \
+					yafOutputStream.h
+
diff --git a/mpeglib/example/yaf/yafxplayer/README b/mpeglib/example/yaf/yafxplayer/README
new file mode 100644
index 00000000..3eb486c4
--- /dev/null
+++ b/mpeglib/example/yaf/yafxplayer/README
@@ -0,0 +1,30 @@
+
+This directory contains a generic player frontend.
+Use this as a start if you add new decoder support
+to yaf.
+
+The first step is to build the generic frontend.
+Uncomment in xplayer_control.c the "main" part
+and link the *.o fails againt yafcore.
+
+g++ -o xplayer *.o ../yafcore.a
+
+
+This should build ./xplayer 
+
+
+If you implement a new player ans you have to change all the names,
+the following script is *very* usefull
+
+
+for i in *.cpp; do
+sed s\/XPlayer\/helloName\/g $i >$i.x
+mv $i.x $i
+done
+
+which replaces all occurances of "XPlayer" in all .cpp files
+to "helloName"
+
+(usefull, isn't it)
+
+
diff --git a/mpeglib/example/yaf/yafxplayer/commandTableXPlayer.cpp b/mpeglib/example/yaf/yafxplayer/commandTableXPlayer.cpp
new file mode 100644
index 00000000..31d3a454
--- /dev/null
+++ b/mpeglib/example/yaf/yafxplayer/commandTableXPlayer.cpp
@@ -0,0 +1,35 @@
+/*
+  valid Commands for generic cd player
+  Copyright (C) 1998  Martin Vogt
+
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of the GNU Library General Public License as published by
+  the Free Software Foundation.
+
+  For more information look at the file COPYRIGHT in this package
+
+ */
+
+#define _USE_XPLAYER_STRUC
+
+#include "commandTableXPlayer.h"
+
+
+CommandTableXPlayer::CommandTableXPlayer(){
+  init();
+}
+
+CommandTableXPlayer::~CommandTableXPlayer(){
+}
+
+void CommandTableXPlayer::init() {
+
+
+  int i;
+  for (i=0;i<XPLAYERCOMMANDS_SIZE;i++) {
+    insert(&xplayerCommands[i]);
+  }
+	   
+
+}
+
diff --git a/mpeglib/example/yaf/yafxplayer/commandTableXPlayer.h b/mpeglib/example/yaf/yafxplayer/commandTableXPlayer.h
new file mode 100644
index 00000000..2bc23094
--- /dev/null
+++ b/mpeglib/example/yaf/yafxplayer/commandTableXPlayer.h
@@ -0,0 +1,36 @@
+/*
+  valid Commands for generic cd player
+  Copyright (C) 1998  Martin Vogt
+
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of the GNU Library General Public License as published by
+  the Free Software Foundation.
+
+  For more information look at the file COPYRIGHT in this package
+
+ */
+
+
+
+
+#ifndef __COMMAND_TABLEXPLAYER_H
+#define __COMMAND_TABLEXPLAYER_H
+
+#include "../yafcore/commandTable.h"
+#include "xplayerCommand.defs"
+
+
+
+
+
+class CommandTableXPlayer : public CommandTable {
+
+ public:
+  CommandTableXPlayer();
+  ~CommandTableXPlayer();
+  void init();
+
+};
+
+#endif
+
diff --git a/mpeglib/example/yaf/yafxplayer/inputDecoderXPlayer.cpp b/mpeglib/example/yaf/yafxplayer/inputDecoderXPlayer.cpp
new file mode 100644
index 00000000..4b3bf3b3
--- /dev/null
+++ b/mpeglib/example/yaf/yafxplayer/inputDecoderXPlayer.cpp
@@ -0,0 +1,239 @@
+/*
+  generic Implementation of a cd-player
+  Copyright (C) 1998  Martin Vogt
+
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of the GNU Library General Public License as published by
+  the Free Software Foundation.
+
+  For more information look at the file COPYRIGHT in this package
+
+ */
+
+
+
+
+#include "inputDecoderXPlayer.h"
+#include "commandTableXPlayer.h"
+#include <iostream>
+using namespace std;
+
+#define DEBUG cout << "Command:1 Msg:"
+
+
+InputDecoderXPlayer::InputDecoderXPlayer(YafOutputStream* yafOutput) : 
+  InputDecoder() {
+
+  output=new OutputInterface(&cout);
+  output->setProtocolSyntax(true);
+  this->yafOutput=yafOutput;
+  ct=new CommandTableXPlayer();
+  
+  setDecoderStatus(_DECODER_STATUS_IDLE);
+  appendCommandTable(ct);
+  majorMode=_PLAYER_MAJOR_MODE_OFF;
+  setRuntimeInfo(false);
+  // As default we expect a user which does not want to know
+  // about the player status.
+  // This is *not* true if the user is a controlling GUI.
+  // A GUI should alwas send :
+  // "MajorModeInfo on"
+  setMajorModeInfo(true);   // as default we don't inform about the state!
+  isOn=false;
+} 
+
+InputDecoderXPlayer::~InputDecoderXPlayer(){
+  delete ct;
+  delete output;
+}
+
+void InputDecoderXPlayer::setMajorModeInfo(int lDisplayMajorMode) {
+  this->lDisplayMajorMode=lDisplayMajorMode;
+}
+
+int InputDecoderXPlayer::getMajorModeInfo() {
+  return lDisplayMajorMode;
+}
+
+
+
+int InputDecoderXPlayer::getOn() {
+  return isOn;
+}
+
+ 
+void InputDecoderXPlayer::setOn(int lOn) {
+  isOn=lOn;
+}
+
+
+
+
+  
+void InputDecoderXPlayer::setMajorMode(int mode) {
+  const char* ptr;
+  majorMode=mode;
+
+  if (lDisplayMajorMode==false) {
+    cout << "lDisplayMajorMode false"<<endl;
+    return;
+  }
+  output->lock();
+  output->clearBuffer();
+  output->appendBuffer("Command:0 Msg:player-status ");
+  if (majorMode == _PLAYER_MAJOR_MODE_OFF) {
+    ptr="off";
+  } else if (majorMode == _PLAYER_MAJOR_MODE_ON) {
+    ptr="on";
+  } else if (majorMode == _PLAYER_MAJOR_MODE_OPEN_TRACK) {
+    ptr="open";
+  } else if (majorMode == _PLAYER_MAJOR_MODE_CLOSE_TRACK) {
+    ptr="close";
+  } else if (majorMode == _PLAYER_MAJOR_MODE_PLAYING) {
+    ptr="playing";
+  } else if (majorMode == _PLAYER_MAJOR_MODE_PAUSE) {            
+    ptr="pause";
+  } else {
+    ptr="unknown";
+  }
+  output->appendBuffer(ptr);
+  if (majorMode == _PLAYER_MAJOR_MODE_OFF) {
+    char val[40];
+    long bytes=yafOutput->getBytesCounter();
+    long allWrite=yafOutput->getAllWriteCounter();
+    
+    snprintf(val,40,"%ld %ld",bytes,allWrite);
+    output->appendBuffer(" ");
+    output->appendBuffer(val);
+  }
+  output->flushBuffer();  
+  output->unlock();
+}
+
+
+
+int InputDecoderXPlayer::getMajorMode() {
+  return majorMode;
+}
+
+
+
+void InputDecoderXPlayer::doSomething(){
+  DEBUG << "Decoder did something" << endl;
+  // after decoding is ready we close the file
+
+  InputDecoder::doSomething();
+}
+
+
+
+const char* InputDecoderXPlayer::processCommand(int command,const char* args){
+
+  if (command == _PLAYER_OFF) {
+    if (isOn == true) {
+      isOn=false;
+      processCommand(_PLAYER_PAUSE,"");
+      processCommand(_PLAYER_CLOSE,"");
+     
+      setMajorMode(_PLAYER_MAJOR_MODE_OFF);
+      yafOutput->setBytesCounter(0);
+    }
+    return"";
+  }
+  
+  if (command == _PLAYER_ON) {
+    if (isOn == false) {
+      setMajorMode(_PLAYER_MAJOR_MODE_ON);
+      isOn=true;
+    }
+    return"";
+  }
+
+
+  if (command == _PLAYER_OPEN) {
+    setMajorMode(_PLAYER_MAJOR_MODE_OPEN_TRACK);
+    return"";
+  }
+  
+  if (command == _PLAYER_CLOSE) {
+    setMajorMode(_PLAYER_MAJOR_MODE_CLOSE_TRACK);
+    return"";
+  }
+ 
+  if (command == _PLAYER_PLAY) {
+    setDecoderStatus(_DECODER_STATUS_WORKING);
+    setMajorMode(_PLAYER_MAJOR_MODE_PLAYING);
+    return"";
+  }
+ 
+  if (command == _PLAYER_PAUSE) {
+    setMajorMode(_PLAYER_MAJOR_MODE_PAUSE);
+    return"";
+  }   
+
+  if (command == _PLAYER_VERBOSE) {
+    if (strcmp(args,"off")==0) {
+      setMajorModeInfo(false); 
+    } else {
+      setMajorModeInfo(true); 
+    }
+    return"";
+  } 
+
+  if (command == _PLAYER_OUTPUTFILE) {
+    int ret;
+    if (yafOutput->isOpenStream() == true) {
+      return "already output file selected";
+    }    
+    yafOutput->setStreamFile(args);
+    // now we have set the fifo. But we must say the parent
+    // process that we start with waiting
+
+    cout << "Command:0 Msg:fileopen before"<<endl;
+    ret=yafOutput->openStream();
+    cout << "Command:0 Msg:fileopen after"<<endl;
+
+    if (ret < 0) {
+      return "cannot open outfile";
+    }
+    return "";
+  }
+  if (command == _PLAYER_CLOSEOUTPUTFILE) {
+    if (yafOutput->isOpenStream() == false) {
+      return "no output file selected";
+    }
+    yafOutput->closeStream();
+    return "";
+  }
+
+  if (command == _PLAYER_INTERNALAUDIO) {
+    if (strcmp("on",args)==0) {
+      yafOutput->internalDevice(true);
+      return "";
+    }
+    yafOutput->internalDevice(false);
+    return "";
+  }
+   
+  if (command == _PLAYER_SLEEP) {
+    int nSec;
+    sscanf(args,"%d",&nSec);  // convert string to int
+    sleep(nSec);
+    return "";
+  }
+  if (command == _PLAYER_CLEAR) {
+    yafOutput->setBytesCounter(0);
+    return "";
+  }
+    
+  return InputDecoder::processCommand(command,args);
+}
+
+
+
+
+
+
+
+
+
diff --git a/mpeglib/example/yaf/yafxplayer/inputDecoderXPlayer.h b/mpeglib/example/yaf/yafxplayer/inputDecoderXPlayer.h
new file mode 100644
index 00000000..e6602b52
--- /dev/null
+++ b/mpeglib/example/yaf/yafxplayer/inputDecoderXPlayer.h
@@ -0,0 +1,117 @@
+/*
+  generic Implementation of a cd-player
+  Copyright (C) 1998  Martin Vogt
+
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of the GNU Library General Public License as published by
+  the Free Software Foundation.
+
+  For more information look at the file COPYRIGHT in this package
+
+ */
+
+
+
+
+#ifndef __INPUTDECODERXPLAYER_H
+#define __INPUTDECODERXPLAYER_H
+
+
+#include "../yafcore/inputDecoder.h"
+#include "yafOutputStream.h"
+
+
+
+/** 
+    major modes . it should be not necessary to define
+    new modes.
+    What are "major modes"?
+    <p>
+    The idea of the major modes, is that this is a very
+    general description of an abstract cd player.
+    When the decoder works yaf send these
+    major modes to the frontend.
+    <p>
+    These Major modes describes the basic commands which
+    every yaf-decoder implementation should support:
+    <pre>
+    on/off
+    open/close
+    pause/play
+    </pre>
+    Thus it is possible that a frontend works with
+    a decoder even if the frontend  does not fully support all
+    the commands (e.g: switch to mono etc...)
+
+ <pre>
+ If you think you have a new "mode" its almost a "feature"
+ eg:  You have a command "jump" but this is not a "mode"
+      because you can press "jump" on your cd player even
+      if the cd player is off OR on OR playing OR paused
+      In all these cases the command does not affect the
+      state of your cd-player. Or do you have a player
+      which switches itself on if you press e.g. "Track 1" ?
+ </pre>     
+*/
+
+#define _PLAYER_MAJOR_MODE_OFF               1
+#define _PLAYER_MAJOR_MODE_ON                2
+#define _PLAYER_MAJOR_MODE_OPEN_TRACK        3
+#define _PLAYER_MAJOR_MODE_CLOSE_TRACK       4
+#define _PLAYER_MAJOR_MODE_PLAYING           5   
+#define _PLAYER_MAJOR_MODE_PAUSE             6
+
+
+/*    
+ off: the cd player is switched off  (/dev/dsp is unlocked)
+
+
+ on : (you may play the inserte cd) (/dev/dsp is locked) 
+
+ playing: cd player plays something  (player is switched on)
+ pause: does not play                        "
+
+ open track : think of it that you "select a track" you
+              can only open a track if the player is "ON"
+
+ close track: eject the cd from player. 
+              (This does not necessarily mean that /dev/dsp is unlocked)
+*/
+ 
+
+class CommandTableXPlayer;
+
+class InputDecoderXPlayer : public InputDecoder {
+
+  
+ public:
+  InputDecoderXPlayer(YafOutputStream* yafOutput);
+  ~InputDecoderXPlayer();
+
+  const char* processCommand(int command,const char* args);
+  void doSomething();
+
+  void setMajorMode(int mode);
+  int getMajorMode();
+
+  void setMajorModeInfo(int lDisplayMajorMode);
+  int getMajorModeInfo();
+
+  int getOn();
+  void setOn(int lOn);
+
+ private:
+
+  int majorMode;
+  CommandTableXPlayer* ct;
+  int lDisplayMajorMode;
+  OutputInterface* output;
+  YafOutputStream* yafOutput;
+  
+  int isOn;
+};
+
+
+#endif
+
+
diff --git a/mpeglib/example/yaf/yafxplayer/inputDecoderYAF.cpp b/mpeglib/example/yaf/yafxplayer/inputDecoderYAF.cpp
new file mode 100644
index 00000000..b4b6a317
--- /dev/null
+++ b/mpeglib/example/yaf/yafxplayer/inputDecoderYAF.cpp
@@ -0,0 +1,220 @@
+/*
+  base Implementation of a yaf decoder
+  Copyright (C) 1999  Martin Vogt
+
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of the GNU Library General Public License as published by
+  the Free Software Foundation.
+
+  For more information look at the file COPYRIGHT in this package
+
+ */
+
+
+
+#define DEBUG cout << "Command:1 Msg:"
+
+#include "inputDecoderYAF.h"
+#include "xplayerCommand.defs"
+#include "../yafcore/yafCommand.defs"
+#include <iostream>
+  
+using namespace std;
+
+InputDecoderYAF::InputDecoderYAF(DecoderPlugin* plugin,
+				 YafOutputStream* output) 
+  : InputDecoderXPlayer(output) {
+
+  this->plugin=plugin;
+  this->output=output;
+  input=NULL;
+
+  lAutoPlay=true;
+  lFileSelected=false;
+  songPath=new Buffer(256);
+}
+
+
+InputDecoderYAF::~InputDecoderYAF(){
+  delete songPath;
+}
+
+
+/** 
+    This method is entered by the global loop. (xplayer_control.c)
+    This method should never (!) block or it
+    is unpossible to read commands on stdin!
+
+
+    Note: YAF is not a threaded player this is why we need
+    this doSomething method. Other player may already be threaded and
+    offer a "control"/"working" channel. 
+    These players won't need this loop.
+
+*/
+
+  
+void InputDecoderYAF::doSomething(){
+
+}
+
+
+const char* InputDecoderYAF::processCommand(int command,const char* args){
+
+  if (command == _PLAYER_UPDATE) {
+    int state=plugin->getStreamState();
+    if (state == _STREAM_STATE_EOF) {
+      if (getMajorMode() != _PLAYER_MAJOR_MODE_OFF) {
+	return processCommand(_PLAYER_OFF,"");
+      }
+    }
+    return "";
+  }
+ 
+
+  if (command == _PLAYER_OPEN) {
+    if (strlen(args) == 0) {
+      return "no file";
+    }
+    if (lFileSelected == true) {
+      processCommand(_PLAYER_CLOSE,"");
+    }
+
+    if (getOn() == true) {
+      processCommand(_PLAYER_OFF,"");
+    }
+            
+    if (getOn() == false) {
+      processCommand(_PLAYER_ON,"");
+    }
+    output->setBytesCounter(0);
+  
+    input=InputPlugin::createInputStream(args,_INPUT_THREADSAFE);
+    if (input == NULL) {
+      cout << "createInputStream failed"<<endl;
+      return processCommand(_PLAYER_OFF,"");
+    }     
+    lFileSelected=true;
+    setMajorMode(_PLAYER_MAJOR_MODE_OPEN_TRACK);
+    input->open(args);
+    if (plugin->setInputPlugin(input) == false) {
+      return processCommand(_PLAYER_OFF,"");
+    }
+    songPath->clear();
+    songPath->append(args);
+    if (lAutoPlay) {
+      return processCommand(_PLAYER_PLAY,"");
+    }
+    return "";
+  }
+  
+  if (command == _PLAYER_CLOSE) {
+    if (lFileSelected) {
+      processCommand(_PLAYER_PAUSE,"");
+      plugin->close();
+      
+      delete input;
+      input=NULL;
+      setMajorMode(_PLAYER_MAJOR_MODE_CLOSE_TRACK);
+      lFileSelected=false;
+    }
+    return "";
+  }
+    
+    
+  if (command == _PLAYER_PLAY) {
+    if (lFileSelected) {
+      setMajorMode(_PLAYER_MAJOR_MODE_PLAYING);
+      plugin->play();
+      return "";
+    }
+    return "no file";
+  }
+  
+  if (command == _PLAYER_PAUSE) {
+    int mode=getMajorMode();
+    if (mode == _PLAYER_MAJOR_MODE_PLAYING) {
+      plugin->pause();
+      setMajorMode(_PLAYER_MAJOR_MODE_PAUSE);
+    }
+
+    return ""; 
+  }
+
+  if (command == _YAF_I_PLAYTIME) {
+    int current=plugin->getTime(true);
+    int total=plugin->getTime(false);
+      
+    cout << "Command:0 Msg:playtime current:"<<current<<" total:"<<total<<endl;
+    return "";
+  }
+
+  // another YAF part:
+  if (command == _PLAYER_JUMP) {
+    if (lFileSelected) {
+      int nSec=0;
+      int mode=getMajorMode();
+      processCommand(_PLAYER_PAUSE,"");
+      sscanf(args,"%d",&nSec);  // convert string to int
+      /* if the value is signed, do a relative jump */
+      if(index(args, '-') || index(args, '+')) {
+      	nSec += plugin->getTime(true);
+      }
+      // nPos is the time in seconds!!!!
+      plugin->seek(nSec);
+      output->setBytesCounter(0);
+
+      if (mode == _PLAYER_MAJOR_MODE_PLAYING) {
+	processCommand(_PLAYER_PLAY,"");
+      }
+      return "";
+    }
+    return "no file";
+  }
+
+
+  if (command == _YAF_I_RUNTIME) {
+    if (strcmp("off",args)==0) {
+      plugin->config("runtime","off",NULL);
+    } else {
+      plugin->config("runtime","on",NULL);
+    }
+  } 
+  if (command == _PLAYER_MUSICINFO) {
+    PluginInfo* plugInfo=plugin->getPluginInfo();
+    output->writeInfo(plugInfo);
+    return "";
+  }
+  
+  if (command == _YAF_I_SELECT_A_LAYER) {
+    plugin->config("AudioLayer",args,NULL);
+    return "";
+  }
+  if (command == _YAF_I_SELECT_V_LAYER) {
+    plugin->config("VideoLayer",args,NULL);
+    return "";
+  }
+
+  if (command == _YAF_I_WRITE) {
+    if (strcmp(args,"on")==0) {
+      plugin->config("-w","true",NULL);
+    } else {
+      plugin->config("-w","false",NULL);
+    }
+    return "";
+  }
+
+
+  return (InputDecoderXPlayer::processCommand(command,args));
+}
+
+
+
+
+int InputDecoderYAF::getAutoPlay() {
+  return lAutoPlay;
+}
+
+void InputDecoderYAF::setAutoPlay(int lAutoPlay) {
+  this->lAutoPlay=lAutoPlay;
+}
diff --git a/mpeglib/example/yaf/yafxplayer/inputDecoderYAF.h b/mpeglib/example/yaf/yafxplayer/inputDecoderYAF.h
new file mode 100644
index 00000000..2002dc58
--- /dev/null
+++ b/mpeglib/example/yaf/yafxplayer/inputDecoderYAF.h
@@ -0,0 +1,51 @@
+/*
+  base Implementation of a yaf decoder
+  Copyright (C) 1999  Martin Vogt
+
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of the GNU Library General Public License as published by
+  the Free Software Foundation.
+
+  For more information look at the file COPYRIGHT in this package
+
+ */
+
+
+
+
+#ifndef __INPUTDECODERYAF_H
+#define __INPUTDECODERYAF_H
+
+#include <pthread.h>
+
+#include "inputDecoderXPlayer.h"
+#include "yafOutputStream.h"
+#include <kdemacros.h>
+
+
+class KDE_EXPORT InputDecoderYAF : public InputDecoderXPlayer {
+
+  DecoderPlugin* plugin;
+  YafOutputStream* output;
+  InputStream* input;
+  int lAutoPlay;
+
+ public:
+  InputDecoderYAF(DecoderPlugin* plugin,YafOutputStream* output);
+  ~InputDecoderYAF();
+
+  const char* processCommand(int command,const char* args);
+  void doSomething();
+  
+  int getAutoPlay();
+  void setAutoPlay(int lAutoPlay);
+
+ private:
+
+  int lFileSelected;
+  Buffer* songPath;
+};
+
+
+#endif
+
diff --git a/mpeglib/example/yaf/yafxplayer/runtimeTableXPlayer.cpp b/mpeglib/example/yaf/yafxplayer/runtimeTableXPlayer.cpp
new file mode 100644
index 00000000..792d0d45
--- /dev/null
+++ b/mpeglib/example/yaf/yafxplayer/runtimeTableXPlayer.cpp
@@ -0,0 +1,37 @@
+/*
+  valid runtime commands for generic player
+  Copyright (C) 1998  Martin Vogt
+
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of the GNU Library General Public License as published by
+  the Free Software Foundation.
+
+  For more information look at the file COPYRIGHT in this package
+
+ */
+
+
+#define _USE_RUNTIME_XPLAYER_STRUC
+
+#include "runtimeTableXPlayer.h"
+
+
+RuntimeTableXPlayer::RuntimeTableXPlayer(){
+  init();
+}
+
+RuntimeTableXPlayer::~RuntimeTableXPlayer(){
+}
+
+void RuntimeTableXPlayer::init() {
+
+
+  int i;
+  for (i=0;i<XPLAYERRUNTIME_SIZE;i++) {
+    insert(&xplayerRuntime[i]);
+  }
+	   
+
+}
+
+
diff --git a/mpeglib/example/yaf/yafxplayer/runtimeTableXPlayer.h b/mpeglib/example/yaf/yafxplayer/runtimeTableXPlayer.h
new file mode 100644
index 00000000..8f3ad2d0
--- /dev/null
+++ b/mpeglib/example/yaf/yafxplayer/runtimeTableXPlayer.h
@@ -0,0 +1,40 @@
+/*
+  valid runtime commands for generic player
+  Copyright (C) 1998  Martin Vogt
+
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of the GNU Library General Public License as published by
+  the Free Software Foundation.
+
+  For more information look at the file COPYRIGHT in this package
+
+ */
+
+
+
+
+#ifndef __RUNTIME_TABLEXPLAYER_H
+#define __RUNTIME_TABLEXPLAYER_H
+
+#include "../yafcore/commandTable.h"
+#include "xplayerRuntime.defs"
+
+
+
+
+
+class RuntimeTableXPlayer : public CommandTable {
+
+ public:
+  RuntimeTableXPlayer();
+  ~RuntimeTableXPlayer();
+  void init();
+
+};
+
+#endif
+
+
+
+
+
diff --git a/mpeglib/example/yaf/yafxplayer/xplayerCommand.defs b/mpeglib/example/yaf/yafxplayer/xplayerCommand.defs
new file mode 100644
index 00000000..853eb2eb
--- /dev/null
+++ b/mpeglib/example/yaf/yafxplayer/xplayerCommand.defs
@@ -0,0 +1,84 @@
+/*
+  definition file for generic decoder commands
+  Copyright (C) 1998  Martin Vogt
+
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of the GNU Library General Public License as published by
+  the Free Software Foundation.
+
+  For more information look at the file COPYRIGHT in this package
+
+ */
+
+
+#ifndef __XPLAYER_COMMAND_DEFS
+#define __XPLAYER_COMMAND_DEFS
+
+#include "../yafcore/commandTable.h"   // defines CommandDesc-Struct...
+
+// Command Numbers
+
+#define _PLAYER_ON	   _CT_START+1
+#define _PLAYER_OFF        _CT_START+2
+#define _PLAYER_OPEN       _CT_START+3
+#define _PLAYER_CLOSE      _CT_START+4
+
+#define _PLAYER_PLAY       _CT_START+5
+#define _PLAYER_PAUSE      _CT_START+6
+#define _PLAYER_VERBOSE	   _CT_START+7 
+#define _PLAYER_JUMP	   _CT_START+8
+
+
+#define _PLAYER_OUTPUTFILE	_CT_START+9
+#define _PLAYER_CLOSEOUTPUTFILE	_CT_START+10
+#define _PLAYER_INTERNALAUDIO   _CT_START+11
+#define _PLAYER_SLEEP		_CT_START+12
+#define _PLAYER_UPDATE		_CT_START+13
+#define _PLAYER_CLEAR		_CT_START+14
+#define _PLAYER_MUSICINFO	_CT_START+15
+
+
+#define _XPLAYER_START     _CT_START+100
+
+
+// The commands as String. The Syntax is :
+// 
+
+//  { lexternalUse,lReturnMsg,longName,shortName,number,helpText }
+// 
+// lexternal use ist true when the text should be written when 
+// user enters "help"
+
+#ifdef _USE_XPLAYER_STRUC
+static struct CommandDescriptionStruct xplayerCommands[]={
+
+  { 1,1,"on","",_PLAYER_ON,"turn decoder ON"},
+  { 1,1,"off","",_PLAYER_OFF,"turn it OFF"},
+  { 1,1,"open","o",_PLAYER_OPEN,"open <filename>"},
+  { 1,1,"close","c",_PLAYER_CLOSE,"closes current file "},
+  { 1,1,"play" ,"p",_PLAYER_PLAY,"plays the mpeg file" },
+  { 1,1,"verbose" ,"v",_PLAYER_VERBOSE,"verbose [on|off] info about player" },
+  { 1,1,"jump" ,"j",_PLAYER_JUMP,"jump [+|-]<second>" },
+  { 1,1,"pause" ,"a",_PLAYER_PAUSE,"pauses playing mpeg file"},
+  { 1,1,"update" ,"",_PLAYER_UPDATE,"checks state of plugin"},
+  { 1,1,"clear" ,"",_PLAYER_CLEAR,"usefull loopback for frontends"},
+  { 1,1,"musicinfo" ,"",_PLAYER_MUSICINFO,"print useful info about stream"},
+  { 1,1,"outputfile" ,"",_PLAYER_OUTPUTFILE,"outputfile foo.txt" },	
+  { 1,1,"closeoutputfile" ,"",_PLAYER_CLOSEOUTPUTFILE,
+	"closes the outputfile " },
+  { 1,1,"sleep" ,"",_PLAYER_SLEEP,"sleep for x seconds"},
+  {1,1,"audio" ,"",_PLAYER_INTERNALAUDIO,
+       "audio [on|off] for internal audiodevice" }
+
+};
+#endif
+
+
+// How much Commands are in the Array :
+#define XPLAYERCOMMANDS_SIZE 15
+
+
+
+#endif
+
+
diff --git a/mpeglib/example/yaf/yafxplayer/xplayerRuntime.defs b/mpeglib/example/yaf/yafxplayer/xplayerRuntime.defs
new file mode 100644
index 00000000..34402881
--- /dev/null
+++ b/mpeglib/example/yaf/yafxplayer/xplayerRuntime.defs
@@ -0,0 +1,123 @@
+/*
+  Runtime definitions from generic player
+  Copyright (C) 1998  Martin Vogt
+
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of the GNU Library General Public License as published by
+  the Free Software Foundation.
+
+  For more information look at the file COPYRIGHT in this package
+
+ */
+
+
+#ifndef __XPLAYER_RUNTIME_DEFS
+#define __XPLAYER_RUNTIME_DEFS
+
+#include "../yafcore/commandTable.h"   // defines CommandDesc-Struct...
+#include "../yafcore/yafRuntime.defs"
+
+// Command Numbers
+
+#define _PLAYER_RUN_PLAYER_STATUS      			_YAF_RUN_START+1
+
+#define _PLAYER_RUN_STREAMINFO_START			_YAF_RUN_START+2
+#define _PLAYER_RUN_STREAMINFO_CHANNELS			_YAF_RUN_START+3
+#define _PLAYER_RUN_STREAMINFO_SAMPLESIZE		_YAF_RUN_START+4
+#define _PLAYER_RUN_STREAMINFO_SPEED			_YAF_RUN_START+5
+#define _PLAYER_RUN_STREAMINFO_END			_YAF_RUN_START+6
+
+#define _PLAYER_RUN_FILEOPEN                    	_YAF_RUN_START+7
+
+#define _PLAYER_RUN_MUSICINFO_START                   	_YAF_RUN_START+8
+#define _PLAYER_RUN_MUSICINFO_SONG_FILENAME            	_YAF_RUN_START+10
+#define _PLAYER_RUN_MUSICINFO_SONG_NAME                	_YAF_RUN_START+11
+#define _PLAYER_RUN_MUSICINFO_SONG_LEN                 	_YAF_RUN_START+12
+#define _PLAYER_RUN_MUSICINFO_SONG_JUMPS               	_YAF_RUN_START+13
+#define _PLAYER_RUN_MUSICINFO_END                   	_YAF_RUN_START+14
+#define _PLAYER_RUN_ID3_INFO_START			_YAF_RUN_START+15
+#define _PLAYER_RUN_ID3_NAME				_YAF_RUN_START+16
+#define _PLAYER_RUN_ID3_ARTIST				_YAF_RUN_START+17
+#define _PLAYER_RUN_ID3_ALBUM				_YAF_RUN_START+18
+#define _PLAYER_RUN_ID3_YEAR				_YAF_RUN_START+19
+#define _PLAYER_RUN_ID3_COMMENT				_YAF_RUN_START+20
+#define _PLAYER_RUN_ID3_GENRE				_YAF_RUN_START+21
+#define _PLAYER_RUN_ID3_INFO_END			_YAF_RUN_START+22
+#define _PLAYER_RUN_MP3_INFO_START			_YAF_RUN_START+23
+#define _PLAYER_RUN_MP3_BPS				_YAF_RUN_START+24
+#define _PLAYER_RUN_MP3_INFO_END			_YAF_RUN_START+25
+
+
+
+
+
+#define _XPLAYER_RUN_START			_YAF_RUN_START+100
+
+
+typedef struct {
+	int channels;	//2 = stereo 1=mono
+	int nStreamPos; // Position in Stream on which this Info becomes "true"
+} ChannelInfo;
+
+
+typedef struct {
+	int samplesize;	// 16 for 16 Bit
+	int nStreamPos; // Position in Stream on which this Info becomes "true"
+} SampleSizeInfo;
+
+ 
+typedef struct {
+	int channels;	//2 = stereo 1=mono
+	int nStreamPos; // Position in Stream on which this Info becomes "true"
+} SpeedInfo;
+
+
+
+
+// The commands as String. The Syntax is :
+// 
+//  { lexternalUse,lReturnMsg,longName,shortName,number,helpText }
+// 
+// lexternal use ist true when the text should be written when 
+// user enters "help"
+#ifdef _USE_RUNTIME_XPLAYER_STRUC
+static struct CommandDescriptionStruct xplayerRuntime[]={
+
+  { 0,1,"player-status","",_PLAYER_RUN_PLAYER_STATUS,"state of cdplayer"},
+  { 0,1,"streamInfo-Start","",_PLAYER_RUN_STREAMINFO_START,"StreamInfo start"},
+  { 0,1,"streamInfo-Channels","",_PLAYER_RUN_STREAMINFO_CHANNELS,
+	"ChannelInfo"},
+  { 0,1,"streamInfo-SampleSize","",_PLAYER_RUN_STREAMINFO_SAMPLESIZE,
+	"SampleSizeInfo"},
+  { 0,1,"streamInfo-Speed","",_PLAYER_RUN_STREAMINFO_SPEED,"SpeedInfo"},
+  { 0,1,"streamInfo-End","",_PLAYER_RUN_STREAMINFO_END,"StreamInfo end"},
+  { 0,1,"musicinfo-Start","",_PLAYER_RUN_MUSICINFO_START,"begin block"},
+  { 0,1,"song_filename","",_PLAYER_RUN_MUSICINFO_SONG_FILENAME,
+	"filename to the song"},
+  { 0,1,"song_name","",_PLAYER_RUN_MUSICINFO_SONG_NAME,"name of the song"},
+  { 0,1,"song_len","",_PLAYER_RUN_MUSICINFO_SONG_LEN,"length in secs"},
+  { 0,1,"song_jumps","",_PLAYER_RUN_MUSICINFO_SONG_JUMPS,"jump entities in song"},
+  { 0,1,"musicinfo-End","",_PLAYER_RUN_MUSICINFO_END,"end block"},
+  { 0,1,"id3Info-Start","",_PLAYER_RUN_ID3_INFO_START,"ID3Info start"},
+  { 0,1,"id3Name","",_PLAYER_RUN_ID3_NAME,"ID3 Name"},
+  { 0,1,"id3Artist","",_PLAYER_RUN_ID3_ARTIST,"ID3 Artist"},
+  { 0,1,"id3Album","",_PLAYER_RUN_ID3_ALBUM,"ID3 Album"},
+  { 0,1,"id3Year","",_PLAYER_RUN_ID3_YEAR,"ID3 Year"},
+  { 0,1,"id3Comment","",_PLAYER_RUN_ID3_COMMENT,"ID3 Comment"},
+  { 0,1,"id3Genre","",_PLAYER_RUN_ID3_GENRE,"ID3 Genre"},
+  { 0,1,"id3Info-End","",_PLAYER_RUN_ID3_INFO_END,"ID3Info start"},
+  { 0,1,"mp3Info-Start","",_PLAYER_RUN_MP3_INFO_START,"MP3Info start"},
+  { 0,1,"mp3BitsPerSec","",_PLAYER_RUN_MP3_BPS,"Samplebits per second"},
+  { 0,1,"mp3Info-End","",_PLAYER_RUN_MP3_INFO_END,"MP3Info end"},
+  { 0,1,"fileopen", "",_PLAYER_RUN_FILEOPEN, 
+      	"sended before yaf tries to open outputfile"}	
+
+};
+#endif
+
+// How much Commands are in the Array :
+#define XPLAYERRUNTIME_SIZE 24
+
+
+
+#endif
diff --git a/mpeglib/example/yaf/yafxplayer/xplayer_control.cpp b/mpeglib/example/yaf/yafxplayer/xplayer_control.cpp
new file mode 100644
index 00000000..c09b2cbd
--- /dev/null
+++ b/mpeglib/example/yaf/yafxplayer/xplayer_control.cpp
@@ -0,0 +1,44 @@
+/*
+  generic interactive controller 
+  Copyright (C) 1998  Martin Vogt
+
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of the GNU Library General Public License as published by
+  the Free Software Foundation.
+
+  For more information look at the file COPYRIGHT in this package
+
+ */
+
+
+
+#include "xplayer_control.h"
+#include <iostream>
+
+using namespace std;
+
+
+extern "C" void control_xplayer() {
+  InputInterface input;
+  OutputInterface output(&cout);
+  YafOutputStream yafOutput(&input);
+  InputDecoderXPlayer decoder(&yafOutput);
+
+
+  cout<< "Command:0 Msg:protocol yaf-0.1" << endl;
+  cout<< "Command:0 Msg:decoder generic player demo Version:0.1" << endl;
+  cout<< "Command:0 Msg:comment enter 'help' for list of commands" << endl;
+  
+
+  yaf_control(&input,&output,&decoder);
+}
+
+
+/*
+
+int main() {
+  control_xplayer();
+}
+
+
+*/
diff --git a/mpeglib/example/yaf/yafxplayer/xplayer_control.h b/mpeglib/example/yaf/yafxplayer/xplayer_control.h
new file mode 100644
index 00000000..771e8ee4
--- /dev/null
+++ b/mpeglib/example/yaf/yafxplayer/xplayer_control.h
@@ -0,0 +1,25 @@
+ 
+
+#ifndef __XPLAYER_CONTROL_H
+#define __XPLAYER_CONTROL_H
+
+
+
+#include "../yafcore/inputInterface.h"
+#include "../yafcore/outputInterface.h"
+#include "inputDecoderXPlayer.h"
+#include "../yafcore/parser.h"
+
+#include "../yafcore/yaf_control.h"
+
+#include <sys/time.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <stdio.h>
+
+
+
+// prototypes
+
+
+#endif
diff --git a/mpeglib/example/yaf/yafxplayer/yafOutputStream.cpp b/mpeglib/example/yaf/yafxplayer/yafOutputStream.cpp
new file mode 100644
index 00000000..95e61d05
--- /dev/null
+++ b/mpeglib/example/yaf/yafxplayer/yafOutputStream.cpp
@@ -0,0 +1,307 @@
+/*
+  concret OutputClass for yaf text consol player
+  Copyright (C) 1999  Martin Vogt
+
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of the GNU Library General Public License as published by
+  the Free Software Foundation.
+
+  For more information look at the file COPYRIGHT in this package
+
+ */
+
+
+#include "yafOutputStream.h"
+#include <iostream>
+
+using namespace std;
+
+#define _AUDIO_DELAY_STAMPS 200
+
+
+
+
+YafOutputStream::YafOutputStream(InputInterface* input) {
+  lInternalDevice=false;
+  bytes=0;
+  allWrite=0;
+  writeToBuffer=0;
+  lOpen=false;
+  directOutput=OutPlugin::createOutputStream(_OUTPUT_LOCAL,_OUTPUT_THREADSAFE);
+
+
+  this->input=input;
+  ::pipe(fd);
+
+  if (errno < 0) {
+    perror("YafOutputStream pipe");
+    exit(0);
+  }
+  input->addFileDescriptor(fd[0]);
+}
+
+
+YafOutputStream::~YafOutputStream() {
+  delete directOutput;
+}
+
+
+int YafOutputStream::audioSetup(int frequency,int stereo,
+				int sign,int big,int bits) {
+
+  cout << "Command:0 Msg:streamInfo-Start"<<endl;
+  cout << "Command:0 Msg:streamInfo-Channels "<<stereo+1<<endl;
+  
+  cout << "Command:0 Msg:streamInfo-SampleSize "<<bits<<endl;
+  cout << "Command:0 Msg:streamInfo-Speed "<<frequency<<endl;
+  cout << "Command:0 Msg:streamInfo-End"<<endl;
+
+  directOutput->audioSetup(frequency,stereo,sign,big,bits);
+
+  return true;
+}
+
+void YafOutputStream::audioOpen() {
+  if (lInternalDevice) {
+    directOutput->audioOpen();
+  }
+}
+
+void YafOutputStream::audioClose(void) {
+  if (lInternalDevice) {
+    // never close internal audio, because
+    // its not possible to open it again fast enough
+    //directOutput->audioClose();
+  } else {
+    directOutput->audioClose();
+  }
+}
+
+
+int YafOutputStream::audioPlay(TimeStamp* startStamp,
+			       TimeStamp* endStamp,char *buffer, int size) {
+
+  int ret=0;
+  if (lInternalDevice) {
+    directOutput->audioPlay(startStamp,endStamp,buffer,size);
+  }
+
+
+  
+  if (lOpen) {
+    // if we are doing video, we even have to sync
+    // audio writing.
+    // Because yaf sends the audio data to another process
+    // but the video data _not_ the audio data is directly
+    // flushed here, but maybe stay on the other side
+    // in a very big buffer
+    // until the protocol has no better handle
+    // for this, we must make sure to
+    // dont get the buffer on the other
+    // side too big.
+    // we sleep some time until we write the next sample
+
+
+
+
+    directOutput->audioPlay(startStamp,endStamp,buffer,size);
+ 
+
+    ret=::send(sd,buffer,size,0);
+
+
+ 
+ 
+    
+
+    if (ret < 0) {
+      
+      closeStream();
+      cout << "fifo error in streamWriter";
+      perror("writeStream");
+      exit(-1);
+      return ret;
+    }
+
+    bytes=bytes+size;
+    allWrite+=size;
+    return size;
+  }
+
+    
+
+
+  bytes=bytes+size;
+  allWrite+=size;
+  return size;
+}
+
+
+void YafOutputStream::audioFlush() {
+  // notify command line, that plugin state changed
+  input->write(fd[1],"update\n");
+
+  if (lInternalDevice) {
+    directOutput->audioFlush();
+  }
+}
+
+int YafOutputStream::getPreferredDeliverSize() {
+  return directOutput->getPreferredDeliverSize();
+}
+
+
+
+
+int YafOutputStream::openWindow(int width, int height,const char *title) {
+  return directOutput->openWindow(width,height,title);
+}
+
+
+void YafOutputStream::closeWindow() {
+  directOutput->closeWindow();
+}
+
+void YafOutputStream::flushWindow() {
+  directOutput->flushWindow();
+} 
+
+PictureArray* YafOutputStream::lockPictureArray() {
+  return directOutput->lockPictureArray();
+}
+
+
+void YafOutputStream::unlockPictureArray(PictureArray* pictureArray) {
+  directOutput->unlockPictureArray(pictureArray);
+}
+ 
+
+int YafOutputStream::getFrameusec() {
+  return directOutput->getFrameusec();
+}
+
+
+
+int YafOutputStream::getOutputInit() {
+  return directOutput->getOutputInit();
+}
+
+
+void YafOutputStream::setOutputInit(int lInit) {
+  directOutput->setOutputInit(lInit);
+}
+
+
+
+
+void YafOutputStream::writeInfo(PluginInfo* pluginInfo) {
+  char* url=pluginInfo->getUrl();
+  const char* nameStart=strrchr(url,'/');
+
+  if (nameStart==NULL) {
+    nameStart="noname";
+  } else {
+    nameStart++;
+    if (strlen(nameStart) == 0) {
+      nameStart="noname";
+    }
+  }
+      
+  cout << "Command:0 Msg:musicinfo-Start"<<endl;
+  cout << "Command:0 Msg:song_filename "<<pluginInfo->getUrl()<<endl;
+  cout << "Command:0 Msg:song_name "<<nameStart<<endl;
+  cout << "Command:0 Msg:song_len  "<<pluginInfo->getLength()<<endl;
+  cout << "Command:0 Msg:song_jumps 0"<<endl;
+  cout << "Command:0 Msg:musicinfo-End"<<endl;
+}
+
+
+
+
+
+
+void YafOutputStream::setBytesCounter(long value) {
+  bytes=value;
+  writeToBuffer=value;
+}
+
+
+
+int YafOutputStream::isOpenStream() {
+  return lOpen;
+}
+
+
+void YafOutputStream::setStreamFile(const char* filename) {
+  if (lOpen == true) {
+    closeStream();
+  }
+  this->filename=filename;
+}
+
+
+int YafOutputStream::openStream() {
+  if (lOpen == true) {
+    cout << "stream already open! call ignored"<<endl;
+    return sd;
+  }
+  sd=::socket(AF_UNIX,SOCK_STREAM,0);
+  if (sd < 0) {
+    perror("sd-Socket StreamWriter");exit(1);
+  }
+  
+  unsigned int i=0;
+  sockad.sun_family=AF_UNIX;
+
+  while(i<strlen(filename)) {
+        sockad.sun_path[i]=filename[i];
+        i++;
+  }
+  sockad.sun_path[i]=0;
+  if (::connect(sd,(sockaddr*)&sockad,strlen(filename)+2)<0) {
+    perror("connect StreamWriter");exit(1);
+  }
+  if (sd > 0) {
+    lOpen=true;
+  }
+  return sd;
+}
+
+
+int YafOutputStream::closeStream() {
+  int ret=0;
+  if (lOpen) {
+    ret=close(sd);
+    lOpen=false;
+    filename=NULL;
+  } else {
+    cout << "stream already closed. call ignored!"<<endl;
+  }
+  return ret;
+}
+
+
+void YafOutputStream::internalDevice(int lInternal){
+  lInternalDevice=lInternal;
+}
+
+
+
+long YafOutputStream::getBytesCounter() {
+  return bytes;
+}
+
+
+long YafOutputStream::getAllWriteCounter() {
+  return allWrite;
+}
+
+
+
+void YafOutputStream::config(const char* key,const char* value,
+			     void* user_data) {
+
+  directOutput->config(key,value,user_data);
+  
+}
+
diff --git a/mpeglib/example/yaf/yafxplayer/yafOutputStream.h b/mpeglib/example/yaf/yafxplayer/yafOutputStream.h
new file mode 100644
index 00000000..bb7df423
--- /dev/null
+++ b/mpeglib/example/yaf/yafxplayer/yafOutputStream.h
@@ -0,0 +1,140 @@
+/*
+  concret OutputClass for yaf text consol player
+  Copyright (C) 1999  Martin Vogt
+
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of the GNU Library General Public License as published by
+  the Free Software Foundation.
+
+  For more information look at the file COPYRIGHT in this package
+
+ */
+
+
+
+#ifndef __YAFOUTPUTSTREAM_H
+#define __YAFOUTPUTSTREAM_H
+
+   
+
+//
+// If we build mpeglib we include the path absolute
+// otherwise we must have installed the includes (eg /usr/include/mpeglib)
+//
+
+#ifdef DIRECT_INCLUDE
+#include "../../../lib/output/avSyncer.h"
+#include "../../../lib/output/pluginInfo.h"
+#include "../../../lib/decoder/decoderPlugin.h"
+#include "../../../lib/input/inputPlugin.h"
+#include "../../../lib/output/outPlugin.h"
+#else 
+#include <mpeglib/output/avSyncer.h>
+#include <mpeglib/output/pluginInfo.h>
+#include <mpeglib/decoder/decoderPlugin.h>
+#include <mpeglib/input/inputPlugin.h>
+#include <mpeglib/output/outPlugin.h>
+#endif
+
+#include <sys/un.h>
+#include <errno.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <kdemacros.h>
+
+// If you get compile errors when using mpeglib
+// simply remove the yaf dependencies
+#include "../yafcore/inputInterface.h"
+
+
+
+class KDE_EXPORT YafOutputStream : public OutputStream {
+
+
+  long bytes;
+  int lInternalDevice;
+  long allWrite;
+  int lOpen;
+  int sd;
+  struct sockaddr_un sockad;
+  const char* filename;
+  OutputStream* directOutput;
+  int fd[2];
+  InputInterface* input;
+
+  int writeToBuffer;
+
+
+  
+
+ public:
+  // to the filedescriptor we write status messages from
+  // the thread. This makes it thread safe
+  YafOutputStream(InputInterface* input);
+  ~YafOutputStream();
+
+  // Audio Output
+
+  int audioSetup(int frequency,int stereo,int sign,int big,int sixteen);
+  void audioClose(void);
+  int audioPlay(TimeStamp* startStamp,
+		TimeStamp* endStamp,char *buffer, int size);
+
+  void audioFlush();
+  void audioOpen();
+
+  int getPreferredDeliverSize();
+
+
+  // Video part (no yaf protocol for this)
+  // Maybe in a future version we distribute this interface
+  // over shared mem or something, but for now
+  // a video player must include the mpeg video lib directly
+  // we forward the calls to the direct output
+
+ 
+  int openWindow(int width, int height,const char *title);
+  void closeWindow();
+  void flushWindow();
+
+  PictureArray* lockPictureArray();
+  void unlockPictureArray(PictureArray* pictureArray);
+  
+  int getFrameusec();
+
+  int getDepth();
+  int getOutputInit();
+  void setOutputInit(int lInit);
+
+
+  // Info Output
+  void writeInfo(PluginInfo* pluginInfo);
+ 
+  void config(const char* key,const char* value,void* user_data);
+
+
+  // additional functionality (needed for the yaf-protocol)
+  void setBytesCounter(long value);
+
+
+  int isOpenStream();
+  void setStreamFile(const char* filename);
+  int openStream();
+  int closeStream();
+
+  void internalDevice(int lInternal);
+  long getBytesCounter();
+  long getAllWriteCounter();
+
+
+  
+
+  
+
+
+};
+
+
+
+#endif
diff --git a/mpeglib/example/yaf/yafyuv/Makefile.am b/mpeglib/example/yaf/yafyuv/Makefile.am
new file mode 100644
index 00000000..3400a34c
--- /dev/null
+++ b/mpeglib/example/yaf/yafyuv/Makefile.am
@@ -0,0 +1,37 @@
+#  splay-yaf - Makefile.am
+
+INCLUDES		=	-I../../include $(all_includes)
+
+EXTRA_DIST		=	
+
+bin_PROGRAMS		=	yaf-yuv
+
+yaf_yuv_SOURCES		=	yuv_control.cpp
+
+
+noinst_HEADERS		=	
+
+yaf_yuv_LDFLAGS		=	$(all_libraries) $(KDE_RPATH)
+
+
+yaf_yuv_LDADD		=	../yafxplayer/libyafxplayer.la \
+				../yafcore/libyafcore.la \
+				../../../lib/libmpeg.la \
+				$(THIS_LIB_LIBS)
+
+
+
+
+
+
+
+				
+
+
+
+
+
+
+
+
+
diff --git a/mpeglib/example/yaf/yafyuv/yuv_control.cpp b/mpeglib/example/yaf/yafyuv/yuv_control.cpp
new file mode 100644
index 00000000..b62e50cf
--- /dev/null
+++ b/mpeglib/example/yaf/yafyuv/yuv_control.cpp
@@ -0,0 +1,207 @@
+/*
+  generic interactive controller 
+  Copyright (C) 1998  Martin Vogt
+
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of the GNU Library General Public License as published by
+  the Free Software Foundation.
+
+  For more information look at the file COPYRIGHT in this package
+
+ */
+
+
+
+// Set for local include
+#define DIRECT_INCLUDE
+
+#include "../yafcore/yaf_control.h"
+#include "../yafxplayer/inputDecoderYAF.h"
+
+#include <iostream>
+using namespace std;
+
+#include <math.h>
+
+
+
+// we include our plugin here
+#include "../../../lib/yuv/yuvPlugin.h"
+
+#if defined(HAVE_GETOPT_H) 
+#include <getopt.h>
+#endif
+
+
+void control_yuv(InputInterface* input,OutputInterface* output,
+		 InputDecoder* decoder) {
+
+
+  cout<< "Command:0 Msg:protocol yaf-0.1" << endl;
+  cout<< "Command:0 Msg:implements xplayer" << endl;
+  cout<< "Command:0 Msg:decoder yuv Version:0.0.2" << endl;
+  cout<< "Command:0 Msg:mimetypes vide/yuv1;" << endl;
+  cout<< "Command:0 Msg:comment yuv Plugin by Martin Vogt" << endl;
+  cout<< "Command:0 Msg:comment yaf port by [email protected]"<<endl;
+  cout<< "Command:0 Msg:comment enter 'help' " << endl;
+ 
+ 
+  
+  yaf_control(input,output,decoder);
+}
+
+
+void usage() {
+  cout << "yaf-yuv is a interactive frontend for the still image decoder"
+       <<endl;
+  cout << "Usage : yaf-yuv [w:g:y:f:hr:] <file.raw> [url]"<<endl;
+  cout << endl;
+  cout << "-w : width of raw yuv stream in pixel"<<endl;
+  cout << "-g : height of raw yuv stream in pixel"<<endl;
+  cout << "-h : help"<<endl;
+  cout << "-y : set image Format:"<<endl;
+  cout << "                      1   : yuv lum/Cr/Cb"<<endl;
+  cout << "                      2   : yuv lum/Cb/Cr"<<endl;
+  cout << "                      3   : rgb 24 BIT"<<endl;
+  cout << "                      4   : rgb 24 BIT (flipped)"<<endl;
+
+  cout << "-f : [1..n] frames per second"<<endl;
+
+  cout << endl;
+  cout << "THIS SOFTWARE COMES WITH ABSOLUTELY NO WARRANTY! " \
+       << "USE AT YOUR OWN RISK!"<<endl;
+  cout << endl;
+  cout << "for more help type 'help' in interactive mode"<<endl;
+}
+
+
+int readFormat(int* w,int* h,char* filename) {
+  char formatFileName[100];
+  FILE* file=NULL;
+  snprintf(formatFileName,100,"%s.format",filename);
+  cout << "open:"<<formatFileName<<endl;
+  file=fopen(formatFileName,"r");
+  if (file == NULL) {
+    cout << "no format file found"<<endl;
+    return false;
+  }
+
+  if (fscanf(file,"Version 0.1\nw:%dh:%d\n",w,h)==2) {
+    cout << "read ! w:"<<*w<<"h:"<<*h<<endl;
+    return true;
+  }
+
+  
+  cout << "format file mismatch"<<endl;
+  return false;
+}
+
+
+int main(int argc, char** argv) {
+  int c;
+  int lInternalAudio=true;
+  char* width=NULL;
+  char* height=NULL;
+  int fps=1;
+
+  pow(6.0,3.0);            // fixes bug in __math.h
+
+
+
+  
+  InputInterface* input=new InputInterface();
+
+  OutputInterface output(&cout);
+
+  YafOutputStream* yafOutput=new YafOutputStream(input);
+
+  YUVPlugin* plugin=new YUVPlugin();
+
+  plugin->setOutputPlugin(yafOutput);
+  InputDecoderYAF decoder(plugin,yafOutput);
+  
+
+
+  while(1) { 
+    c = getopt (argc, argv, "w:g:y:hf:");
+    if (c == -1) break;
+    switch(c) {
+    case 'a': {    
+      lInternalAudio=false;
+      break;
+    }
+    case 'h': {
+      cout << "query for help"<<endl;
+      usage();
+      exit(0);
+    }
+    case 'w': {    
+      width=optarg;
+      printf("setting width:%s\n",width);
+      break;
+    }
+    case 'f': {    
+      fps=atoi(optarg);
+      if (fps <= 0) {
+	cout << "wrong fps. must be > 0"<<endl;
+	exit(0);
+      }
+      break;
+    }
+    case 'g': {
+      height=optarg;
+      printf("setting height:%s\n",height);
+      break;
+    }
+    case 'y': {
+      cout << "config:imageType:"<<optarg<<endl;
+      plugin->config("imageType",optarg,NULL);
+      break;
+    }
+
+    default:
+      printf ("?? getopt returned character code 0%o ??\n", c);
+      usage();
+      exit(-1);
+    }
+  }
+  if (optind < argc ) {
+    Buffer buffer(300);
+    buffer.append("open ");
+    buffer.append(argv[optind]);
+    buffer.append("\n");
+    
+    input->addInputLine(&buffer);
+
+  }
+  if ((width == NULL) || (height == NULL)) {
+    int w;
+    int h;
+    cout << "automatic try to read a .format file"<<endl;
+    if (readFormat(&w,&h,argv[optind]) == false) {
+      cout << "no format specified"<<endl;
+      exit(-1);
+    }
+    width=new char[20];
+    height=new char[20];
+    snprintf(width,20,"%d",w);
+    snprintf(height,20,"%d",h);
+  }
+
+  char* picPerSec=new char[20];
+  snprintf(picPerSec,20,"%d",fps);
+  
+ 
+  plugin->config("picPerSec",picPerSec,NULL);
+  plugin->config("height",height,NULL);
+  plugin->config("width",width,NULL);
+ 
+
+  yafOutput->internalDevice(lInternalAudio);
+  control_yuv(input,&output,&decoder);
+  delete plugin;
+  delete yafOutput;
+  delete input;
+
+}
+