JPEGThumbnailer.java

package org.nees.rbnb;

import java.awt.geom.AffineTransform;
import java.awt.image.AffineTransformOp;
import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;

import java.util.Date;
import java.util.TimeZone;
import java.text.SimpleDateFormat;

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

import com.sun.image.codec.jpeg.JPEGCodec;
import com.sun.image.codec.jpeg.JPEGEncodeParam;
import com.sun.image.codec.jpeg.JPEGImageDecoder;
import com.sun.image.codec.jpeg.JPEGImageEncoder;

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

public class JPEGThumbnailer extends RBNBBase {

    public JPEGThumbnailer() {      
        setParamterArrays();
        initialize();
    }

    private final static String DEFAULT_RBNB_OUTPUT_NAME_NAME = "SourceName";
    private final static String DEFAULT_RBNB_OUTPUT_NAME = "TSource";
    private final static String DEFAULT_RBNB_OUTPUT_CHANNEL_NAME = "ChannelName";
    private final static String DEFAULT_RBNB_OUTPUT_CHANNEL = "thumbnail.jpg";
    private final static String DEFAULT_RBNB_SINK_NAME_NAME = "SinkName";   
    private final static String DEFAULT_RBNB_SINK_NAME = "JPEGThumbanilerSink";
    private final static String REQUIRED_INPUT_PATH_NAME = "RequiredInputPath";
    private final static String REQUIRED_INPUT_PATH = "";
    private final static String DEFAULT_SAMPLE_RATE_NAME = "SampleRate";
    private final static double DEFAULT_SAMPLE_RATE = 1.0; // secondes
    private static final String CACHE_SIZE_NAME = "CacheSize";  
    private static final int DEFAULT_CACHE_SIZE=10;

    private static final SimpleDateFormat DATE_FORMAT = new SimpleDateFormat("MMM d, yyyy h:mm:ss aa");
    private static final TimeZone TZ = TimeZone.getTimeZone("GMT");

    static
    {
        DATE_FORMAT.setTimeZone(TZ);
    }

    private String rbnbSourceName = DEFAULT_RBNB_OUTPUT_NAME;
    private String rbnbSourceChannel = DEFAULT_RBNB_OUTPUT_CHANNEL;
    
    private String rbnbSinkName = DEFAULT_RBNB_SINK_NAME;
    
    private String rbnbInputPath = null; // required

    private double outputSampleRate = DEFAULT_SAMPLE_RATE; // seconds

    private int cacheSize = DEFAULT_CACHE_SIZE;
    
    private String[] parameterNameArray;
    private String[] parameterTypeArray;
    private Object[] parameterDefaultArray;
    
    Sink sink;
    Source source;
    ChannelMap getmap;
    ChannelMap reqmap;
    ChannelMap cmap;
    int outputChannelIndex;
    int inputChannelIndex;

    private boolean connected = false;
    Thread theThread;
    boolean runit = false;
    
    public void printUsage()
    {
        System.out.println("Usage for JPEGThumbnailer...");
        super.printUsage();
        System.out.println("  -v RBNB Sink path for input video (required) ");
        System.out.println("  [-s RBNB Source (output) Name *" + DEFAULT_RBNB_OUTPUT_NAME + "]");
        System.out.println("  [-c RBNB Source (output) Channel *" + DEFAULT_RBNB_OUTPUT_CHANNEL + "]");
        System.out.println("  [-f desired output frame rate (in seconds) *" + DEFAULT_SAMPLE_RATE + "]");
        System.out.println("  [-z cache size *" + 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('s')) {
                String a=ah.getOption('s');
                if (a!=null) rbnbSourceName=a;
            }
            if (ah.checkFlag('c')) {
                String a=ah.getOption('c');
                if (a!=null) rbnbSourceChannel=a;
            }
            if (ah.checkFlag('v')) {
                String a=ah.getOption('v');
                if (a!=null) rbnbInputPath=a;
            }
            if (ah.checkFlag('f')) {
                String a=ah.getOption('f');
                if (a!=null) outputSampleRate = Double.parseDouble(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;
                }
                catch (Exception ignore) {} 
            }
        } catch (Exception e) {
            System.err.println("JPEGThumbnailer argument exception "+e.getMessage());
            e.printStackTrace();
            throw new IllegalArgumentException("JPEGThumbnailer argument exception "+e.getMessage());
        }

