/*****************************************************************************
                           jpegdatasource.c
******************************************************************************
   This is the data source manager that Jpegtopnm supplies to the JPEG
   library.  The Jpeg library uses this object to get JPEG input.

   This data source manager is the same as the Jpeg library's built in
   "stdio" one, except that it looks ahead and one can query it to see
   if there is any data in the stream that the Jpeg library hasn't seen
   yet.  Thus, you can use it in a program that reads multiple JPEG 
   images and know when to stop.  You can also nicely handle completely
   empty input files more gracefully than just crying input error.

   This data source manager does 4K fread() reads and passes 4K buffers 
   to the Jpeg library.  It reads one 4K block ahead, so there is up to
   8K of image buffered at any time.

   By Bryan Henderson, San Jose CA 2002.10.13
*****************************************************************************/

#include <ctype.h>	   
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
/* Note: jpeglib.h prerequires stdlib.h and ctype.h.  It should include them
   itself, but doesn't.
*/
#include <jpeglib.h>

#include "pm_c_util.h"
#include "mallocvar.h"
#include "pnm.h"

#include "jpegdatasource.h"

#define BUFFER_SIZE 4096

struct sourceManager {
    /* The following structure _must_ be the first thing in this structure,
       because the methods below assume the address of the struct
       jpeg_source_mgr is the same as the address of the struct sourceManager.
       The former address is the only information the Jpeg library gives
       these methods to tell them on what source manager object they are
       supposed to operate.
    */
    struct jpeg_source_mgr jpegSourceMgr;
    FILE * ifP;
    bool prematureEof;
        /* We have been asked for data and were unable to comply because
           the file had no more to give (so we supplied EOI markers
           instead).
        */
    JOCTET * currentBuffer;
    JOCTET * nextBuffer;
    unsigned int bytesInNextBuffer;
    JOCTET buffer1[BUFFER_SIZE];
    JOCTET buffer2[BUFFER_SIZE];
};


static void
dsInitSource(j_decompress_ptr const cinfoP) {
/*----------------------------------------------------------------------------
   This is the init_source method for the data source manager the Jpeg
   library uses.
-----------------------------------------------------------------------------*/
    /* The object was created ready to go and remains ready from one image
       to the next.  No per-image initialization is necessary.
    */
}



static const JOCTET jfifEoiMarker[] = {0xff, JPEG_EOI};
    /* An EOI (end of image) marker */


static boolean
dsFillInputBuffer(j_decompress_ptr const cinfoP) {
/*----------------------------------------------------------------------------
   This is the fill_input_buffer method for the data source manager the Jpeg
   library uses.
-----------------------------------------------------------------------------*/
    struct sourceManager * const srcP = (struct sourceManager *) cinfoP->src;

    if (srcP->bytesInNextBuffer == 0) {
        /* The decompressor expects more bytes, but there aren't any, so
           the file is corrupted -- probably truncated.  We want the
           decompressor to decompress whatever it's read so far, so we
           synthesize an EOI marker here, but we also set error state
           in the source manager.  The decompressor will recognize the
           truncation and pad out the image with gray.
        */
        srcP->prematureEof = TRUE;
        
        srcP->jpegSourceMgr.next_input_byte = jfifEoiMarker;
        srcP->jpegSourceMgr.bytes_in_buffer = sizeof(jfifEoiMarker);
    } else {
        /* Rotate the buffers */
        srcP->jpegSourceMgr.next_input_byte = srcP->nextBuffer;
        srcP->jpegSourceMgr.bytes_in_buffer = srcP->bytesInNextBuffer;
        {
            JOCTET * tmp;
            tmp = srcP->nextBuffer;
            srcP->nextBuffer = srcP->currentBuffer;
            srcP->currentBuffer = tmp;
        }

        /* Fill the new "next" buffer */
        srcP->bytesInNextBuffer = 
            fread(srcP->nextBuffer, 1, BUFFER_SIZE, srcP->ifP);
    }
    return TRUE;
}



static void
dsSkipInputData(j_decompress_ptr const cinfoP, long const num_bytes) {
/*----------------------------------------------------------------------------
   This is the skip_input_data method for the data source manager the Jpeg
   library uses.
-----------------------------------------------------------------------------*/
    struct jpeg_source_mgr * const jpegSourceMgrP = cinfoP->src;

    long i;

    for (i = 0; i < num_bytes; ++i) {
        if (jpegSourceMgrP->bytes_in_buffer == 0)
            dsFillInputBuffer(cinfoP);
        ++jpegSourceMgrP->next_input_byte;
        --jpegSourceMgrP->bytes_in_buffer;
    }
}



static void
dsTermSource(j_decompress_ptr const cinfoP) {
/*----------------------------------------------------------------------------
   This is the term_source method for the data source manager the Jpeg
   library uses.
-----------------------------------------------------------------------------*/
    /* We couldn't care less that the Jpeg library is done reading an
       image.  The source manager object remains active and ready for the
       Jpeg library to read the next image.
    */
}



bool
dsDataLeft(struct sourceManager * const srcP) {

    return((srcP->jpegSourceMgr.bytes_in_buffer > 0 ||
            srcP->bytesInNextBuffer > 0));
}



bool
dsPrematureEof(struct sourceManager * const srcP) {

    return srcP->prematureEof;
}



struct sourceManager * 
dsCreateSource(const char * const fileName) {

    struct sourceManager * srcP;

    MALLOCVAR(srcP);
    if (srcP == NULL)
        pm_error("Unable to get memory for the Jpeg library source manager.");

    srcP->ifP = pm_openr(fileName);

    srcP->jpegSourceMgr.init_source = dsInitSource;
    srcP->jpegSourceMgr.fill_input_buffer = dsFillInputBuffer;
    srcP->jpegSourceMgr.skip_input_data = dsSkipInputData;
    srcP->jpegSourceMgr.resync_to_restart = jpeg_resync_to_restart;
    srcP->jpegSourceMgr.term_source = dsTermSource;
    
    srcP->prematureEof = FALSE;
    srcP->currentBuffer = srcP->buffer1;
    srcP->nextBuffer = srcP->buffer2;
    srcP->jpegSourceMgr.bytes_in_buffer = 
        fread(srcP->currentBuffer, 1, BUFFER_SIZE, srcP->ifP);
    srcP->jpegSourceMgr.next_input_byte = srcP->currentBuffer;
    srcP->bytesInNextBuffer = 
        fread(srcP->nextBuffer, 1, BUFFER_SIZE, srcP->ifP);

    return srcP;
}

void
dsDestroySource(struct sourceManager * const srcP) {
    
    pm_close(srcP->ifP);
    free(srcP);

}



struct jpeg_source_mgr *
dsJpegSourceMgr(struct sourceManager * const srcP) {
    return &srcP->jpegSourceMgr;
}
