Code:
(void) jpeg_read_scanlines(&cinfo, buffer, 1);

Code:
/* Assume put_scanline_someplace wants a pointer and sample count. */
    put_scanline_someplace(buffer[0], row_stride);

Code:

struct jpeg_decompress_struct dinfo;
int jpg_rdata(int fd, FILE* fd, byte *data) // data points to ALLOCATED MEMORY
{
    byte *c_data;
    ERR err;
    SRC src;
    int stride, jrc;

    fseek(fd, 0L, SEEK_SET);

    dinfo.err = jpeg_std_error((struct jpeg_error_mgr *)&err);
    dinfo.err->output_message = my_output_message;
    dinfo.err->error_exit = my_error_exit;
    if ( (jrc = setjmp(err.setjmp_buffer)) != 0 )
        {
        /* If we get here, the JPEG code has signaled an error.
         * We need to clean up the JPEG object and return.
         */
        jpeg_destroy_decompress(&dinfo);
        return jrc;
        }

    jpeg_create_decompress(&dinfo);

    /* Use a file descriptor based source manager */
    init_fd_src(&dinfo, fd, &src);

    /* Read file header, set default decompression parameters */
    (void) jpeg_read_header(&dinfo, TRUE);

    /* Start decompressor */
    (void) jpeg_start_decompress(&dinfo);
    /* We can ignore the return value since suspension is not possible
     * with the stdio data source.
     */

    stride = dinfo.output_width * dinfo.output_components;

    /* Process data */
    c_data = data + (dinfo.output_height - 1) * stride;
    /* Here we use the library's state variable dinfo.output_scanline as the
     * loop counter, so that we don't have to keep track ourselves.
     */
    while ( dinfo.output_scanline < dinfo.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.
         */
        int num_scanlines;
        JSAMPROW sarray[1];  /* array of pointers to rows */
        sarray[0] = c_data;
        num_scanlines = jpeg_read_scanlines(&dinfo, sarray, 1);
        c_data -= num_scanlines * stride;
        }

    (void) jpeg_finish_decompress(&dinfo);
    /* We can ignore the return value since suspension is not possible
     * with the file descriptor data source.
     */

    /* This is an important step since it will release a good deal of memory. */
    jpeg_destroy_decompress(&dinfo);

    /* At this point you may want to check to see whether any corrupt-data
     * warnings occurred (test whether err.pub.num_warnings is nonzero).
     */
    return 1;
}