        if ((rbnbInputPath == null) || (rbnbInputPath.equals("")))
        {
            System.err.println("The source/channel path for the video source is required. "
                + "Use JPEGThumbnailer -h for help");
            return false;
        }

        return true;
    }

    private void connect()
    {
        source = new Source(cacheSize, "none", 0);
        try {
            source.OpenRBNBConnection(getServer(), rbnbSourceName);
        } catch (SAPIException e) {
            System.err.println("Failed to connect to RBNB server for source.");
            e.printStackTrace();
            return;             
        }           
    
        // select channel to output data to
        cmap = new ChannelMap();
        outputChannelIndex = -1;
        try {
            outputChannelIndex = cmap.Add(rbnbSourceChannel);
        } catch (SAPIException e) {
            System.err.println("Failed to add output channel to channel map.");
            e.printStackTrace();
            return;             
        }           
        cmap.PutMime(outputChannelIndex, "image/jpeg");         
                    
        // The Sink to get the source images
        sink = new Sink();
        reqmap = new ChannelMap();
        inputChannelIndex = -1;
        try
        {
            // connect and set up with monitoring 
            sink.OpenRBNBConnection(getServer(), rbnbSinkName);
            inputChannelIndex = reqmap.Add(rbnbInputPath);
            sink.Monitor(reqmap,0);
            System.out.println("JPGThumNailer: Connection made to server = "
                + getServer() + " as " + rbnbSinkName 
                + " requesting " + rbnbInputPath + ".");
        }
        catch (SAPIException se)
        {
            se.printStackTrace();
            return;
        }
        
        connected = true;

    }
    
    private void disconnect()
    {
        sink.CloseRBNBConnection();
        sink = null;
        source.CloseRBNBConnection();
        source = null;
        connected = false;
    }
        
    private void execute() {

        byte[] imageData;
        double startTime = 0;
        double durationTime = 0;
        long sleepTime = (long) (1000.0 * outputSampleRate); // milliseconds
        long lastTime = System.currentTimeMillis();
        long actualSleepTime;
        while (true) { //loop forever, receiving JPEG frames
            //adjsut sleep time by how long the look took
            actualSleepTime = sleepTime - (System.currentTimeMillis() - lastTime);
            if (actualSleepTime < 0) actualSleepTime = 0;
            try { Thread.sleep(actualSleepTime); } catch (Exception ignore) {}
            lastTime = System.currentTimeMillis();
            // see if any data is available from source
            getmap = null;
            try {
                getmap = sink.Fetch(0);
            } catch (SAPIException e) {
                System.err.println("Failed to fetch input data, retrying.");
                continue;
            }                   
                
            // no data received, try again
            if (getmap.GetIfFetchTimedOut()) {
                System.err.println("Failed to fetch input data, retrying.");
                continue;
            }
                        
            startTime = getmap.GetTimeStart(0);
            durationTime = getmap.GetTimeDuration(0);
            imageData = getmap.GetData(0);

            JPEGImageDecoder decoder = JPEGCodec.createJPEGDecoder(new ByteArrayInputStream(imageData));
    
            // decode JPEG image to raw image
            BufferedImage bi;
            try {
                bi = decoder.decodeAsBufferedImage();
            } catch (IOException e){
                System.err.println("Failed to decode input JPEG image, skipping.");
                continue;
            }

            // scale both width and height by 0.5
            AffineTransformOp op = new AffineTransformOp(AffineTransform.getScaleInstance(0.5, 0.5), null);
            bi = op.filter(bi, null);
            
            // encode scaled image as JPEG image                
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(out);
            JPEGEncodeParam param = encoder.getDefaultJPEGEncodeParam(bi);
            param.setQuality(0.75f, false);         
            try {
                encoder.encode(bi, param);
            } catch (IOException e) {
                System.err.println("Failed to encode output JPEG image, skipping.");
                continue;
            }               

            // get JPEG image data as byte array
            imageData = out.toByteArray();

            // put data in channel map, preserving original time stamp
            try {
                cmap.PutTime(startTime, durationTime);
                cmap.PutDataAsByteArray(outputChannelIndex, imageData);
            } catch (SAPIException e) {
                System.err.println("Failed to put output data to channel map, skipping.");
                continue;               
            }   
            long unixTime = (long)(startTime * 1000.0); // convert sec to millisec
            String time = DATE_FORMAT.format(new Date(unixTime));
            // System.out.println("Thumbnail sent for " + time + " GMT)");
            
            // send data to RBNB server
            try {
                source.Flush(cmap, true);
            } catch (SAPIException e) {
                System.err.println("Failed to flush output data to server, skipping.");
                continue;               
            }       
        }
    }

    public static void main(String[] args) {
        JPEGThumbnailer t = new JPEGThumbnailer();
        if (t.setArgs(args))
        {
            t.connect();
            t.startThread();
        }
    }

    public void startThread()
    {
        
        if (!connected) return;
        
        // Use this inner class to hide the public run method
        Runnable r = new Runnable() {
            public void run() {
              runWork();
            }
        };
        runit = true;
        theThread = new Thread(r, "Timer");
        theThread.start();
        System.out.println("WalkerSource: Started thread.");
    }

    public void stopThread()
    {
        if (!connected) return;
        
        runit = false;
        theThread.interrupt();
        System.out.println("WalkerSource: Stopped thread.");
    }
    
    private void runWork ()
    {
        execute();
    }
    
    public boolean isRunning()
    {
        return (connected && runit);
    }

    /* (non-Javadoc)
     * @see org.nees.rbnb.RBNBBase#setParamterArrays()
     */
    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] = DEFAULT_RBNB_OUTPUT_NAME_NAME;
        parameterTypeArray[base + 0] = RBNBBaseParameterHolder.STRING_TYPE;
        parameterDefaultArray[base + 0] = new String(DEFAULT_RBNB_OUTPUT_NAME);     

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

        parameterNameArray[base + 2] = DEFAULT_RBNB_SINK_NAME_NAME;
        parameterTypeArray[base + 2] = RBNBBaseParameterHolder.STRING_TYPE;
        parameterDefaultArray[base + 2] = new String(DEFAULT_RBNB_SINK_NAME);

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

        parameterNameArray[base + 4] = DEFAULT_SAMPLE_RATE_NAME;
        parameterTypeArray[base + 4] = RBNBBaseParameterHolder.DOUBLE_TYPE;
        parameterDefaultArray[base + 4] = new Double(DEFAULT_SAMPLE_RATE);      
        
        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#setVariablesFromParameters()
     */
    public void setVariablesFromParameters() {
        super.setBaseVarialbesFromParametes();

        rbnbSourceName = DEFAULT_RBNB_OUTPUT_NAME;
        try{
            Object obj = getValueWithDefault(DEFAULT_RBNB_OUTPUT_NAME_NAME, DEFAULT_RBNB_OUTPUT_NAME);
            rbnbSourceName = (String)obj;
        } catch (Throwable ignore){}

        rbnbSourceChannel = DEFAULT_RBNB_OUTPUT_CHANNEL;
        try{
            Object obj = getValueWithDefault(DEFAULT_RBNB_OUTPUT_CHANNEL_NAME, DEFAULT_RBNB_OUTPUT_CHANNEL);
            rbnbSourceChannel = (String)obj;
        } catch (Throwable ignore){}
        
        rbnbSinkName = DEFAULT_RBNB_SINK_NAME;
        try{
            Object obj = getValueWithDefault(DEFAULT_RBNB_SINK_NAME_NAME, DEFAULT_RBNB_SINK_NAME);
            rbnbSinkName = (String)obj;
        } catch (Throwable ignore){}

        rbnbInputPath = REQUIRED_INPUT_PATH;
        try{
            Object obj = getValueWithDefault(REQUIRED_INPUT_PATH_NAME, REQUIRED_INPUT_PATH);
            rbnbInputPath = (String)obj;
        } catch (Throwable ignore){}

        outputSampleRate = DEFAULT_SAMPLE_RATE;
        try{
            Double d = new Double(DEFAULT_SAMPLE_RATE);
            Object obj = getValueWithDefault(DEFAULT_SAMPLE_RATE_NAME, d);
            outputSampleRate = ((Double)obj).doubleValue();
        } 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){}

    }

    /* (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#getParameterDefaultArray()
     */
    public Object[] getParameterDefaultArray() {
        return parameterDefaultArray;
    }

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

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

---