PictureSource.java

/*
 * This RBNB object supplies a "psudo video" stream by sending
 * a series of JPG images.
 * 
 * Created on Feb 5, 2004
 *  Derived from Axis Source (Dec 12, 2003) by Jason P. Hanley
 */
package org.nees.rbnb;

import java.awt.Image;
import java.awt.Toolkit;
import java.awt.MediaTracker;
import java.awt.Component;
import java.net.URL;

import java.io.FileInputStream;
import java.io.File;
import java.io.IOException;

import java.net.URL;
import java.net.URLConnection;
import java.net.MalformedURLException;

import com.rbnb.sapi.ChannelMap;
import com.rbnb.sapi.Source;
import com.rbnb.sapi.SAPIException;

//import COM.Creare.Utility.ArgHandler; //for argument parsing
import com.rbnb.utility.ArgHandler; //for argument parsing

public class PictureSource extends RBNBBase{
    private byte[][] fileBuffer;
    private String[] text;
    private int current = 0;
    private Thread timerThread = null;
    private int channelId = -1;
    private Source source = null;   
    private ChannelMap cmap = null;

    private static final String SOURCE_NAME_NAME = "SourceName";
    private static final String SOURCE_NAME = "FakeVideoSource";
    private static final String CHANNEL_NAME_NAME = "ChannelName";
    private static final String CHANNEL_NAME = "Duke";
    private static final String PICTURE_PATH_NAME = "PicturePath";
    private static final String PICTURE_PATH = "./duke/Duke";
    private static final String PICTURE_COUNT_NAME = "PictureCount";
    private static final int PICTURE_COUNT = 10;
    private static final String TIMER_INTERVAL_NAME = "TimerInterval";
    private static final long TIMER_INTERVAL=1000;
    private static final String CACHE_SIZE_NAME = "CacheSize";  
    private static final int DEFAULT_CACHE_SIZE=30;

    private String sourceName = SOURCE_NAME;
    private String channelName = CHANNEL_NAME;
    private String picturePath = PICTURE_PATH;
    private int pictureCount = PICTURE_COUNT;
    private long timerInterval = TIMER_INTERVAL;
    private int cacheSize = DEFAULT_CACHE_SIZE;
    
    private boolean connected = false;
    private boolean running = false;
    
    private String[] parameterNameArray;
    private String[] parameterTypeArray;
    private Object[] parameterDefaultArray;

    public static void main(String[] args) {
        // start from command line
        PictureSource p = new PictureSource();
        if (p.setArgs(args)) p.start();
    }
    
    public PictureSource()
    {
        setParamterArrays();
        initialize();
    }

    public void printUsage() {
        System.out.println("PictureSource: usage is...");       
        System.out.println("PictureSource ");
        super.printUsage();
        System.out.println("[-N source_name *FakeVideoSource] ");
        System.out.println("[-C channel_name *Duke] ");
        System.out.println("[-P pathname_for_pictures *./duke/Duke]");
        System.out.println("[-K picture_count *10]");
        System.out.println("[-t timer_interval *1000]");
        System.out.println("[-z cache size *" + DEFAULT_CACHE_SIZE + "]");
        System.out.println();
    }

    protected void setParamterArrays() {

        String [] pNameArray = super.getBaseParameterNameArray();
        String [] pTypeArray = super.getBaseParameterTypeArray();
        Object [] pDefaultArray = super.getBaseParameterDefaultArray();
        
        int base = pNameArray.length;
        int numberOfparameters = 6;
        parameterNameArray = new String[base + numberOfparameters];
        parameterTypeArray = new String[base + numberOfparameters];
        parameterDefaultArray = new Object[base + numberOfparameters];
        
        for (int i = 0; i < base; i++)
        {
            parameterNameArray[i] = pNameArray[i];
            parameterTypeArray[i] = pTypeArray[i];
            parameterDefaultArray[i] = pDefaultArray[i];
        }

        parameterNameArray[base + 0] = SOURCE_NAME_NAME;
        parameterTypeArray[base + 0] = RBNBBaseParameterHolder.STRING_TYPE;
        parameterDefaultArray[base + 0] = new String(SOURCE_NAME);      

        parameterNameArray[base + 1] = CHANNEL_NAME_NAME;
        parameterTypeArray[base + 1] = RBNBBaseParameterHolder.STRING_TYPE;
        parameterDefaultArray[base + 1] = new String(CHANNEL_NAME);     

        parameterNameArray[base + 2] = TIMER_INTERVAL_NAME;
        parameterTypeArray[base + 2] = RBNBBaseParameterHolder.LONG_TYPE;
        parameterDefaultArray[base + 2] = new Long(TIMER_INTERVAL);     

        parameterNameArray[base + 3] = PICTURE_PATH_NAME;
        parameterTypeArray[base + 3] = RBNBBaseParameterHolder.STRING_TYPE;
        parameterDefaultArray[base + 3] = new String(PICTURE_PATH);     

        parameterNameArray[base + 4] = PICTURE_COUNT_NAME;
        parameterTypeArray[base + 4] = RBNBBaseParameterHolder.INTEGER_TYPE;
        parameterDefaultArray[base + 4] = new Integer(PICTURE_COUNT);       

        parameterNameArray[base + 5] = CACHE_SIZE_NAME;
        parameterTypeArray[base + 5] = RBNBBaseParameterHolder.INTEGER_TYPE;
        parameterDefaultArray[base + 5] = new Integer(DEFAULT_CACHE_SIZE);      

    }

