src/pagespeed/kernel/image/read_image.cc - incubator-pagespeed-debian - Git at Google

 /*
  * Copyright 2013 Google Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 // Author: Huibao Lin

 #include "pagespeed/kernel/image/read_image.h"

 #include <setjmp.h>
 #include <stdlib.h>
 #include "pagespeed/kernel/base/message_handler.h"
 #include "pagespeed/kernel/base/scoped_ptr.h"
 #include "pagespeed/kernel/base/string.h"
 #include "pagespeed/kernel/image/frame_interface_optimizer.h"
 #include "pagespeed/kernel/image/gif_reader.h"
 #include "pagespeed/kernel/image/image_frame_interface.h"
 #include "pagespeed/kernel/image/jpeg_optimizer.h"
 #include "pagespeed/kernel/image/jpeg_reader.h"
 #include "pagespeed/kernel/image/png_optimizer.h"
 #include "pagespeed/kernel/image/scanline_interface.h"
 #include "pagespeed/kernel/image/scanline_interface_frame_adapter.h"
 #include "pagespeed/kernel/image/scanline_utils.h"
 #include "pagespeed/kernel/image/webp_optimizer.h"

 namespace pagespeed {

 namespace image_compression {

 using net_instaweb::MessageHandler;

 ////////// Scanline API

 // Forward declaration
 MultipleFrameReader* InstantiateImageFrameReader(
     ImageFormat image_type,
     MessageHandler* handler,
     ScanlineStatus* status);

 // Instantiates an uninitialized scanline image reader.
 ScanlineReaderInterface* InstantiateScanlineReader(
     ImageFormat image_type,
     MessageHandler* handler,
     ScanlineStatus* status) {
   ScanlineReaderInterface* reader = NULL;
   const char* which = NULL;

   *status = ScanlineStatus(SCANLINE_STATUS_SUCCESS);
   switch (image_type) {
     case IMAGE_PNG:
       reader = new PngScanlineReaderRaw(handler);
       which = "PngScanlineReaderRaw";
       break;

     case IMAGE_JPEG:
       reader = new JpegScanlineReader(handler);
       which = "JpegScanlineReader";
       break;

     case IMAGE_WEBP:
       reader = new WebpScanlineReader(handler);
       which = "WebpScanlineReader";
       break;

     case IMAGE_GIF: {
       which = "FrameToScanlineReaderAdapter(GifFrameReader)";
       net_instaweb::scoped_ptr<MultipleFrameReader> mf_reader(
           InstantiateImageFrameReader(image_type, handler, status));
       if (!mf_reader->set_quirks_mode(QUIRKS_CHROME, status)) {
         return NULL;
       }
       reader =
           new FrameToScanlineReaderAdapter(
               new MultipleFramePaddingReader(mf_reader.release()));
       break;
     }

     case IMAGE_UNKNOWN:
       break;

     // No default so compiler will complain if any enum is not processed.
   }

   if (which == NULL) {
       *status = PS_LOGGED_STATUS(PS_LOG_DFATAL, handler,
                                  SCANLINE_STATUS_UNSUPPORTED_FORMAT,
                                  SCANLINE_UTIL,
                                  "invalid image type for reader: %d",
                                  image_type);
   } else if (reader == NULL) {
     *status = PS_LOGGED_STATUS(PS_LOG_ERROR, handler,
                                SCANLINE_STATUS_MEMORY_ERROR,
                                SCANLINE_UTIL,
                                "failed to allocate %s", which);
   }

   return reader;
 }

 // Returns an initialized scanline image reader.
 ScanlineReaderInterface* CreateScanlineReader(
     ImageFormat image_type,
     const void* image_buffer,
     size_t buffer_length,
     MessageHandler* handler,
     ScanlineStatus* status) {
   net_instaweb::scoped_ptr<ScanlineReaderInterface> reader(
       InstantiateScanlineReader(image_type, handler, status));
   if (status->Success()) {
     *status = reader->InitializeWithStatus(image_buffer, buffer_length);
   }
   return status->Success() ? reader.release() : NULL;
 }

 // Forward declaration.
 MultipleFrameWriter* InstantiateImageFrameWriter(
     ImageFormat image_type,
     MessageHandler* handler,
     ScanlineStatus* status);

 // Instantiates an uninitialized scanline image writer.
 ScanlineWriterInterface* InstantiateScanlineWriter(
     ImageFormat image_type,
     MessageHandler* handler,
     ScanlineStatus* status) {
   ScanlineWriterInterface* writer = NULL;
   const char* which = NULL;

   *status = ScanlineStatus(SCANLINE_STATUS_SUCCESS);
   switch (image_type) {
     case pagespeed::image_compression::IMAGE_JPEG:
       {
         net_instaweb::scoped_ptr<JpegScanlineWriter> jpeg_writer(
             new JpegScanlineWriter(handler));
         if (jpeg_writer != NULL) {
           // TODO(huibao): Set up error handling inside JpegScanlineWriter.
           // Remove 'setjmp' from the clients and remove the 'SetJmpBufEnv'
           // method.
           jmp_buf env;
           if (setjmp(env)) {
             // This code is run only when libjpeg hit an error, and
             // called longjmp(env). Note that this only works for as
             // long as this stack frame is valid.
             jpeg_writer->AbortWrite();
             return NULL;
           }

           jpeg_writer->SetJmpBufEnv(&env);
           writer = jpeg_writer.release();
         }
         which  = "JpegScanlineWriter";
       }
       break;

     case pagespeed::image_compression::IMAGE_PNG:
       writer = new PngScanlineWriter(handler);
       which = "PngScanlineWriter";
       break;

     case pagespeed::image_compression::IMAGE_WEBP:
       which = "FrameToScanlineWriterAdapter(WebpFrameWriter)";
       writer = new FrameToScanlineWriterAdapter(
           InstantiateImageFrameWriter(image_type, handler, status));
       break;

     case IMAGE_GIF:
       // This library does not implement a GIF writer; intentional
       // fall-through.
     case IMAGE_UNKNOWN:
       break;

     // No default so compiler will complain if any enum is not processed.
   }

   if (which == NULL) {
         *status = PS_LOGGED_STATUS(PS_LOG_DFATAL, handler,
                                    SCANLINE_STATUS_UNSUPPORTED_FORMAT,
                                    SCANLINE_UTIL,
                                    "invalid image type for writer: %d",
                                    image_type);
   } else if (writer == NULL) {
     *status = PS_LOGGED_STATUS(PS_LOG_ERROR, handler,
                                SCANLINE_STATUS_MEMORY_ERROR,
                                SCANLINE_UTIL,
                                "failed to allocate %s", which);
   }

   return writer;
 }


 // Returns an initialized scanline image writer.
 ScanlineWriterInterface* CreateScanlineWriter(
     ImageFormat image_type,
     PixelFormat pixel_format,
     size_t width,
     size_t height,
     const void* config,
     GoogleString* image_data,
     MessageHandler* handler,
     ScanlineStatus* status) {
   net_instaweb::scoped_ptr<ScanlineWriterInterface> writer(
       InstantiateScanlineWriter(image_type, handler, status));
   if (status->Success()) {
     *status = writer->InitWithStatus(width, height, pixel_format);
   }
   if (status->Success()) {
     *status = writer->InitializeWriteWithStatus(config, image_data);
   }
   return status->Success() ? writer.release() : NULL;
 }


 ////////// ImageFrame API

 // Instantiates an uninitialized image frame reader.
 MultipleFrameReader* InstantiateImageFrameReader(
     ImageFormat image_type,
     MessageHandler* handler,
     ScanlineStatus* status) {
   MultipleFrameReader* reader = NULL;

   *status = ScanlineStatus(SCANLINE_STATUS_SUCCESS);
   if (image_type == IMAGE_GIF) {
     // Native ImageFrame implementation
     reader = new GifFrameReader(handler);
     if (reader == NULL) {
       *status = PS_LOGGED_STATUS(
           PS_LOG_ERROR, handler,
           SCANLINE_STATUS_MEMORY_ERROR,
           SCANLINE_UTIL,
           "failed to allocate GifFrameReader");
     }
   } else {
     // Image formats for which we do not have an ImageFrame
     // implementation result in a wrapper around the corresponding
     // Scanline object.
     net_instaweb::scoped_ptr<ScanlineReaderInterface> scanline_reader(
         InstantiateScanlineReader(image_type, handler, status));
     if (status->Success()) {
       reader = new ScanlineToFrameReaderAdapter(
           scanline_reader.release(), handler);
       if (reader == NULL) {
         *status = PS_LOGGED_STATUS(
             PS_LOG_ERROR, handler,
             SCANLINE_STATUS_MEMORY_ERROR,
             SCANLINE_UTIL,
             "failed to allocate ScanlineToFrameReaderAdapter");
       }
     }
   }

   return reader;
 }

 // Returns an initialized image frame reader.
 MultipleFrameReader* CreateImageFrameReader(
     ImageFormat image_type,
     const void* image_buffer,
     size_t buffer_length,
     QuirksMode quirks_mode,
     MessageHandler* handler,
     ScanlineStatus* status) {
   net_instaweb::scoped_ptr<MultipleFrameReader> reader(
       InstantiateImageFrameReader(image_type, handler, status));
   return (status->Success() &&
           reader->set_quirks_mode(quirks_mode, status) &&
           reader->Initialize(image_buffer, buffer_length, status)) ?
           reader.release() : NULL;
 }

 // Instantiates an uninitialized image frame writer.
 MultipleFrameWriter* InstantiateImageFrameWriter(
     ImageFormat image_type,
     MessageHandler* handler,
     ScanlineStatus* status) {
   MultipleFrameWriter* allocated_writer = NULL;
   *status = ScanlineStatus(SCANLINE_STATUS_SUCCESS);

   if (image_type == IMAGE_WEBP) {
     // Native ImageFrame implementation
     allocated_writer = new WebpFrameWriter(handler);
     if (allocated_writer == NULL) {
       *status = PS_LOGGED_STATUS(
           PS_LOG_ERROR, handler,
           SCANLINE_STATUS_MEMORY_ERROR,
           SCANLINE_UTIL,
           "failed to allocate WebpFrameReader");
     }
   } else {
     // Image formats for which we do not have an ImageFrame
     // implementation result in a wrapper around the corresponding
     // Scanline object.
     net_instaweb::scoped_ptr<ScanlineWriterInterface> scanline_writer(
         InstantiateScanlineWriter(image_type, handler, status));
     if (status->Success()) {
       allocated_writer = new ScanlineToFrameWriterAdapter(
           scanline_writer.release(), handler);
       if (allocated_writer == NULL) {
         *status = PS_LOGGED_STATUS(
             PS_LOG_ERROR, handler,
             SCANLINE_STATUS_MEMORY_ERROR,
             SCANLINE_UTIL,
             "failed to allocate ScanlineToFrameWriterAdapter");
       }
     }
   }
   return allocated_writer;
 }

 // Returns an initialized image frame writer.
 MultipleFrameWriter* CreateImageFrameWriter(
     ImageFormat image_type,
     const void* config,
     GoogleString* image_data,
     MessageHandler* handler,
     ScanlineStatus* status) {
   net_instaweb::scoped_ptr<MultipleFrameWriter> writer(
       InstantiateImageFrameWriter(image_type, handler, status));
   return (status->Success() &&
           writer->Initialize(config, image_data, status)) ?
       writer.release() : NULL;
 }

 ////////// Utilities

 bool ReadImage(ImageFormat image_type,
                const void* image_buffer,
                size_t buffer_length,
                void** pixels,
                PixelFormat* pixel_format,
                size_t* width,
                size_t* height,
                size_t* stride,
                MessageHandler* handler) {
   // Instantiate and initialize the reader based on image type.
   net_instaweb::scoped_ptr<ScanlineReaderInterface> reader;
   reader.reset(CreateScanlineReader(image_type, image_buffer, buffer_length,
                                     handler));
   if (reader.get() == NULL) {
     return false;
   }

   // The following information is available after the reader is initialized.
   // Copy them to the outputs if they are requested.
   if (pixel_format != NULL) {
     *pixel_format = reader->GetPixelFormat();
   }
   if (width != NULL) {
     *width = reader->GetImageWidth();
   }
   if (height != NULL) {
     *height = reader->GetImageHeight();
   }

   // Round up stride to a multiplier of 4.
   size_t bytes_per_row4 = (((reader->GetBytesPerScanline() + 3) >> 2) << 2);
   if (stride != NULL) {
     *stride = bytes_per_row4;
   }

   // Decode the image data (pixels) if it has been requested.
   if (pixels == NULL) {
     return true;
   }
   *pixels = NULL;
   const size_t data_length = reader->GetImageHeight() * bytes_per_row4;
   unsigned char* image_data = static_cast<unsigned char*>(malloc(data_length));
   if (image_data == NULL) {
     return false;
   }

   unsigned char* row_data = image_data;
   unsigned char* scanline = NULL;
   while (reader->HasMoreScanLines()) {
     if (!reader->ReadNextScanline(reinterpret_cast<void**>(&scanline))) {
       free(image_data);
       return false;
     }
     memcpy(row_data, scanline, reader->GetBytesPerScanline());
     row_data += bytes_per_row4;
   }

   *pixels = static_cast<void*>(image_data);
   return true;
 }

 }  // namespace image_compression

 }  // namespace pagespeed
	/*
	* Copyright 2013 Google Inc.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	// Author: Huibao Lin

	#include "pagespeed/kernel/image/read_image.h"

	#include <setjmp.h>
	#include <stdlib.h>
	#include "pagespeed/kernel/base/message_handler.h"
	#include "pagespeed/kernel/base/scoped_ptr.h"
	#include "pagespeed/kernel/base/string.h"
	#include "pagespeed/kernel/image/frame_interface_optimizer.h"
	#include "pagespeed/kernel/image/gif_reader.h"
	#include "pagespeed/kernel/image/image_frame_interface.h"
	#include "pagespeed/kernel/image/jpeg_optimizer.h"
	#include "pagespeed/kernel/image/jpeg_reader.h"
	#include "pagespeed/kernel/image/png_optimizer.h"
	#include "pagespeed/kernel/image/scanline_interface.h"
	#include "pagespeed/kernel/image/scanline_interface_frame_adapter.h"
	#include "pagespeed/kernel/image/scanline_utils.h"
	#include "pagespeed/kernel/image/webp_optimizer.h"

	namespace pagespeed {

	namespace image_compression {

	using net_instaweb::MessageHandler;

	////////// Scanline API

	// Forward declaration
	MultipleFrameReader* InstantiateImageFrameReader(
	ImageFormat image_type,
	MessageHandler* handler,
	ScanlineStatus* status);

	// Instantiates an uninitialized scanline image reader.
	ScanlineReaderInterface* InstantiateScanlineReader(
	ImageFormat image_type,
	MessageHandler* handler,
	ScanlineStatus* status) {
	ScanlineReaderInterface* reader = NULL;
	const char* which = NULL;

	*status = ScanlineStatus(SCANLINE_STATUS_SUCCESS);
	switch (image_type) {
	case IMAGE_PNG:
	reader = new PngScanlineReaderRaw(handler);
	which = "PngScanlineReaderRaw";
	break;

	case IMAGE_JPEG:
	reader = new JpegScanlineReader(handler);
	which = "JpegScanlineReader";
	break;

	case IMAGE_WEBP:
	reader = new WebpScanlineReader(handler);
	which = "WebpScanlineReader";
	break;

	case IMAGE_GIF: {
	which = "FrameToScanlineReaderAdapter(GifFrameReader)";
	net_instaweb::scoped_ptr<MultipleFrameReader> mf_reader(
	InstantiateImageFrameReader(image_type, handler, status));
	if (!mf_reader->set_quirks_mode(QUIRKS_CHROME, status)) {
	return NULL;
	}
	reader =
	new FrameToScanlineReaderAdapter(
	new MultipleFramePaddingReader(mf_reader.release()));
	break;
	}

	case IMAGE_UNKNOWN:
	break;

	// No default so compiler will complain if any enum is not processed.
	}

	if (which == NULL) {
	*status = PS_LOGGED_STATUS(PS_LOG_DFATAL, handler,
	SCANLINE_STATUS_UNSUPPORTED_FORMAT,
	SCANLINE_UTIL,
	"invalid image type for reader: %d",
	image_type);
	} else if (reader == NULL) {
	*status = PS_LOGGED_STATUS(PS_LOG_ERROR, handler,
	SCANLINE_STATUS_MEMORY_ERROR,
	SCANLINE_UTIL,
	"failed to allocate %s", which);
	}

	return reader;
	}

	// Returns an initialized scanline image reader.
	ScanlineReaderInterface* CreateScanlineReader(
	ImageFormat image_type,
	const void* image_buffer,
	size_t buffer_length,
	MessageHandler* handler,
	ScanlineStatus* status) {
	net_instaweb::scoped_ptr<ScanlineReaderInterface> reader(
	InstantiateScanlineReader(image_type, handler, status));
	if (status->Success()) {
	*status = reader->InitializeWithStatus(image_buffer, buffer_length);
	}
	return status->Success() ? reader.release() : NULL;
	}

	// Forward declaration.
	MultipleFrameWriter* InstantiateImageFrameWriter(
	ImageFormat image_type,
	MessageHandler* handler,
	ScanlineStatus* status);

	// Instantiates an uninitialized scanline image writer.
	ScanlineWriterInterface* InstantiateScanlineWriter(
	ImageFormat image_type,
	MessageHandler* handler,
	ScanlineStatus* status) {
	ScanlineWriterInterface* writer = NULL;
	const char* which = NULL;

	*status = ScanlineStatus(SCANLINE_STATUS_SUCCESS);
	switch (image_type) {
	case pagespeed::image_compression::IMAGE_JPEG:
	{
	net_instaweb::scoped_ptr<JpegScanlineWriter> jpeg_writer(
	new JpegScanlineWriter(handler));
	if (jpeg_writer != NULL) {
	// TODO(huibao): Set up error handling inside JpegScanlineWriter.
	// Remove 'setjmp' from the clients and remove the 'SetJmpBufEnv'
	// method.
	jmp_buf env;
	if (setjmp(env)) {
	// This code is run only when libjpeg hit an error, and
	// called longjmp(env). Note that this only works for as
	// long as this stack frame is valid.
	jpeg_writer->AbortWrite();
	return NULL;
	}

	jpeg_writer->SetJmpBufEnv(&env);
	writer = jpeg_writer.release();
	}
	which = "JpegScanlineWriter";
	}
	break;

	case pagespeed::image_compression::IMAGE_PNG:
	writer = new PngScanlineWriter(handler);
	which = "PngScanlineWriter";
	break;

	case pagespeed::image_compression::IMAGE_WEBP:
	which = "FrameToScanlineWriterAdapter(WebpFrameWriter)";
	writer = new FrameToScanlineWriterAdapter(
	InstantiateImageFrameWriter(image_type, handler, status));
	break;

	case IMAGE_GIF:
	// This library does not implement a GIF writer; intentional
	// fall-through.
	case IMAGE_UNKNOWN:
	break;

	// No default so compiler will complain if any enum is not processed.
	}

	if (which == NULL) {
	*status = PS_LOGGED_STATUS(PS_LOG_DFATAL, handler,
	SCANLINE_STATUS_UNSUPPORTED_FORMAT,
	SCANLINE_UTIL,
	"invalid image type for writer: %d",
	image_type);
	} else if (writer == NULL) {
	*status = PS_LOGGED_STATUS(PS_LOG_ERROR, handler,
	SCANLINE_STATUS_MEMORY_ERROR,
	SCANLINE_UTIL,
	"failed to allocate %s", which);
	}

	return writer;
	}


	// Returns an initialized scanline image writer.
	ScanlineWriterInterface* CreateScanlineWriter(
	ImageFormat image_type,
	PixelFormat pixel_format,
	size_t width,
	size_t height,
	const void* config,
	GoogleString* image_data,
	MessageHandler* handler,
	ScanlineStatus* status) {
	net_instaweb::scoped_ptr<ScanlineWriterInterface> writer(
	InstantiateScanlineWriter(image_type, handler, status));
	if (status->Success()) {
	*status = writer->InitWithStatus(width, height, pixel_format);
	}
	if (status->Success()) {
	*status = writer->InitializeWriteWithStatus(config, image_data);
	}
	return status->Success() ? writer.release() : NULL;
	}


	////////// ImageFrame API

	// Instantiates an uninitialized image frame reader.
	MultipleFrameReader* InstantiateImageFrameReader(
	ImageFormat image_type,
	MessageHandler* handler,
	ScanlineStatus* status) {
	MultipleFrameReader* reader = NULL;

	*status = ScanlineStatus(SCANLINE_STATUS_SUCCESS);
	if (image_type == IMAGE_GIF) {
	// Native ImageFrame implementation
	reader = new GifFrameReader(handler);
	if (reader == NULL) {
	*status = PS_LOGGED_STATUS(
	PS_LOG_ERROR, handler,
	SCANLINE_STATUS_MEMORY_ERROR,
	SCANLINE_UTIL,
	"failed to allocate GifFrameReader");
	}
	} else {
	// Image formats for which we do not have an ImageFrame
	// implementation result in a wrapper around the corresponding
	// Scanline object.
	net_instaweb::scoped_ptr<ScanlineReaderInterface> scanline_reader(
	InstantiateScanlineReader(image_type, handler, status));
	if (status->Success()) {
	reader = new ScanlineToFrameReaderAdapter(
	scanline_reader.release(), handler);
	if (reader == NULL) {
	*status = PS_LOGGED_STATUS(
	PS_LOG_ERROR, handler,
	SCANLINE_STATUS_MEMORY_ERROR,
	SCANLINE_UTIL,
	"failed to allocate ScanlineToFrameReaderAdapter");
	}
	}
	}

	return reader;
	}

	// Returns an initialized image frame reader.
	MultipleFrameReader* CreateImageFrameReader(
	ImageFormat image_type,
	const void* image_buffer,
	size_t buffer_length,
	QuirksMode quirks_mode,
	MessageHandler* handler,
	ScanlineStatus* status) {
	net_instaweb::scoped_ptr<MultipleFrameReader> reader(
	InstantiateImageFrameReader(image_type, handler, status));
	return (status->Success() &&
	reader->set_quirks_mode(quirks_mode, status) &&
	reader->Initialize(image_buffer, buffer_length, status)) ?
	reader.release() : NULL;
	}

	// Instantiates an uninitialized image frame writer.
	MultipleFrameWriter* InstantiateImageFrameWriter(
	ImageFormat image_type,
	MessageHandler* handler,
	ScanlineStatus* status) {
	MultipleFrameWriter* allocated_writer = NULL;
	*status = ScanlineStatus(SCANLINE_STATUS_SUCCESS);

	if (image_type == IMAGE_WEBP) {
	// Native ImageFrame implementation
	allocated_writer = new WebpFrameWriter(handler);
	if (allocated_writer == NULL) {
	*status = PS_LOGGED_STATUS(
	PS_LOG_ERROR, handler,
	SCANLINE_STATUS_MEMORY_ERROR,
	SCANLINE_UTIL,
	"failed to allocate WebpFrameReader");
	}
	} else {
	// Image formats for which we do not have an ImageFrame
	// implementation result in a wrapper around the corresponding
	// Scanline object.
	net_instaweb::scoped_ptr<ScanlineWriterInterface> scanline_writer(
	InstantiateScanlineWriter(image_type, handler, status));
	if (status->Success()) {
	allocated_writer = new ScanlineToFrameWriterAdapter(
	scanline_writer.release(), handler);
	if (allocated_writer == NULL) {
	*status = PS_LOGGED_STATUS(
	PS_LOG_ERROR, handler,
	SCANLINE_STATUS_MEMORY_ERROR,
	SCANLINE_UTIL,
	"failed to allocate ScanlineToFrameWriterAdapter");
	}
	}
	}
	return allocated_writer;
	}

	// Returns an initialized image frame writer.
	MultipleFrameWriter* CreateImageFrameWriter(
	ImageFormat image_type,
	const void* config,
	GoogleString* image_data,
	MessageHandler* handler,
	ScanlineStatus* status) {
	net_instaweb::scoped_ptr<MultipleFrameWriter> writer(
	InstantiateImageFrameWriter(image_type, handler, status));
	return (status->Success() &&
	writer->Initialize(config, image_data, status)) ?
	writer.release() : NULL;
	}

	////////// Utilities

	bool ReadImage(ImageFormat image_type,
	const void* image_buffer,
	size_t buffer_length,
	void** pixels,
	PixelFormat* pixel_format,
	size_t* width,
	size_t* height,
	size_t* stride,
	MessageHandler* handler) {
	// Instantiate and initialize the reader based on image type.
	net_instaweb::scoped_ptr<ScanlineReaderInterface> reader;
	reader.reset(CreateScanlineReader(image_type, image_buffer, buffer_length,
	handler));
	if (reader.get() == NULL) {
	return false;
	}

	// The following information is available after the reader is initialized.
	// Copy them to the outputs if they are requested.
	if (pixel_format != NULL) {
	*pixel_format = reader->GetPixelFormat();
	}
	if (width != NULL) {
	*width = reader->GetImageWidth();
	}
	if (height != NULL) {
	*height = reader->GetImageHeight();
	}

	// Round up stride to a multiplier of 4.
	size_t bytes_per_row4 = (((reader->GetBytesPerScanline() + 3) >> 2) << 2);
	if (stride != NULL) {
	*stride = bytes_per_row4;
	}

	// Decode the image data (pixels) if it has been requested.
	if (pixels == NULL) {
	return true;
	}
	*pixels = NULL;
	const size_t data_length = reader->GetImageHeight() * bytes_per_row4;
	unsigned char* image_data = static_cast<unsigned char*>(malloc(data_length));
	if (image_data == NULL) {
	return false;
	}

	unsigned char* row_data = image_data;
	unsigned char* scanline = NULL;
	while (reader->HasMoreScanLines()) {
	if (!reader->ReadNextScanline(reinterpret_cast<void**>(&scanline))) {
	free(image_data);
	return false;
	}
	memcpy(row_data, scanline, reader->GetBytesPerScanline());
	row_data += bytes_per_row4;
	}

	pixels = static_cast<void>(image_data);
	return true;
	}

	} // namespace image_compression

	} // namespace pagespeed