Roedy Green schrieb:

Actually it seems to be an object of the type
OSXImage
which shoudln't surprise since I'm using Mac Os X 10.4   :)
It offers a method named
getBufferedImage
which indeed delivers what it promises. However, it still doesn't run
that fast and I wonder if it isn't a different problem than jpeg decoding.

I might post the critical sourcecode parts, but they are pretty big.
All in all, my program has 3 Threads:

- 2 Threads for decoding the camera images
- 1 Thread for drawing to screen

This is the run Method of the camera threads:

public void run()
{
        //test if still connected
        if(!connected)
            return;
               
           
        try
        {
            //decode stream
            if(connected)
            {
                                                    while(!Thread.currentThread().isInterrupted())
            {       
                //BufferedImage. Can be accessed from
                //outside via getLatestImage() method
                image = null;       
                   
                String header;
                int k = 0;

                   do
                      header = datainstream.readLine();
                   while(++k < 3);
       
                   datainstream.readByte();
                   int j = (new Integer(header.substring("Content-Length:
".length()))).intValue();   
                   datainstream.readByte();   
                   byte abyte1[] = new byte[j + 2];
                   datainstream.readFully(abyte1, 0, j + 2);       
                   datainstream.readLine();
               //header decoding ends here
       
       
                   //abyte1 contains the raw Jfif data now which can be
decoded by the toolkit
                   Image i = Toolkit.getDefaultToolkit().createImage(abyte1,
0,j+2);
                   //Thread.currentThread().sleep(1000);
                   //System.out.println(o.toString());
       

               //I have to use MediaTracker, or the image drawn later is all white
                   MediaTracker tracker = new MediaTracker(new Frame());
                       tracker.addImage(i,0);
                  
                       try {
                       tracker.waitForAll();
                       } catch(InterruptedException iex)
                       {
                           iex.printStackTrace();
                       }
                      
                       tracker.removeImage(i);
       
               //we know that the image is from type apple.awt.OSXImage
                   image = ((apple.awt.OSXImage)i).getBufferedImage();
       
               //invokes stateChanged() methods on all objects that are
interested in the images
                   fireChange();
       
       
                   //decodeNext = false;
                   //((apple.awt.OSXImage)o).preload(this);
       
                   
                }
            }
            catch(Exception ex)
            {
                ex.printStackTrace();
            }
            finally
            {
               
                try {
                datainstream.close();
                } catch(Exception ex)
                {
                    ex.printStackTrace();
                }
            }
}

So the thread calls method stateChanged() via fireChange() on another
object which shows interest in the images. It looks like this:

class MainProgram
extends Frame
implements Runnable,ChangeListener
{

<.....>

BufferedImage currentLeftImage,currentRightImage;
Runnable drawThread;

CameraCanvas leftCameraCanvas = null;
CameraCanvas rightCameraCanvas = null;

<.....>

public void stateChanged(ChangeEvent e)
{
           
            if(e.getSource().equals(leftCamera))
            {
     
            currentLeftImage = leftCamera.getLatestImage();
                       
       
            }
            if(e.getSource().equals(rightCamera))
            {
               
               
            currentRightImage = rightCamera.getLatestImage();
                   
               
            }
           
        //invoke the drawing thread
            EventQueue.invokeLater(drawThread);
           
}

}

The drawing thread resides on the same class and looks like this

drawThread = new Runnable()
{
           
            public void run()
            {
                if(!readyToDraw)
                    return;
               
                repaint();
               
                try {
                Thread.currentThread().sleep(1);
                } catch(InterruptedException iex)
                {
                    iex.printStackTrace();
                }
               
            }
};

This class represents also the main window. It has 2 Canvases,
CameraCanvas leftCameraCanvas = null;
CameraCanvas rightCameraCanvas = null;

This is the paint() Method of MainProgram that is called by the
drawThread thread

 public void paint(Graphics g)
 {
           
        leftCameraCanvas.SetImage(currentLeftImage);
        rightCameraCanvas.SetImage(currentRightImage);
        leftCameraCanvas.repaint();
        rightCameraCanvas.repaint();
 }

And finally, the source of the CameraCanvas class:

public class CameraCanvas extends Canvas
{
    private BufferedImage image = null;
   
    public void paint(Graphics g)
    {
       
        if(image !=null)
        g.drawImage(image,0,0,getWidth(),getHeight(),null);
       
    }
   
    public void SetImage(BufferedImage i)
    {
        image = i;
    }
}

Maybe you have an idea. I can send you the sourcecode files directly if
you need and want to.

Java already uses free jpeg decoder written in C - libjpeg.

I know about that implementation. The interesting point here is that
they directly take the abstract image object produced by
Toolkit.getDefaultToolkit().createImage
and pass it to drawimage in the paint method of the displaying frame.
For some reason, this works perfectly even without a media tracker to
ensure that the images are fully loaded before drawing.

Richard Wheeldon schrieb:

Would you mind sending me the url (if you have it) ?
Maybe I can learn a few things from it. tx