    /* (non-Javadoc)
     * @see org.nees.rbnb.RBNBBase#setInstanceArgs(java.lang.String[])
     */
    protected boolean setInstanceArgs(String[] args) throws IllegalArgumentException {
        
        //parse args
        try {
            ArgHandler ah=new ArgHandler(args);
            if (ah.checkFlag('N')) {
                String a=ah.getOption('N');
                if (a!=null) sourceName=a;
            }
            if (ah.checkFlag('C')) {
                String a=ah.getOption('C');
                if (a!=null) channelName=a;
            }
            if (ah.checkFlag('P')) {
                String a=ah.getOption('P');
                if (a!=null) picturePath=a;
            }
            if (ah.checkFlag('K')) {
                String a=ah.getOption('K');
                if (a!=null) pictureCount=Integer.parseInt(a);
            }
            if (ah.checkFlag('t')) {
                String a=ah.getOption('t');
                if (a!=null) timerInterval=Long.parseLong(a);
            }
            if (ah.checkFlag('z')) {
                String a=ah.getOption('z');
                if (a!=null)
                try
                {
                    Integer i =  new Integer(a);
                    int value = i.intValue();
                    cacheSize = value;
                    System.out.println("sizes " + cacheSize + "," + value);
                }
                catch (Exception ignore) {} 
            }
        } catch (Exception e) {
            System.err.println("PictureSource argument exception "+e.getMessage());
            throw new IllegalArgumentException("PictureSource argument exception "+e.getMessage());
        }
        
        System.out.println("Starting PictureSource on " + getServer() + " as " + sourceName);
        System.out.println("  Channel name = " + channelName + "; timer interval = " + timerInterval);
        System.out.println("  Using images " + picturePath + "01.jpg"
                + " through " + picturePath 
                + (pictureCount<10?("0" + pictureCount):("" + pictureCount)) + ".jpg");
        System.out.println("  Use PictureSource -h to see optional parameters");
        return true;
    }
    
    /* (non-Javadoc)
     * @see org.nees.rbnb.RBNBBase#setVariablesFromParameters()
     */
    public void setVariablesFromParameters() {
        super.setBaseVarialbesFromParametes();
        
        sourceName = SOURCE_NAME;
        try{
            Object obj = getValueWithDefault(SOURCE_NAME_NAME, SOURCE_NAME);
            sourceName = (String)obj;
        } catch (Throwable ignore){}

        channelName = CHANNEL_NAME;
        try{
            Object obj = getValueWithDefault(CHANNEL_NAME_NAME, CHANNEL_NAME);
            channelName = (String)obj;
        } catch (Throwable ignore){}

        picturePath = PICTURE_PATH;
        try{
            Object obj = getValueWithDefault(PICTURE_PATH_NAME, PICTURE_PATH);
            picturePath = (String)obj;
        } catch (Throwable ignore){}

        pictureCount = PICTURE_COUNT;
        try{
            Integer i = new Integer(PICTURE_COUNT);
            Object obj = getValueWithDefault(PICTURE_COUNT_NAME, i);
            pictureCount = ((Integer)obj).intValue();
        } catch (Throwable ignore){}

        timerInterval = TIMER_INTERVAL;
        try{
            Long l = new Long(TIMER_INTERVAL);
            Object obj = getValueWithDefault(TIMER_INTERVAL_NAME, l);
            timerInterval = ((Long)obj).longValue();
        } catch (Throwable ignore){}

        cacheSize = DEFAULT_CACHE_SIZE;
        try{
            Integer i = new Integer(DEFAULT_CACHE_SIZE);
            Object obj = getValueWithDefault(CACHE_SIZE_NAME, i);
            cacheSize = ((Integer)obj).intValue();
        } catch (Throwable ignore){}

        System.out.println("Starting PictureSource on " + getServer() + " as " + sourceName);
        System.out.println("  Channel name = " + channelName + "; timer interval = " + timerInterval);
        System.out.println("  Using images " + picturePath + "01.jpg"
                + " through " + picturePath 
                + (pictureCount<10?("0" + pictureCount):("" + pictureCount)) + ".jpg");
        System.out.println("  Use PictureSource -h to see optional parameters");
    }

