JPEG decoding by giving encoded data in chunks - WinCE
Hello,
I'm trying to develop a program (for WinCE) that can give me decoded data by accepting
input (that is, encoded data - JPEG for example) in chunks. This need arose
because in the case that I'm working on, the whole encoded file is not
available at one go. The stream of encoded data keeps on coming.
I'm using ImgSimple sample code as reference which is available. (available
in %_PUBLICROOT%\GDIEX\SDK\SAMPLES\ImgSinple)
Just to clear upon what exactly I'm trying to get, example given below will
help:
Suppose we have a 320x240 image. and the whole encoded data is not with us
for use. What I need is, that what ever data we have, we pass it to the
decoder and it gives the corresponding decoded data and we start rendering it.
So, the output to user will look something like this:
Step 1: no image can be viewed
Step 2: 320x60 image can be viewed
Step 3: 320x120 image can be viewed
Step 4: 320x180 image can be viewed
Step 5: Full image can be viewed
Now, my query is that is this possible first of all in WinMo? And if it is
possible, am I using the right reference?
In what chunks the input data should be given? Like raw by raw or macro block
by macro block or any other way? Any pointers on how it can be done will be
appreciated.
Thanks in advance.
Tanmay
Re: JPEG decoding by giving encoded data in chunks - WinCE
See the Independent JPEG Group at http://www.ijg.org/
They have developped a library of functions, written in C, decoding jpeg files.
Here an example of code using theses functions.
Code:
#include <setjmp.h>
#include "jpeglib.h"
/* ==============================================================
Routine for JPEG decompression.
Return 1 on success, 0 on error.
N.B. The program should be linked with libjpg.a
============================================================== */
static int read_JPEG_file(char *filename, BYTE *DIBits, int x0, int y0, int w)
{
/* 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 */
char buf[500];
if (DIBits == NULL) return (0);
/* 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) {
sprintf(buf, "JPEG :\nCan't open %s\n", filename);
MessageBox(GetActiveWindow(), buf, "JPEG Error", MB_OK|MB_ICONERROR);
return 0;
}
/* 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)) {
/* 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);
return 0;
}
/* 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);
/* 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. */
/* 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);
/* Assume put_scanline_someplace wants a pointer and sample count. */
// put_scanline_someplace(buffer[0], row_stride);
if (cinfo.output_components == 3) {
// handles only color pictures
j_putRGBScanline(buffer[0], cinfo.output_scanline - 1,
cinfo.output_width, DIBits, x0, y0, w);
}
}
/* 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 1;
}
/* ==============================================================
Store a scanline to our data buffer
============================================================== */
void j_putRGBScanline(BYTE *jpegline, int jpeg_row, int jpeg_width,
BYTE *DIBits, int x0, int y0, int w)
{
long int i_DIBits, i_buffer;
i_DIBits = ((y0 + jpeg_row) * w + x0) * 4;
for (i_buffer = 0; i_buffer < jpeg_width * 3; i_buffer += 3) {
DIBits[i_DIBits++] = *(jpegline + i_buffer + 2);
DIBits[i_DIBits++] = *(jpegline + i_buffer + 1);
DIBits[i_DIBits++] = *(jpegline + i_buffer);
DIBits[i_DIBits++] = 0;
}
}
You can see the loop on every line of the picture in the step 6 of this piece of code. For each line j_putRGBScanline() is called. Here I fill an array named DIBits[], but you could display the pixels right away. You can exit from the loop after 60 lines, and later start again reading the file from the line 60 to 120, etc.
Re: JPEG decoding by giving encoded data in chunks - WinCE
Hey,
Thanks a lot for the reply.
I am using the open source lib currently for JPEG. So, I'm aware of the point that you are mentioning. But I need to move to platform codecs for improving the efficiency. That's why I need to know whether the feature I mentioned is supported in Windows Mobile.
Please let me know if anyone has that info. It would be great if one can redirect me to a documentation by Microsoft which states that chunk based/progressive decoding is supported or not supported.
Thanks,
Tanmay
