--- pdp_v4l.c	2005-01-03 12:04:13.000000000 +0100
+++ pdp_v4l-jpeg.c	2005-01-03 12:03:51.000000000 +0100
@@ -18,7 +18,6 @@
  *
  */
 
-
 #include "pdp_config.h"
 #include "pdp.h"
 #include "pdp_llconv.h"
@@ -52,6 +51,11 @@
 //#endif
 
 
+/* jpeg start */
+#include <jpeglib.h>
+#include <setjmp.h>
+/* jpeg end */
+
 #define DEVICENO 0
 #define NBUF 2
 #define COMPOSITEIN 1
@@ -117,7 +121,213 @@
 
 } t_pdp_v4l;
 
+/* fbar: jpeg start */
+/* for jpeg library - handling buffered input for decompression */
+static void init_source (j_decompress_ptr cinfo) { return; }
+static boolean fill_input_buffer (j_decompress_ptr cinfo) { return 1; }
+static void skip_input_data (j_decompress_ptr cinfo, long num_bytes) {
+  if (num_bytes <= 0) return;
+  cinfo->src->next_input_byte+=num_bytes;
+  cinfo->src->bytes_in_buffer-=num_bytes;
+}
+static boolean resync_to_restart (j_decompress_ptr cinfo, int desired) { return 1; }
+static void term_source (j_decompress_ptr cinfo) { return; }
+
+struct my_error_mgr {
+    struct jpeg_error_mgr pub;	/* "public" fields */
+    jmp_buf setjmp_buffer;	/* for return to caller */
+};
+
+typedef struct my_error_mgr * my_error_ptr;
+
+static void my_error_exit (j_common_ptr cinfo)
+{
+    /* cinfo->err really points to a my_error_mgr struct, so coerce pointer */
+    my_error_ptr myerr = (my_error_ptr) cinfo->err;
+
+    /* Always display the message. */
+    /* We could postpone this until after returning, if we chose. */
+    (*cinfo->err->output_message) (cinfo);
+    
+    /* Return control to the setjmp point */
+    longjmp(myerr->setjmp_buffer, 1);
+}
+
+
+static int load_packet_jpeg(t_pdp_v4l *x, unsigned char * newimage)
+{
+    unsigned char * mydata;
+    x->x_v4l_palette = VIDEO_PALETTE_RGB24;
+    // mydata = x->x_videobuf;
+    mydata = newimage;
+
+    int packet = -1;
+    /* This struct contains the JPEG decompression parameters and pointers to
+     * working space (which is allocated as needed by the JPEG library).
+     */
+    struct jpeg_decompress_struct cinfo;
+
+    /* We use our private extension JPEG error handler.
+     * Note that this struct must live as long as the main JPEG parameter
+     * struct, to avoid dangling-pointer problems.
+     */
+    struct my_error_mgr jerr;
+    
+    /* More stuff */
+    /* FILE * infile;*/		/* source file */ 
+    JSAMPARRAY buffer;		/* Output row buffer */
+    int row_stride;		/* physical row width in output buffer */
+
+    /* In this example we want to open the input file before doing anything else,
+     * so that the setjmp() error recovery below can assume the file is open.
+     * VERY IMPORTANT: use "b" option to fopen() if you are on a machine that
+     * requires it in order to read binary files.
+     */
+
+    /* if ((infile = fopen(filename, "rb")) == NULL) { return packet; } */
+
+    /* Step 1: allocate and initialize JPEG decompression object */
+
+    /* We set up the normal JPEG error routines, then override error_exit. */
+    cinfo.err = jpeg_std_error(&jerr.pub);
+    jerr.pub.error_exit = my_error_exit;
+
+    /* Establish the setjmp return context for my_error_exit to use. */
+    if (setjmp(jerr.setjmp_buffer)) 
+    {
+          error:
+        /* If we get here, the JPEG code has signaled an error.
+         * We need to clean up the JPEG object, close the input file, and return.
+         */
+        jpeg_destroy_decompress(&cinfo);
+        /* fclose(infile); */
+        // post("Error in setjmp");
+        packet = -1;
+        return packet;
+    }
+
+    /* Now we can initialize the JPEG decompression object. */
+    jpeg_create_decompress(&cinfo);
+
+    /* Step 2: specify data source (eg, a file) */
+    /* jpeg_stdio_src(&cinfo, infile); */
+    struct jpeg_source_mgr source;
+    cinfo.src=&source;
+    /* functions for managing jpeg lib's input buffer */
+    source.init_source=init_source;
+    source.fill_input_buffer=fill_input_buffer;
+    source.skip_input_data=skip_input_data;
+    source.resync_to_restart=resync_to_restart;
+    source.term_source=term_source;    
+    // The length / 8 of the JPEG is stored in the first 2 bytes of vmbuffer
+    // char  *framepointer;
+    unsigned short *vmpointer = NULL;
+    // vmpointer = (unsigned short *)( x->x_videobuf + x->x_vmbuf.offsets[x->x_last_frame]);
+    // framepointer= x->x_videobuf + x->x_vmbuf.offsets[x->x_last_frame] + 2;
+    // or:
+    // framepointer= newimage + 2;
+    vmpointer = (unsigned short *) newimage;
+    
+    source.next_input_byte=newimage + 2; //framepointer;
+    source.bytes_in_buffer=(ssize_t)((unsigned int)(vmpointer[0])<<3); // count
+    /* Step 3: read file parameters with jpeg_read_header() */
+    (void) jpeg_read_header(&cinfo, TRUE);
+    /* We can ignore the return value from jpeg_read_header since
+     *   (a) suspension is not possible with the stdio data source, and
+     *   (b) we passed TRUE to reject a tables-only JPEG file as an error.
+     * See libjpeg.doc for more info.
+     */
+
+
+    /* Step 4: set parameters for decompression */
+
+    /* In this example, we don't need to change any of the defaults set by
+     * jpeg_read_header(), so we do nothing here.
+     */
+
+    /* Step 5: Start decompressor */
+
+    (void) jpeg_start_decompress(&cinfo);
+    /* We can ignore the return value since suspension is not possible
+     * with the stdio data source.
+     */
+
+    /* We may need to do some setup of our own at this point before reading
+     * the data.  After jpeg_start_decompress() we have the correct scaled
+     * output image dimensions available, as well as the output colormap
+     * if we asked for color quantization.
+     * In this example, we need to make an output work buffer of the right size.
+     */ 
+
+    /* map cinfo struct to pdp packet */
+/*    int width = cinfo.output_width;
+    int height = cinfo.output_height;
+    int depth = cinfo.output_components;
+    char *encoding;
+    switch(cinfo.out_color_space){
+    case JCS_RGB:  encoding = "rgb"; break;
+    default:
+	goto error;
+    } */
+    // packet = pdp_factory_newpacket(pdp_symbolf("bitmap/%s/%d/%d", encoding, width, height));
+    // if (-1 == packet) goto error;
+    // data == rgbdata from showvideo.c
+    /* unsigned char *data = malloc(height * width * 3); */
+    
+    /* JSAMPLEs per row in output buffer */
+    row_stride = cinfo.output_width * cinfo.output_components;
+    /* Make a one-row-high sample array that will go away when done with image */
+    buffer = (*cinfo.mem->alloc_sarray)
+	((j_common_ptr) &cinfo, JPOOL_IMAGE, row_stride, 1);
+
+    /* Step 6: while (scan lines remain to be read) */
+    /*           jpeg_read_scanlines(...); */
+
+    /* Here we use the library's state variable cinfo.output_scanline as the
+     * loop counter, so that we don't have to keep track ourselves.
+     */
+    while (cinfo.output_scanline < cinfo.output_height) 
+    {
+        /* jpeg_read_scanlines expects an array of pointers to scanlines.
+         * Here the array is only one element long, but you could ask for
+         * more than one scanline at a time if that's more convenient.
+         */
+        (void) jpeg_read_scanlines(&cinfo, buffer, 1);
+        // (void) jpeg_read_scanlines(&cinfo, buffer, cinfo.output_height-cinfo.output_scanline);
+        /* Assume put_scanline_someplace wants a pointer and sample count. */
+        // TODO put_scanline_someplace(buffer[0], row_stride);
+        memcpy(mydata, buffer[0], row_stride);
+        mydata += row_stride;
+    }
+
+    /* Step 7: Finish decompression */
+
+    (void) jpeg_finish_decompress(&cinfo);
+    /* We can ignore the return value since suspension is not possible
+     * with the stdio data source.
+     */
+
+    /* Step 8: Release JPEG decompression object */
+    
+    /* This is an important step since it will release a good deal of memory. */
+    jpeg_destroy_decompress(&cinfo);
+
+    /* After finish_decompress, we can close the input file.
+     * Here we postpone it until after no more JPEG errors are possible,
+     * so as to simplify the setjmp error logic above.  (Actually, I don't
+     * think that jpeg_destroy can do an error exit, but why assume anything...)
+     */
+    /* fclose(infile); */
+
+    /* At this point you may want to check to see whether any corrupt-data
+     * warnings occurred (test whether jerr.pub.num_warnings is nonzero).
+     */
+
+    /* And we're done! */
+    return packet;
+}
 
+/* fbar: jpeg end */
 
 
 
@@ -598,6 +808,7 @@
 
     /* get the address of the "other" frame */
     newimage = x->x_videobuf + x->x_vmbuf.offsets[x->x_last_frame];
+    // load_packet_jpeg(x, newimage);
 
     /* create new packet */
     w = x->x_width;
@@ -635,8 +846,11 @@
     }
 
     data = (short int *) pdp_packet_data(object);
+    
     newimage = x->x_videobuf + x->x_vmbuf.offsets[x->x_frame ^ 0x1];
-
+    load_packet_jpeg(x, newimage);
+    /* fbar: much better: */
+    /* newimage = x->x_videobuf + x->x_vmbuf.offsets[x->x_frame + 2]; */
 
     /* convert data to pdp packet */