    public boolean loadImageFiles() {
        fileBuffer = new byte[10][];
        text = new String[10];

        current = 0;
        
        URL fig = null;
        try {
            for (int i = 1; i < (pictureCount + 1); i++ )
            {
                text[i-1] = picturePath + ((i<10)?("0" + i):(""+i)) + ".jpg";
            }
            
            for (int i = 0; i < text.length; i++)
            {
                File f = new File(text[i]);
                FileInputStream in = new FileInputStream(f);
                int fileLength = (int)f.length();
                byte[] buffer = new byte[fileLength];
                in.read(buffer);
                fileBuffer[i] = buffer;
                System.out.println("Read " + text[i] + " for " + fileLength + " bytes");
            }
    
            return true;
        }
        catch (Exception e)
        {
            System.out.println("Loading Image files failed at " + current + "; " + e);
            e.printStackTrace();
            return false;
        }
    }

    private byte[] next()
    {
        byte[] ret = null;
        int l = (int)fileBuffer.length;
        current = ( current + 1 ) % l;
        ret = fileBuffer[current];
        return ret;
    }
    
    private boolean exec()
    {
        connect();
        if (!connected) return false;
        startThread();
        return true;
    }
    
    private void connect() {
        connected = false;
        source=new Source(cacheSize, "none", 0);
        try {
            source.OpenRBNBConnection(getServer(), sourceName);
        } catch (SAPIException e) {
            System.err.println("Failed to connect to RBNB server.");
            source = null;
            return;
        }

        cmap = new ChannelMap();
        cmap.PutTimeAuto("timeofday");
        channelId = -1;
        try {
            channelId = cmap.Add(channelName);
        } catch (SAPIException e) {
            System.err.println("Failed to add video channel to channel map.");
            disconnect();
            return;
        }
        cmap.PutMime(channelId, "image/jpeg");
        System.out.println("ChannelId = " + channelId);
        connected = true;
    } // readySource

    private void startThread() {
        // Use this inner class to hide the public run method
        Runnable r = new Runnable() {
            public void run() {
                runWork();
            }
        };
        running = true;
        timerThread = new Thread(r, "Timer");
        timerThread.start();
        System.out.println("PictureSource: Started thread.");
    }

    public void stopThread()
    {
        if (!connected) return;
        
        running = false;
        timerThread.interrupt();
        System.out.println("PictureSource: Stopped thread.");
    }

    private void runWork ()
    {
        try
        {
            while(isRunning())
            {
                if (!oneStep()) break;
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    return;
                }
            }
        }
        catch (Throwable t)
        {
            System.out.println("PictureSource: error while running -- " + t);
        }
        if (connected) disconnect();
        running = false;
    }
            
    private boolean oneStep()
    {
        try{
            byte[] imageData = next();
            cmap.PutDataAsByteArray(channelId, imageData);
            source.Flush(cmap);
//          System.out.println("On channel " + channelId + ": sent image file " + text[current] + " for "
//              + imageData.length + " bytes");
        } catch (Exception e){
            System.err.println("Failed to send image " + current);
            e.printStackTrace();
            disconnect();
            return false;
        }
        return true;
    }

    private void disconnect()
    {
        source.CloseRBNBConnection();
        source = null;
        cmap = null;
        connected = false;              
    }
    
    /* (non-Javadoc)
     * @see org.nees.rbnb.RBNBBase#getParameterNameArray()
     */
    public String[] getParameterNameArray() {
        return parameterNameArray;
    }

    /* (non-Javadoc)
     * @see org.nees.rbnb.RBNBBase#getParameterTypeArray()
     */
    public String[] getParameterTypeArray() {
        return parameterTypeArray;
    }

    /* (non-Javadoc)
     * @see org.nees.rbnb.RBNBBase#getParameterDefaultsArray()
     */
    public Object[] getParameterDefaultArray() {
        return parameterDefaultArray;
    }

    public boolean isRunning()
    {
        return (connected && running);
    }

    /* (non-Javadoc)
     * @see org.nees.rbnb.RBNBBase#start()
     */
    public boolean start() {
        if (isRunning()) return false;
        if (connected) disconnect();
        setVariablesFromParameters();
        if (loadImageFiles())
        {
            return exec();
        }
        return false;
    }

    /* (non-Javadoc)
     * @see org.nees.rbnb.RBNBBase#stop()
     */
    public boolean stop() {
        if (!isRunning()) return false;
        stopThread();
        disconnect();
        return true;
    }

}

---