JPEGImportFilter Class Reference

Provides a JPEG import filter using the IJG JPEG LIBRARY. More...

#include <imjpeg.h>

Inheritance diagram for JPEGImportFilter:

List of all members.

Public Member Functions
	JPEGImportFilter ()
	Default constructor for a JPEGFilter object.
	~JPEGImportFilter ()
	Default constructor for a JPEGFilter object.
virtual BOOL	Init ()
	Initializes the JPEGImportFilter class.
virtual INT32	HowCompatible (PathName &Filename, ADDR HeaderStart, UINT32 HeaderSize, UINT32 FileSize)
	Overrides the Filter class member to determine if the given file is reckoned to be a JPEG.
virtual BOOL	ReadFromFile (OILBitmap *pOilBitmap, BaseCamelotFilter *pFilter, CCLexFile *pFile, BOOL IsCompressed)
	Entry point for Native File Format stuff Actually does the process of reading a bitmap from a file. Inherited classes override this to read in different file formats. It is used by the web/native filters to pull out a bitmap definition from inside a bitmap definition record.
virtual BOOL	ReadFromFile (OILBitmap *pOilBitmap)
	Actually does the process of reading a bitmap from a file. Inherited classes override this to read in different file formats. JPEG reads a JPEG file.
Static Public Member Functions
static BOOL	GetImportAt96dpi ()
static void	SetImportAt96dpi (BOOL fImportAt96)
Protected Member Functions
BOOL	DoFilter (CCFile *pInputFile, OILBitmap *pOilBitmap)
	Provides the main processing point for the JPEG import. Called by the external interface.
virtual BOOL	PrepareFilterForOperation ()
	Default constructor for a JPEGFilter object.
virtual BitmapImportOptions *	GetImportOptions ()
	Overrides the BaseBitmapFilter::GetImportOptions to This will read the source datastream header markers, up to the beginning.
virtual BOOL	IsFormatLossy () const
	The JPEGImportFilter imports a lossy format & therefore always returns TRUE See Also: BaseBitmapFilter::IsFormatLossy().
virtual OFFSET	GetDataStartOffset () const
	Provides information to the BaseBitmapFilter, so that it knows where to start any required BitmapSource. It will only be useful to derived classes that deal with a lossy file format.
virtual BitmapSource *	CreateBitmapSource (OFFSET Size) const
	Provides a BitmapSource for lossy file formats. The JPEGImportFilter returns a JPEGBitmapSource.
virtual void	PrepareForImage (BitmapImportOptions *pOptions)
	Prepares a place for the actual scanlines using the given options.
virtual void	ReadImage ()
	Reads the actual scanlines of the image into this's DIB data members.
virtual void	OnImageCompletion ()
	Once an image has been read, this member should be called to complete any processing associated with that image.
virtual BOOL	OnFilterCompletion ()
	Default constructor for a JPEGFilter object.
void	ReadHeader ()
	This will read the source datastream header markers, up to the beginning of the compressed data proper. On return, the image dimensions and other info have been stored in the JPEG object. The application may wish to consult this information before selecting decompression parameters.
BOOL	SetBitmapResolution ()
	Support function that sets the X & Y pixel densities for the bitmap imported from the JPEG file.
BOOL	ReadPalette ()
	Reads a palette for the image In this case it just generates a greyscale palette for JCS_GRAYSCALE JPEGs. All other colour models are 24-bit.
BOOL	InitErrorHandler ()
	Creates & initializes an error handler for this filter.
BOOL	InitFileHandler ()
	Creates & initializes a source data provider for this filter.
BOOL	InitProgressMonitor ()
	Creates & initializes the Progress bar for the filtering operation.
Protected Attributes
CCFile *	m_pFile
BOOL	m_bOldReportErrors
BOOL	m_bOldThrowExceptions
UINT32	m_uStartOffset
libJPEG::jpeg_decompress_struct	m_cinfo
JPEGErrorManager *	m_pErrorHandler
JPEGDataSource *	m_pSourceHandler
JPEGProgressMonitor *	m_pProgressMonitor
CCLexFile *	m_pFileForProgress
Filter *	m_pFilterForProgress
UINT32	m_uImportSize
LPBITMAPINFO *	m_ppInfo
LPBYTE *	m_ppBytes
UINT32	m_uWidth
UINT32	m_uHeight
UINT32	m_uBitsPerPixel
Static Protected Attributes
static BOOL	m_fImportAt96dpi = m_fImportAt96dpi
Private Member Functions
	CC_DECLARE_MEMDUMP (JPEGImportFilter)

---

Detailed Description

Provides a JPEG import filter using the IJG JPEG LIBRARY.

Author:

Date:

Definition at line 123 of file imjpeg.h.

---

Constructor & Destructor Documentation

JPEGImportFilter::JPEGImportFilter (   )

Default constructor for a JPEGFilter object. Author: Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com> Date: 02/08/96 Definition at line 173 of file imjpeg.cpp. : BaseBitmapFilter() { // Initialize members for class Filter ImportMsgID = _R(IDS_IMPORTMSG_JPEG); Flags.CanImport = TRUE; Flags.CanExport = FALSE; Flags.CanExportMultipleImages = FALSE; Flags.ShowFilter = TRUE; FilterID = FILTERID_IMPORT_JPEG; // Initialize our class members m_pFile = NULL; m_bOldReportErrors = FALSE; m_bOldThrowExceptions = FALSE; m_uStartOffset = 0; // Offset from start at which header appears, maybe... m_pErrorHandler = NULL; m_pSourceHandler = NULL; m_pProgressMonitor = NULL; m_pFilterForProgress = NULL; m_pFileForProgress = NULL; m_uImportSize = 0; m_ppInfo = NULL; m_ppBytes = NULL; m_uWidth = 0; m_uHeight = 0; m_uBitsPerPixel = 0; }

JPEGImportFilter::~JPEGImportFilter (   )

Default constructor for a JPEGFilter object. Author: Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com> Date: 02/08/96 Definition at line 216 of file imjpeg.cpp. { if (m_pErrorHandler != NULL) delete m_pErrorHandler; if (m_pSourceHandler != NULL) delete m_pSourceHandler; if (m_pProgressMonitor != NULL) delete m_pProgressMonitor; }

---

Member Function Documentation

JPEGImportFilter::CC_DECLARE_MEMDUMP (  JPEGImportFilter   )  [private]

BitmapSource * JPEGImportFilter::CreateBitmapSource (  OFFSET  Size  )  const [protected, virtual]

Provides a BitmapSource for lossy file formats. The JPEGImportFilter returns a JPEGBitmapSource. Author: Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com> Date: 21/08/96 Returns: A pointer to a new BitmapSource See also: BaseBitmapFIlter::CreateBitmapSource Scope: protected Reimplemented from BaseBitmapFilter. Definition at line 476 of file imjpeg.cpp. { BitmapSource* pSource = new JPEGBitmapSource(Size); return pSource; }

BOOL JPEGImportFilter::DoFilter (  CCFile *  pInputFile, OILBitmap *  pOilBitmap )  [protected]

Provides the main processing point for the JPEG import. Called by the external interface. Author: Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com> Date: 09/08/96 Parameters: pInputFile  : a pointer to an open CCFile containing the JPEG data to be [INPUTS] imported pOilBitmap : pointer to the OILBitmap to be filled in pOilBitmap  : If successful will contain the bitmap data from reading the [OUTPUTS] JPEG file (GetImportFile()). Returns: TRUE if successful FALSE if not Notes: Here's how the IJG docs say we do it: 1) Allocate and initialize a JPEG decompression object 2) Specify the source of the compressed data (eg, a file) 3) Call jpeg_read_header() to obtain image info 4) Set parameters for decompression 5) jpeg_start_decompress(...); 6) while (scan lines remain to be read) jpeg_read_scanlines(...); 7) jpeg_finish_decompress(...); 8) Release the JPEG decompression object See Also: ReadFromFile(...) Definition at line 613 of file imjpeg.cpp. { ERROR2IF(pOilBitmap == NULL || pInputFile == NULL, FALSE, "NULL Args"); ERROR3IF(!pInputFile->IS_KIND_OF(CCFile), "pInputFile isn't"); m_pFile = pInputFile; CWxBitmap* pWBitmap = (CWxBitmap*)pOilBitmap; ERROR2IF(!pWBitmap->IS_KIND_OF(CWxBitmap), FALSE, "Only CWxBitmap supported"); m_ppInfo = &(pWBitmap->BMInfo); m_ppBytes = &(pWBitmap->BMBytes); // Try to import the bitmap from a JPEG file. if (!PrepareFilterForOperation()) return FALSE; try { ReadHeader(); PrepareForImage(m_pImportOptions); ReadImage(); OnImageCompletion(); } catch(...) { // catch our form of a file exception // Tidy up StringID errorString = m_pErrorHandler->GetStringIDForError(); Error::SetError(errorString); if (*m_ppInfo != NULL && *m_ppBytes != NULL) { FreeDIB( *m_ppInfo, *m_ppBytes ); // free any alloced memory } *m_ppInfo = NULL; // and NULL the pointers *m_ppBytes = NULL; /* The IJG library says: You can abort a decompression cycle by calling jpeg_destroy_decompress() or jpeg_destroy() if you don't need the JPEG object any more, or jpeg_abort_decompress() or jpeg_abort() if you want to reuse the object. */ OnFilterCompletion(); return FALSE; } OnFilterCompletion(); return TRUE; }

OFFSET JPEGImportFilter::GetDataStartOffset (   )  const [protected, virtual]

Provides information to the BaseBitmapFilter, so that it knows where to start any required BitmapSource. It will only be useful to derived classes that deal with a lossy file format. > virtual OFFSET BaseBitmapFilter::GetDataStartOffset() const Author: Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com> Date: 20/08/96 Returns: The offset from the HeaderStart parameter given in HowCompatible(), from which data essential to the correct functionality of this filter starts. See Also: BaseBitmapFilter::GetDataStartOffset() Reimplemented from BaseBitmapFilter. Definition at line 457 of file imjpeg.cpp. { return m_uStartOffset; }

static BOOL JPEGImportFilter::GetImportAt96dpi (   )  [inline, static]

Definition at line 146 of file imjpeg.h. { return m_fImportAt96dpi; }

BitmapImportOptions * JPEGImportFilter::GetImportOptions (   )  [protected, virtual]

Overrides the BaseBitmapFilter::GetImportOptions to This will read the source datastream header markers, up to the beginning. Author: Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com> Date: 02/08/96 Returns: A pointer to some new JPEGImportOptions if successful NULL otherwise Notes: From the IJG docs: jpeg_read_header() sets appropriate default decompression parameters based on the properties of the image (in particular, its colorspace). However, you may well want to alter these defaults before beginning the decompression. For example, the default is to produce full color output from a color file. If you want colormapped output you must ask for it. Other options allow the returned image to be scaled and allow various speed/quality tradeoffs to be selected. "Decompression parameter selection", below, gives details. If the defaults are appropriate, nothing need be done at this step. Note that all default values are set by each call to jpeg_read_header(). If you reuse a decompression object, you cannot expect your parameter settings to be preserved across cycles, as you can for compression. You must set desired parameter values each time. See Also: BaseBitmapFilter::GetImportOptions() Reimplemented from BaseBitmapFilter. Definition at line 870 of file imjpeg.cpp. { JPEGImportOptions* pOptions = NULL; // Should ReadHeader here... pOptions = new JPEGImportOptions; /* Might want to set one or two of these at some point J_COLOR_SPACE out_color_space; // colorspace for output UINT32 scale_num, scale_denom; // fraction by which to scale image double output_gamma; // image gamma wanted in output boolean buffered_image; // TRUE=multiple output passes boolean raw_data_out; // TRUE=downsampled data wanted J_DCT_METHOD dct_method; // IDCT algorithm selector boolean do_fancy_upsampling; // TRUE=apply fancy upsampling boolean do_block_smoothing; // TRUE=apply interblock smoothing boolean quantize_colors; // TRUE=colormapped output wanted // the following are ignored if not quantize_colors: J_DITHER_MODE dither_mode; //type of color dithering to use boolean two_pass_quantize; // TRUE=use two-pass color quantization INT32 desired_number_of_colors; // max # colors to use in created colormap // these are significant only in buffered-image mode: boolean enable_1pass_quant; // enable future use of 1-pass quantizer boolean enable_external_quant;// enable future use of external colormap boolean enable_2pass_quant; enable future use of 2-pass quantizer */ return (BitmapImportOptions*)pOptions; }

INT32 JPEGImportFilter::HowCompatible (  PathName &  Filename, ADDR  pHeaderStart, UINT32  HeaderSize, UINT32  FileSize )  [virtual]

Overrides the Filter class member to determine if the given file is reckoned to be a JPEG. Author: Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com> Date: 02/08/96 Parameters: Filename  - name of the file. [INPUTS] HeaderStart - Address of the first few bytes of the file. HeaderSize - the number of bytes in the header pointed to by FileStart. FileSize - the size of the whole file, in bytes. Returns: 0 => Not a JPEG file. 10 => Bound to be a JPEG file. 1 - 9 => Might be Reimplemented from Filter. Definition at line 320 of file imjpeg.cpp. { PORTNOTE("byteorder", "TODO: Check byte ordering") static BYTE JPEGSignature[] = {0xFF,0xD8}; static BYTE APP0Signature[] = {0xFF,0xE0}; static BYTE APP1Signature[] = {0xFF,0xE1}; static BYTE JFIFSignature[] = "JFIF"; static BYTE EXIFSignature[] = "Exif"; // If we're forced to import the file when we don't think there's the remotest // chance of a match, start at the beginning of the file in ReadFromFile m_uStartOffset = 0; // Check that we've got enough data to do our check if (HeaderSize < 2) { // Not enough data - ignore this file. return 0; } INT32 Compatability = 0; BOOL bFoundSOI = FALSE; BOOL bFoundJFIF = FALSE; BOOL bFoundEXIF = FALSE; // Check the header for the JPEG SOI signature, 0xFFD8 (unless it's 0xD8FF). ADDR pJPEGHeader = FindBytes(pHeaderStart, HeaderSize, JPEGSignature, 2); if (pJPEGHeader != NULL) { // Add in a value of 0 to 5 depending on the distance from the // start of the header m_uStartOffset = pJPEGHeader - pHeaderStart; bFoundSOI = TRUE; } if (bFoundSOI) { OFFSET HeaderBytesRemaining = HeaderSize - (pJPEGHeader - pHeaderStart); // Look for an APP0 containing JFIF char* pAPP0Start = (char*)FindBytes(pJPEGHeader + 2, HeaderBytesRemaining - 2, APP0Signature, 2); if (pAPP0Start) { if (strncmp(pAPP0Start + 4, (char *)JFIFSignature, sizeof(JFIFSignature) / sizeof(TCHAR)) == 0) { bFoundJFIF = TRUE; } } // Look for an APP1 containing Exif char* pAPP1Start = (char*)FindBytes(pJPEGHeader + 2, HeaderBytesRemaining - 2, APP1Signature, 2); if (pAPP1Start) { if (strncmp(pAPP1Start + 4, (char *)EXIFSignature, sizeof(EXIFSignature) / sizeof(TCHAR)) == 0) { bFoundEXIF = TRUE; } } // Andy Hills, 02-11-00 // Previously, non-JPEG files were scoring as highly as 9, on the // basis that they had JPEG headers ... only, not at the start of the // file, but several hundred bytes in!!! // Now, we will give a score of 10 to a legit JPEG, or a score of 2-5 // depending upon the nearness of the JPEG header to the start of // the file. This means that files with JPEG previews will score a few // points, e.g. PSD & PSP files. switch (m_uStartOffset) { case 0: // the header was at the very start of the file --> // it really is a JPEG!!! // we will give it a score of up to 10 Compatability = 6; break; default: // the header was some way into the file --> // it probably isn't a JPEG, but has a JPEG preview // we will give it a max score of 5 // Nearness evaluates to between 0 and 3 INT32 Nearness = (((HeaderSize - m_uStartOffset) * 4) / HeaderSize); // Compatibility evaluates to between -2 and 1 Compatability = Nearness - 2; break; } } if (bFoundJFIF || bFoundEXIF) { // Closer still Compatability += 4; } // Return the found value to the caller. return max(Compatability,0); }

BOOL JPEGImportFilter::Init (  void   )  [virtual]

Initializes the JPEGImportFilter class. Author: Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com> Date: 02/08/96 Returns: TRUE if the filter was initialized ok FALSE otherwise Reimplemented from BaseBitmapFilter. Definition at line 239 of file imjpeg.cpp. { // Get the OILFilter object pOILFilter = new JPEGImportOILFilter(this); if (pOILFilter==NULL) return FALSE; // Load the description strings FilterName.Load(_R(IDS_JPG_IMP_FILTERNAME)); FilterInfo.Load(_R(IDS_JPG_IMP_FILTERINFO)); if( 9999 == m_fImportAt96dpi && Camelot.DeclareSection( _T("Filters"), 10 ) ) { Camelot.DeclarePref( NULL, _T("ImportJPEGAt96dpi"), &m_fImportAt96dpi, FALSE, TRUE ); } // All ok return TRUE; }

BOOL JPEGImportFilter::InitErrorHandler (   )  [protected]

Creates & initializes an error handler for this filter. Author: Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com> Date: 02/08/96 Definition at line 1275 of file imjpeg.cpp. { m_pErrorHandler = new JPEGErrorManager; if (m_pErrorHandler == NULL) { return FALSE; } m_cinfo.err = m_pErrorHandler->GetErrorMgrStruct(); return TRUE; }

BOOL JPEGImportFilter::InitFileHandler (   )  [protected]

Creates & initializes a source data provider for this filter. Author: Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com> Date: 02/08/96 Definition at line 1299 of file imjpeg.cpp. { if (m_cinfo.src == NULL) { if (m_pSourceHandler == NULL) { m_pSourceHandler = new JPEGDataSource(m_pFile); if (m_pSourceHandler == NULL) return FALSE; } m_cinfo.src = m_pSourceHandler; if (!m_pSourceHandler->InitBuffer(&m_cinfo)) return FALSE; } return TRUE; }

BOOL JPEGImportFilter::InitProgressMonitor (   )  [protected]

Creates & initializes the Progress bar for the filtering operation. Author: Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com> Date: 08/08/96 Definition at line 1328 of file imjpeg.cpp. { PORTNOTETRACE("filters","JPEGImportFilter::InitProgressMonitor - do nothing"); #ifndef EXCLUDE_FROM_XARALX if (m_pFileForProgress == NULL) { m_pProgressMonitor = new JPEGProgressByFilter(&m_cinfo, m_pFilterForProgress, m_uImportSize); } else { // We have to provide the progress bar String_64 string = GetImportProgressString(m_pFileForProgress, GetImportMsgID()); m_pProgressMonitor = new JPEGProgressBySelf(&m_cinfo, string); } // Couldn't create one!!! if (m_pProgressMonitor == NULL) { return FALSE; } // Provide this ProgressMonitor to the IJG library m_cinfo.progress = m_pProgressMonitor; #endif return TRUE; }

BOOL JPEGImportFilter::IsFormatLossy (   )  const [protected, virtual]

The JPEGImportFilter imports a lossy format & therefore always returns TRUE See Also: BaseBitmapFilter::IsFormatLossy(). > virtual BOOL JPEGImportFilter::IsFormatLossy() const Author: Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com> Date: 20/08/96 Returns: TRUE Reimplemented from BaseBitmapFilter. Definition at line 433 of file imjpeg.cpp. { return TRUE; }

BOOL JPEGImportFilter::OnFilterCompletion (   )  [protected, virtual]

Default constructor for a JPEGFilter object. Author: Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com> Date: 02/08/96 Notes: Taken from IJG docs: When you are done with a JPEG decompression object, destroy it by calling jpeg_destroy_decompress() or jpeg_destroy(). Definition at line 1230 of file imjpeg.cpp. { if (m_pErrorHandler != NULL) { delete m_pErrorHandler; m_pErrorHandler = NULL; m_cinfo.err = NULL; } if (m_pSourceHandler != NULL) { delete m_pSourceHandler; m_pSourceHandler = NULL; m_cinfo.src = NULL; } if (m_pProgressMonitor != NULL) { delete m_pProgressMonitor; m_pProgressMonitor = NULL; m_cinfo.progress = NULL; } jpeg_destroy_decompress(&m_cinfo); m_pFile->SetThrowExceptions(m_bOldThrowExceptions); m_pFile->SetReportErrors(m_bOldReportErrors); // Start at the beginning of the file next time m_uStartOffset = 0; return TRUE; }

void JPEGImportFilter::OnImageCompletion (   )  [protected, virtual]

Once an image has been read, this member should be called to complete any processing associated with that image. Author: Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com> Date: 02/08/96 Returns: Errors: Throws exceptions Notes: Taken from IJG docs: After all the image data has been read, call jpeg_finish_decompress() to complete the decompression cycle. This causes working memory associated with the JPEG object to be released. It is an error to call jpeg_finish_decompress() before reading the correct total number of scanlines. If you wish to abort compression, call jpeg_abort() as discussed below. After completing a decompression cycle, you may dispose of the JPEG object as discussed next, or you may use it to decompress another image. In that case return to step 2 or 3 as appropriate. If you do not change the source manager, the next image will be read from the same source. Definition at line 1194 of file imjpeg.cpp. { jpeg_finish_decompress(&m_cinfo); /* Might be able to do this on GreyScale UINT32 Bpp = pWBitmap->GetBPP(); if (TransColour != -1 && Bpp <= 8) pOilBitmap->SetTransparencyIndex(TransColour); */ if (!SetBitmapResolution()) { m_pErrorHandler->ThrowError( _R(IDS_JPEG_ERROR_UNSUPPORTED) ); } SetLastBitmap(); // can only import one bitmap at the moment }

BOOL JPEGImportFilter::PrepareFilterForOperation (   )  [protected, virtual]

Default constructor for a JPEGFilter object. Author: Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com> Date: 02/08/96 1. Allocate and initialize a JPEG decompression object. This is just like initialization for compression, as discussed above, except that the object is a "struct jpeg_decompress_struct" and you call jpeg_create_decompress(). Error handling is exactly the same. A JPEG compression object is a "struct jpeg_compress_struct". (It also has a bunch of subsidiary structures which are allocated via malloc(), but the application doesn't control those directly.) This struct can be just a local variable in the calling routine, if a single routine is going to execute the whole JPEG compression sequence. Otherwise it can be static or allocated from malloc(). You will also need a structure representing a JPEG error handler. The part of this that the library cares about is a "struct jpeg_error_mgr". If you are providing your own error handler, you'll typically want to embed the jpeg_error_mgr struct in a larger structure; this is discussed later under "Error handling". For now we'll assume you are just using the default error handler. The default error handler will print JPEG error/warning messages on stderr, and it will call exit() if a fatal error occurs. You must initialize the error handler structure, store a pointer to it into the JPEG object's "err" field, and then call jpeg_create_compress() to initialize the rest of the JPEG object. Typical code: struct jpeg_decompress_struct cinfo; struct jpeg_error_mgr jerr; ... cinfo.err = jpeg_std_error(&jerr); jpeg_create_decompress(&cinfo); jpeg_create_compress allocates a small amount of memory, so it could fail if you are out of memory. In that case it will exit via the error handler; that's why the error handler must be initialized first. (Both here and in the IJG code, we usually use variable name "cinfo" for both compression and decompression objects.) 2. Specify the source of the compressed data (eg, a file). As previously mentioned, the JPEG library reads compressed data from a "data source" module. The library includes one data source module which knows how to read from a stdio stream. You can use your own source module if you want to do something else, as discussed later. If you use the standard source module, you must open the source stdio stream beforehand. Typical code for this step looks like: FILE * infile; ... if ((infile = fopen(filename, "rb")) == NULL) { fprintf(stderr, "can't open %s\n", filename); exit(1); } jpeg_stdio_src(&cinfo, infile); where the last line invokes the standard source module. WARNING: it is critical that the binary compressed data be read unchanged. On non-Unix systems the stdio library may perform newline translation or otherwise corrupt binary data. To suppress this behavior, you may need to use a "b" option to fopen (as shown above), or use setmode() or another routine to put the stdio stream in binary mode. See cjpeg.c and djpeg.c for code that has been found to work on many systems. You may not change the data source between calling jpeg_read_header() and jpeg_finish_decompress(). If you wish to read a series of JPEG images from a single source file, you should repeat the jpeg_read_header() to jpeg_finish_decompress() sequence without reinitializing either the JPEG object or the data source module; this prevents buffered input data from being discarded. Definition at line 758 of file imjpeg.cpp. { // The error handling in the following should probably be replaced by exceptions at // some time, when somebody can decide on a standard. // Set up a JPEGErrorManager if (!InitErrorHandler()) { return FALSE; } // Initialize the main JPG library structure try { using namespace libJPEG; jpeg_create_decompress( &m_cinfo ); } catch(...) { return FALSE; } // Setup a JPEGDataSource if (!InitFileHandler()) { return FALSE; } // Set up a progress bar if (!InitProgressMonitor()) { return FALSE; } // Don't let the CCFile report errors or throw exceptions m_bOldThrowExceptions = m_pFile->SetThrowExceptions(FALSE); m_bOldReportErrors = m_pFile->SetReportErrors(FALSE); return TRUE; }

void JPEGImportFilter::PrepareForImage (  BitmapImportOptions *  pOptions  )  [protected, virtual]

Prepares a place for the actual scanlines using the given options. Author: Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com> Date: 02/08/96 Parameters: pOptions  : a pointer to some JPEGImportOptions (currently NULL) [INPUTS] Notes: From the IJG docs: Once the parameter values are satisfactory, call jpeg_start_decompress() to begin decompression. This will initialize internal state, allocate working memory, and prepare for returning data. If you have requested a multi-pass operating mode, such as 2-pass color quantization, jpeg_start_decompress() will do everything needed before data output can begin. In this case jpeg_start_decompress() may take quite a while to complete. With a single-scan (non progressive) JPEG file and default decompression parameters, this will not happen; jpeg_start_decompress() will return quickly. After this call, the final output image dimensions, including any requested scaling, are available in the JPEG object; so is the selected colormap, if colormapped output has been requested. Useful fields include output_width image width and height, as scaled output_height out_color_components # of color components in out_color_space output_components # of color components returned per pixel colormap the selected colormap, if any actual_number_of_colors number of entries in colormap output_components is 1 (a colormap index) when quantizing colors; otherwise it equals out_color_components. It is the number of JSAMPLE values that will be emitted per pixel in the output arrays. Typically you will need to allocate data buffers to hold the incoming image. You will need output_width * output_components JSAMPLEs per scanline in your output buffer, and a total of output_height scanlines will be returned. Definition at line 952 of file imjpeg.cpp. { //ERROR2IF(pOptions == NULL, FALSE, "pOptions is NULL"); // Set up conversion parameters (should be in GetImportOptions really) // "The return value need be inspected only if a suspending data source is used" /* One day... if (m_cinfo.jpeg_color_space == JCS_YCCK) { // Convert YCCK to RGB m_cinfo.out_color_space = JCS_RGB; } */ (void)jpeg_start_decompress(&m_cinfo); // Store the image width & height m_uWidth = m_cinfo.output_width; m_uHeight = m_cinfo.output_height; // Compute colormap size and total file size switch (m_cinfo.out_color_space) { case libJPEG::JCS_RGB: { // Unquantized, full color RGB m_uBitsPerPixel = 24; break; } case libJPEG::JCS_GRAYSCALE: { // Grayscale output m_uBitsPerPixel = 8; break; } default: { m_pErrorHandler->ThrowError(_R(IDS_JPEG_ERROR_UNSUPPORTED)); } } // So we know *m_ppInfo = NULL; *m_ppBytes = NULL; // we know what sort of bitmap we are - let's allocate a new LPBITMAPINFO and some bytes *m_ppInfo = AllocDIB( m_uWidth, m_uHeight, m_uBitsPerPixel, m_ppBytes, NULL ); if (*m_ppInfo == NULL || *m_ppBytes == NULL) { m_pErrorHandler->ThrowError( _R(IDS_OUT_OF_MEMORY) ); } if (!ReadPalette()) { m_pErrorHandler->ThrowError( _R(IDS_PNG_ERR_READ_PALETTE) ); // Should be bad palette error } }

BOOL JPEGImportFilter::ReadFromFile (  OILBitmap *  pOilBitmap  )  [virtual]

Actually does the process of reading a bitmap from a file. Inherited classes override this to read in different file formats. JPEG reads a JPEG file. Author: Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com> Date: 09/08/96 Parameters: pOilBitmap  : pointer to the OILBitmap to be filled in [INPUTS] pOilBitmap  : If successful will contain the bitmap data from reading the [OUTPUTS] JPEG file (GetImportFile()). Returns: TRUE if successful FALSE if not Errors: ERROR2s for invalid parameters Notes: m_uStartOffset must have been set prior to calling this (use HowCompatible() or set it zero). Reimplemented from BaseBitmapFilter. Definition at line 568 of file imjpeg.cpp. { ERROR2IF(pOilBitmap == NULL, FALSE, "pOilBitmap is NULL"); m_pFileForProgress = GetImportFile(); // get BaseBitmapFilter member m_pFilterForProgress = NULL; CCFile* pFile = GetImportFile(); return DoFilter(pFile, pOilBitmap); }

BOOL JPEGImportFilter::ReadFromFile (  OILBitmap *  pOilBitmap, BaseCamelotFilter *  pFilter, CCLexFile *  pFile, BOOL  IsCompressed )  [virtual]

Entry point for Native File Format stuff Actually does the process of reading a bitmap from a file. Inherited classes override this to read in different file formats. It is used by the web/native filters to pull out a bitmap definition from inside a bitmap definition record. Author: Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com> (from Neville Humphrys in PNGFilter) Date: 14/08/96 Parameters: pFilter,:  the BaseCamelotFilter which provides functions like [INPUTS] progress update pFile the CCFile class to use to read the data from IsCompressed :Flag to say the bitmap is compressed or not. pOilBitmap,:  Will have filled in BMInfo pointer to the bitmap header to fill [OUTPUTS] in. BMBytes pointer to the bitmap data to fill in Returns: TRUE if worked, FALSE if failed. Notes: m_uStartOffset, the offset in the stream at which the JPEG header starts, is set to zero through this entry point. This assumes, therefore, that the JPEG contains no Adobe style garbage in front of it. Also assumes: pFile has already been opened up for reading pFilter has been set up for reading the data e.g. progress bar Reimplemented from BaseBitmapFilter. Definition at line 512 of file imjpeg.cpp. { ERROR2IF(pOilBitmap == NULL,FALSE,"pOilBitmap NULL"); ERROR2IF(pFilter == NULL,FALSE,"pFilter NULL"); ERROR2IF(pFile == NULL,FALSE,"pFile NULL"); // CCFile* pFile = (CCFile*)pFile->GetIOFile(); m_pFilterForProgress = (Filter*)pFilter; m_pFileForProgress = NULL; m_uImportSize = pFilter->GetCurrentRecordSize(); // The encapsulated JPEG should always have its header starting at offset // zero inside its .xar Record m_uStartOffset = 0; // Try to import bitmap from JPEG file if (!DoFilter(pFile, pOilBitmap)) { return FALSE; } // Make sure this bitmap is treated as lossy pOilBitmap->SetAsLossy(); // Clear any eof signal as CCFile considers this an error if (m_pFile->eof()) { m_pFile->SetGoodState(); } return TRUE; }

void JPEGImportFilter::ReadHeader (   )  [protected]

This will read the source datastream header markers, up to the beginning of the compressed data proper. On return, the image dimensions and other info have been stored in the JPEG object. The application may wish to consult this information before selecting decompression parameters. Author: Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com> Date: 02/08/96 Returns: TRUE if header was correctly read & the data set FALSE otherwise Errors: Throws exceptions Notes: PrepareFilterForOperation must have been called prior to this call. From the IJG docs: More complex code is necessary if A suspending data source is used --- in that case jpeg_read_header() may return before it has read all the header data. Abbreviated JPEG files are to be processed --- see the section on abbreviated datastreams. Standard applications that deal only in interchange JPEG files need not be concerned with this case either. It is permissible to stop at this point if you just wanted to find out the image dimensions and other header info for a JPEG file. In that case, call jpeg_destroy() when you are done with the JPEG object, or call jpeg_abort() to return it to an idle state before selecting a new data source and reading another header. Definition at line 833 of file imjpeg.cpp. { jpeg_read_header(&m_cinfo, TRUE); }

void JPEGImportFilter::ReadImage (   )  [protected, virtual]

Reads the actual scanlines of the image into this's DIB data members. Author: Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com> Date: 02/08/96 Returns: Errors: Throws exceptions Notes: Once PrepareForImage() has been called this function can read in the data Definition at line 1107 of file imjpeg.cpp. { //#ifndef WIN32 // Error::SetError( _R(IDE_BADFORMAT) ); // return FALSE; //#else // Sanity checks on the file that we have been asked to load. if ((m_uBitsPerPixel != 24 && m_uBitsPerPixel != 8) || (m_uWidth == 0 || m_uHeight == 0) || m_cinfo.output_components > 3) { m_pErrorHandler->ThrowError( _R(IDE_FORMATNOTSUPPORTED) ); } // Work out the word/byte rounded line width rather than the pixel width INT32 WidthOfLine = DIBUtil::ScanlineSize( m_uWidth, m_uBitsPerPixel ); // Of course being DIBs we need to read the data in upside down! i.e. bottom to top // So start from the bottom LPBYTE pCurrentScanLine = *m_ppBytes + ((m_uHeight - 1 - m_cinfo.output_scanline) * WidthOfLine); while (m_cinfo.output_scanline < m_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. // Read in from bottom upwards (void) jpeg_read_scanlines(&m_cinfo, &pCurrentScanLine, 1); // // Swap red and blue channels. // #if !defined(__WXMSW__) && defined(BIG_ENDIAN) if ( m_uBitsPerPixel==24 ) { BYTE* pLine = pCurrentScanLine; for ( UINT32 i=0 ; i<m_uWidth ; i++ ) { BYTE t = pLine[0]; pLine[0] = pLine[2]; pLine[2] = t; pLine += 3; } } #endif // If JobState is False then the user has probably pressed escape and we should // immediately stop what we are doing. if (m_pProgressMonitor && m_pProgressMonitor->UserAborted()) { m_pErrorHandler->ThrowError(_R(IDW_CANCELLEDBMPIMPORT)); // Expects error set on cancel } // Work backwards through the DIB pCurrentScanLine -= WidthOfLine; } //#endif }

BOOL JPEGImportFilter::ReadPalette (   )  [protected]

Reads a palette for the image In this case it just generates a greyscale palette for JCS_GRAYSCALE JPEGs. All other colour models are 24-bit. Author: Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com> Date: 02/08/96 Returns: TRUE if a palette was read correctly & the data set FALSE otherwise Definition at line 1075 of file imjpeg.cpp. { if (m_cinfo.out_color_space == libJPEG::JCS_GRAYSCALE) { // We'll have to generate a palette for it LPRGBQUAD pPalette = (*m_ppInfo)->bmiColors; if (pPalette == NULL) { return FALSE; } if (!DIBUtil::GenGreyscalePalette(pPalette, 256)) { return FALSE; } } return TRUE; }

BOOL JPEGImportFilter::SetBitmapResolution (   )  [protected]

Support function that sets the X & Y pixel densities for the bitmap imported from the JPEG file. Author: Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com> Date: 02/08/96 Returns: TRUE if resolution set OK FALSE otherwise Definition at line 1029 of file imjpeg.cpp. { // Set the horizontal & vertical pixel densities LPBITMAPINFOHEADER pHeader = &(*m_ppInfo)->bmiHeader; // Conviently the import code defaults to 96dpi, so // we just leave it alone if we're importing at 96dpi if( !m_fImportAt96dpi ) { switch (m_cinfo.density_unit) { case 1: // dots/inch pHeader->biXPelsPerMeter = (INT32)(m_cinfo.X_density * (100 / 2.54)); pHeader->biYPelsPerMeter = (INT32)(m_cinfo.Y_density * (100 / 2.54)); break; case 2: // dots/cm pHeader->biXPelsPerMeter = m_cinfo.X_density * 100; pHeader->biYPelsPerMeter = m_cinfo.Y_density * 100; break; default: // unknown // Note that the pixel aspect ratio is defined by X_density/Y_density // even when density_unit=0. // So leave it as is: 96dpi break; } } return TRUE; }

static void JPEGImportFilter::SetImportAt96dpi (  BOOL  fImportAt96  )  [inline, static]

Definition at line 147 of file imjpeg.h. { m_fImportAt96dpi = fImportAt96; }

---

Member Data Documentation

BOOL JPEGImportFilter::m_bOldReportErrors [protected]

Definition at line 180 of file imjpeg.h.

BOOL JPEGImportFilter::m_bOldThrowExceptions [protected]

Definition at line 181 of file imjpeg.h.

struct libJPEG::jpeg_decompress_struct JPEGImportFilter::m_cinfo [protected]

Definition at line 186 of file imjpeg.h.

BOOL JPEGImportFilter::m_fImportAt96dpi = m_fImportAt96dpi [static, protected]

Definition at line 183 of file imjpeg.h.

JPEGErrorManager* JPEGImportFilter::m_pErrorHandler [protected]

Definition at line 188 of file imjpeg.h.

CCFile* JPEGImportFilter::m_pFile [protected]

Definition at line 179 of file imjpeg.h.

CCLexFile* JPEGImportFilter::m_pFileForProgress [protected]

Definition at line 193 of file imjpeg.h.

Filter* JPEGImportFilter::m_pFilterForProgress [protected]

Definition at line 194 of file imjpeg.h.

LPBYTE* JPEGImportFilter::m_ppBytes [protected]

Definition at line 199 of file imjpeg.h.

LPBITMAPINFO* JPEGImportFilter::m_ppInfo [protected]

Definition at line 198 of file imjpeg.h.

JPEGProgressMonitor* JPEGImportFilter::m_pProgressMonitor [protected]

Definition at line 190 of file imjpeg.h.

JPEGDataSource* JPEGImportFilter::m_pSourceHandler [protected]

Definition at line 189 of file imjpeg.h.

UINT32 JPEGImportFilter::m_uBitsPerPixel [protected]

Definition at line 203 of file imjpeg.h.

UINT32 JPEGImportFilter::m_uHeight [protected]

Definition at line 202 of file imjpeg.h.

UINT32 JPEGImportFilter::m_uImportSize [protected]

Definition at line 195 of file imjpeg.h.

UINT32 JPEGImportFilter::m_uStartOffset [protected]

Definition at line 182 of file imjpeg.h.

UINT32 JPEGImportFilter::m_uWidth [protected]

Definition at line 201 of file imjpeg.h.

---

The documentation for this class was generated from the following files:

• Kernel/imjpeg.h (r1785/r1758)
• Kernel/imjpeg.cpp (r1785/r1758)

---