src/pagespeed/kernel/image/scanline_interface_frame_adapter.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: Victor Chudnovsky

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

 #include "base/logging.h"
 #include "pagespeed/kernel/base/message_handler.h"

 namespace pagespeed {

 namespace image_compression {

 ////////// FrameToScanlineReaderAdapter

 FrameToScanlineReaderAdapter::FrameToScanlineReaderAdapter(
     MultipleFrameReader* frame_reader) : impl_(frame_reader) {
   CHECK(frame_reader != NULL);
   CHECK(Reset());
 }

 bool FrameToScanlineReaderAdapter::Reset() {
   image_spec_.Reset();
   frame_spec_.Reset();
   return impl_->Reset().Success();
 }

 size_t FrameToScanlineReaderAdapter::GetBytesPerScanline() {
   return GetBytesPerPixel(GetPixelFormat()) * GetImageWidth();
 }

 bool FrameToScanlineReaderAdapter::HasMoreScanLines() {
   return impl_->HasMoreScanlines();
 }

 bool FrameToScanlineReaderAdapter::IsProgressive() {
   return frame_spec_.hint_progressive;
 }

 ScanlineStatus FrameToScanlineReaderAdapter::InitializeWithStatus(
     const void* image_buffer,
     size_t const buffer_length) {
   ScanlineStatus status;
   if ((impl_->Initialize(image_buffer, buffer_length, &status) &&
        impl_->GetImageSpec(&image_spec_, &status) &&
        impl_->PrepareNextFrame(&status) &&
        impl_->GetFrameSpec(&frame_spec_, &status))) {
     if (image_spec_.num_frames > 1) {
       status = PS_LOGGED_STATUS(
           PS_DLOG_INFO, impl_->message_handler(),
           SCANLINE_STATUS_UNSUPPORTED_FEATURE,
           FRAME_TO_SCANLINE_READER_ADAPTER,
           "animated images not supported in Scanline interface. %s",
           image_spec_.ToString().c_str());
     } else if ((frame_spec_.width != image_spec_.width) ||
                (frame_spec_.height != image_spec_.height)) {
       status = PS_LOGGED_STATUS(
           PS_LOG_INFO, impl_->message_handler(),
           SCANLINE_STATUS_PARSE_ERROR,
           FRAME_TO_SCANLINE_READER_ADAPTER,
           "frame must have same dimensions as image");
     }
   }
   return status;
 }

 ScanlineStatus FrameToScanlineReaderAdapter::ReadNextScanlineWithStatus(
     void** const out_scanline_bytes) {
   return impl_->ReadNextScanline(const_cast<const void**>(out_scanline_bytes));
 }

 size_t FrameToScanlineReaderAdapter::GetImageHeight() {
   return image_spec_.height;
 }

 size_t FrameToScanlineReaderAdapter::GetImageWidth() {
   return image_spec_.width;
 }

 PixelFormat FrameToScanlineReaderAdapter::GetPixelFormat() {
   return frame_spec_.pixel_format;
 }


 ////////// FrameToScanlineWriterAdapter

 FrameToScanlineWriterAdapter::FrameToScanlineWriterAdapter(
     MultipleFrameWriter* const frame_writer)
     : impl_(frame_writer), init_done_(false) {
   CHECK(frame_writer != NULL);
 }

 ScanlineStatus FrameToScanlineWriterAdapter::InitWithStatus(
     const size_t width,
     const size_t height,
     const PixelFormat pixel_format) {
   image_spec_.width = width;
   image_spec_.height = height;

   // Non-animated images have only one frame.
   image_spec_.num_frames = 1;

   frame_spec_.width = image_spec_.width;
   frame_spec_.height = image_spec_.height;
   frame_spec_.top = 0;
   frame_spec_.left = 0;
   frame_spec_.pixel_format = pixel_format;
   frame_spec_.duration_ms = 0;
   frame_spec_.disposal = FrameSpec::DISPOSAL_NONE;

   init_done_ = true;
   return ScanlineStatus(SCANLINE_STATUS_SUCCESS);
 }

 ScanlineStatus FrameToScanlineWriterAdapter::InitializeWriteWithStatus(
     const void* const config,
     GoogleString* const out) {
   if (!init_done_) {
     return PS_LOGGED_STATUS(PS_LOG_DFATAL, impl_->message_handler(),
                             SCANLINE_STATUS_INVOCATION_ERROR,
                             FRAME_TO_SCANLINE_WRITER_ADAPTER,
                             "Initialize() called before Init()");
   }

   ScanlineStatus status;
   // We don't actually need a separate success variable, but want to
   // prevent future steps as soon as we encounter an error.
   bool success = (impl_->Initialize(config, out, &status) &&
                   impl_->PrepareImage(&image_spec_, &status) &&
                   impl_->PrepareNextFrame(&frame_spec_, &status));
   (void) success;
   return status;
 }

 ScanlineStatus FrameToScanlineWriterAdapter::WriteNextScanlineWithStatus(
     const void* const scanline_bytes) {
   return impl_->WriteNextScanline(scanline_bytes);
 }

 ScanlineStatus FrameToScanlineWriterAdapter::FinalizeWriteWithStatus() {
   return impl_->FinalizeWrite();
 }


 ////////// ScanlineToFrameReaderAdapter

 ScanlineToFrameReaderAdapter::ScanlineToFrameReaderAdapter(
     ScanlineReaderInterface* const scanline_reader,
     MessageHandler* const message_handler)
     : MultipleFrameReader(message_handler),
       state_(UNINITIALIZED),
       impl_(scanline_reader) {
   CHECK(scanline_reader != NULL);
 }

 ScanlineStatus ScanlineToFrameReaderAdapter::Reset() {
   state_ = UNINITIALIZED;
   frame_spec_.Reset();
   image_spec_.Reset();

   return (impl_->Reset() ?
           ScanlineStatus(SCANLINE_STATUS_SUCCESS) :
           PS_LOGGED_STATUS(PS_LOG_ERROR, message_handler(),
                            SCANLINE_STATUS_INTERNAL_ERROR,
                            SCANLINE_TO_FRAME_READER_ADAPTER,
                            "Error in ScanlineReaderInterface::Reset()"));
 }

 ScanlineStatus ScanlineToFrameReaderAdapter::Initialize() {
   ScanlineStatus status = impl_->InitializeWithStatus(image_buffer_,
                                                       buffer_length_);

   if (status.Success()) {
     image_spec_.width = impl_->GetImageWidth();
     image_spec_.height = impl_->GetImageHeight();

     // Non-animated images have only one frame.
     image_spec_.num_frames = 1;
   }

   state_ = status.Success() ? INITIALIZED : ERROR;
   return status;
 }

 ScanlineStatus ScanlineToFrameReaderAdapter::PrepareNextFrame() {
   if (!HasMoreFrames()) {
     state_ = ERROR;
     return PS_LOGGED_STATUS(PS_LOG_DFATAL, message_handler(),
                             SCANLINE_STATUS_INVOCATION_ERROR,
                             SCANLINE_TO_FRAME_READER_ADAPTER,
                             "PrepareNextFrame()");
   }

   frame_spec_.Reset();
   frame_spec_.width = impl_->GetImageWidth();
   frame_spec_.height = impl_->GetImageHeight();
   frame_spec_.top = 0;
   frame_spec_.left = 0;
   frame_spec_.pixel_format = impl_->GetPixelFormat();
   frame_spec_.hint_progressive = impl_->IsProgressive();
   state_ = FRAME_PREPARED;

   return ScanlineStatus(SCANLINE_STATUS_SUCCESS);
 }

 bool ScanlineToFrameReaderAdapter::HasMoreScanlines() const {
   return impl_->HasMoreScanLines();
 }

 ScanlineStatus ScanlineToFrameReaderAdapter::ReadNextScanline(
     const void** const out_scanline_bytes) {
   return impl_->ReadNextScanlineWithStatus(
       const_cast<void**>(out_scanline_bytes));
 }

 bool ScanlineToFrameReaderAdapter::HasMoreFrames() const {
   // Note that once PrepareNextFrame is called, state_ will no longer
   // be INITIALIZED.
   return (state_ == INITIALIZED);
 }

 ScanlineStatus ScanlineToFrameReaderAdapter::GetImageSpec(
     ImageSpec* const spec) const {
   *spec = image_spec_;
   return ScanlineStatus(SCANLINE_STATUS_SUCCESS);
 }

 ScanlineStatus ScanlineToFrameReaderAdapter::GetFrameSpec(
     FrameSpec* const spec) const {
   *spec = frame_spec_;
   return ScanlineStatus(SCANLINE_STATUS_SUCCESS);
 }

 ////////// ScanlineToFrameWriterAdapter

 ScanlineToFrameWriterAdapter::ScanlineToFrameWriterAdapter(
     ScanlineWriterInterface* const scanline_writer,
     MessageHandler* const handler) : MultipleFrameWriter(handler),
                                      state_(UNINITIALIZED),
                                      impl_(scanline_writer),
                                      config_(NULL),
                                      out_(NULL) {
   CHECK(scanline_writer != NULL);
 }

 ScanlineStatus ScanlineToFrameWriterAdapter::Initialize(
     const void* const config,
     GoogleString* const out) {
   config_ = config;
   out_ = out;
   state_ = INITIALIZED;
   return ScanlineStatus(SCANLINE_STATUS_SUCCESS);
 }

 ScanlineStatus ScanlineToFrameWriterAdapter::PrepareNextFrame(
     const FrameSpec* const spec) {
   if (state_ != IMAGE_PREPARED) {
     state_ = ERROR;
     return PS_LOGGED_STATUS(PS_LOG_DFATAL, message_handler(),
                             SCANLINE_STATUS_INVOCATION_ERROR,
                             SCANLINE_TO_FRAME_WRITER_ADAPTER,
                             "PrepareNextFrame should be called after "
                             "PrepareImage, and only once");
   }

   frame_spec_ = spec;
   ScanlineStatus status = impl_->InitWithStatus(image_spec_->width,
                                                 image_spec_->height,
                                                 frame_spec_->pixel_format);
   if (status.Success()) {
     status = impl_->InitializeWriteWithStatus(config_, out_);
   }
   state_ = (status.Success() ? FRAME_PREPARED : ERROR);
   return status;
 }

 ScanlineStatus ScanlineToFrameWriterAdapter::WriteNextScanline(
     const void* const scanline_bytes) {
   return impl_->WriteNextScanlineWithStatus(scanline_bytes);
 }

 ScanlineStatus ScanlineToFrameWriterAdapter::FinalizeWrite() {
   return impl_->FinalizeWriteWithStatus();
 }

 ScanlineStatus ScanlineToFrameWriterAdapter::PrepareImage(
     const ImageSpec* const spec) {
   image_spec_ = spec;
   if (spec->num_frames > 1) {
     state_ = ERROR;
     return PS_LOGGED_STATUS(PS_LOG_INFO, message_handler(),
                             SCANLINE_STATUS_UNSUPPORTED_FEATURE,
                             SCANLINE_TO_FRAME_WRITER_ADAPTER,
                             "animated images not supported in Scanline"
                             "interface");
   }
   state_ = IMAGE_PREPARED;
   return ScanlineStatus(SCANLINE_STATUS_SUCCESS);
 }

 }  // 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: Victor Chudnovsky

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

	#include "base/logging.h"
	#include "pagespeed/kernel/base/message_handler.h"

	namespace pagespeed {

	namespace image_compression {

	////////// FrameToScanlineReaderAdapter

	FrameToScanlineReaderAdapter::FrameToScanlineReaderAdapter(
	MultipleFrameReader* frame_reader) : impl_(frame_reader) {
	CHECK(frame_reader != NULL);
	CHECK(Reset());
	}

	bool FrameToScanlineReaderAdapter::Reset() {
	image_spec_.Reset();
	frame_spec_.Reset();
	return impl_->Reset().Success();
	}

	size_t FrameToScanlineReaderAdapter::GetBytesPerScanline() {
	return GetBytesPerPixel(GetPixelFormat()) * GetImageWidth();
	}

	bool FrameToScanlineReaderAdapter::HasMoreScanLines() {
	return impl_->HasMoreScanlines();
	}

	bool FrameToScanlineReaderAdapter::IsProgressive() {
	return frame_spec_.hint_progressive;
	}

	ScanlineStatus FrameToScanlineReaderAdapter::InitializeWithStatus(
	const void* image_buffer,
	size_t const buffer_length) {
	ScanlineStatus status;
	if ((impl_->Initialize(image_buffer, buffer_length, &status) &&
	impl_->GetImageSpec(&image_spec_, &status) &&
	impl_->PrepareNextFrame(&status) &&
	impl_->GetFrameSpec(&frame_spec_, &status))) {
	if (image_spec_.num_frames > 1) {
	status = PS_LOGGED_STATUS(
	PS_DLOG_INFO, impl_->message_handler(),
	SCANLINE_STATUS_UNSUPPORTED_FEATURE,
	FRAME_TO_SCANLINE_READER_ADAPTER,
	"animated images not supported in Scanline interface. %s",
	image_spec_.ToString().c_str());
	} else if ((frame_spec_.width != image_spec_.width) \|\|
	(frame_spec_.height != image_spec_.height)) {
	status = PS_LOGGED_STATUS(
	PS_LOG_INFO, impl_->message_handler(),
	SCANLINE_STATUS_PARSE_ERROR,
	FRAME_TO_SCANLINE_READER_ADAPTER,
	"frame must have same dimensions as image");
	}
	}
	return status;
	}

	ScanlineStatus FrameToScanlineReaderAdapter::ReadNextScanlineWithStatus(
	void** const out_scanline_bytes) {
	return impl_->ReadNextScanline(const_cast<const void**>(out_scanline_bytes));
	}

	size_t FrameToScanlineReaderAdapter::GetImageHeight() {
	return image_spec_.height;
	}

	size_t FrameToScanlineReaderAdapter::GetImageWidth() {
	return image_spec_.width;
	}

	PixelFormat FrameToScanlineReaderAdapter::GetPixelFormat() {
	return frame_spec_.pixel_format;
	}


	////////// FrameToScanlineWriterAdapter

	FrameToScanlineWriterAdapter::FrameToScanlineWriterAdapter(
	MultipleFrameWriter* const frame_writer)
	: impl_(frame_writer), init_done_(false) {
	CHECK(frame_writer != NULL);
	}

	ScanlineStatus FrameToScanlineWriterAdapter::InitWithStatus(
	const size_t width,
	const size_t height,
	const PixelFormat pixel_format) {
	image_spec_.width = width;
	image_spec_.height = height;

	// Non-animated images have only one frame.
	image_spec_.num_frames = 1;

	frame_spec_.width = image_spec_.width;
	frame_spec_.height = image_spec_.height;
	frame_spec_.top = 0;
	frame_spec_.left = 0;
	frame_spec_.pixel_format = pixel_format;
	frame_spec_.duration_ms = 0;
	frame_spec_.disposal = FrameSpec::DISPOSAL_NONE;

	init_done_ = true;
	return ScanlineStatus(SCANLINE_STATUS_SUCCESS);
	}

	ScanlineStatus FrameToScanlineWriterAdapter::InitializeWriteWithStatus(
	const void* const config,
	GoogleString* const out) {
	if (!init_done_) {
	return PS_LOGGED_STATUS(PS_LOG_DFATAL, impl_->message_handler(),
	SCANLINE_STATUS_INVOCATION_ERROR,
	FRAME_TO_SCANLINE_WRITER_ADAPTER,
	"Initialize() called before Init()");
	}

	ScanlineStatus status;
	// We don't actually need a separate success variable, but want to
	// prevent future steps as soon as we encounter an error.
	bool success = (impl_->Initialize(config, out, &status) &&
	impl_->PrepareImage(&image_spec_, &status) &&
	impl_->PrepareNextFrame(&frame_spec_, &status));
	(void) success;
	return status;
	}

	ScanlineStatus FrameToScanlineWriterAdapter::WriteNextScanlineWithStatus(
	const void* const scanline_bytes) {
	return impl_->WriteNextScanline(scanline_bytes);
	}

	ScanlineStatus FrameToScanlineWriterAdapter::FinalizeWriteWithStatus() {
	return impl_->FinalizeWrite();
	}


	////////// ScanlineToFrameReaderAdapter

	ScanlineToFrameReaderAdapter::ScanlineToFrameReaderAdapter(
	ScanlineReaderInterface* const scanline_reader,
	MessageHandler* const message_handler)
	: MultipleFrameReader(message_handler),
	state_(UNINITIALIZED),
	impl_(scanline_reader) {
	CHECK(scanline_reader != NULL);
	}

	ScanlineStatus ScanlineToFrameReaderAdapter::Reset() {
	state_ = UNINITIALIZED;
	frame_spec_.Reset();
	image_spec_.Reset();

	return (impl_->Reset() ?
	ScanlineStatus(SCANLINE_STATUS_SUCCESS) :
	PS_LOGGED_STATUS(PS_LOG_ERROR, message_handler(),
	SCANLINE_STATUS_INTERNAL_ERROR,
	SCANLINE_TO_FRAME_READER_ADAPTER,
	"Error in ScanlineReaderInterface::Reset()"));
	}

	ScanlineStatus ScanlineToFrameReaderAdapter::Initialize() {
	ScanlineStatus status = impl_->InitializeWithStatus(image_buffer_,
	buffer_length_);

	if (status.Success()) {
	image_spec_.width = impl_->GetImageWidth();
	image_spec_.height = impl_->GetImageHeight();

	// Non-animated images have only one frame.
	image_spec_.num_frames = 1;
	}

	state_ = status.Success() ? INITIALIZED : ERROR;
	return status;
	}

	ScanlineStatus ScanlineToFrameReaderAdapter::PrepareNextFrame() {
	if (!HasMoreFrames()) {
	state_ = ERROR;
	return PS_LOGGED_STATUS(PS_LOG_DFATAL, message_handler(),
	SCANLINE_STATUS_INVOCATION_ERROR,
	SCANLINE_TO_FRAME_READER_ADAPTER,
	"PrepareNextFrame()");
	}

	frame_spec_.Reset();
	frame_spec_.width = impl_->GetImageWidth();
	frame_spec_.height = impl_->GetImageHeight();
	frame_spec_.top = 0;
	frame_spec_.left = 0;
	frame_spec_.pixel_format = impl_->GetPixelFormat();
	frame_spec_.hint_progressive = impl_->IsProgressive();
	state_ = FRAME_PREPARED;

	return ScanlineStatus(SCANLINE_STATUS_SUCCESS);
	}

	bool ScanlineToFrameReaderAdapter::HasMoreScanlines() const {
	return impl_->HasMoreScanLines();
	}

	ScanlineStatus ScanlineToFrameReaderAdapter::ReadNextScanline(
	const void** const out_scanline_bytes) {
	return impl_->ReadNextScanlineWithStatus(
	const_cast<void**>(out_scanline_bytes));
	}

	bool ScanlineToFrameReaderAdapter::HasMoreFrames() const {
	// Note that once PrepareNextFrame is called, state_ will no longer
	// be INITIALIZED.
	return (state_ == INITIALIZED);
	}

	ScanlineStatus ScanlineToFrameReaderAdapter::GetImageSpec(
	ImageSpec* const spec) const {
	*spec = image_spec_;
	return ScanlineStatus(SCANLINE_STATUS_SUCCESS);
	}

	ScanlineStatus ScanlineToFrameReaderAdapter::GetFrameSpec(
	FrameSpec* const spec) const {
	*spec = frame_spec_;
	return ScanlineStatus(SCANLINE_STATUS_SUCCESS);
	}

	////////// ScanlineToFrameWriterAdapter

	ScanlineToFrameWriterAdapter::ScanlineToFrameWriterAdapter(
	ScanlineWriterInterface* const scanline_writer,
	MessageHandler* const handler) : MultipleFrameWriter(handler),
	state_(UNINITIALIZED),
	impl_(scanline_writer),
	config_(NULL),
	out_(NULL) {
	CHECK(scanline_writer != NULL);
	}

	ScanlineStatus ScanlineToFrameWriterAdapter::Initialize(
	const void* const config,
	GoogleString* const out) {
	config_ = config;
	out_ = out;
	state_ = INITIALIZED;
	return ScanlineStatus(SCANLINE_STATUS_SUCCESS);
	}

	ScanlineStatus ScanlineToFrameWriterAdapter::PrepareNextFrame(
	const FrameSpec* const spec) {
	if (state_ != IMAGE_PREPARED) {
	state_ = ERROR;
	return PS_LOGGED_STATUS(PS_LOG_DFATAL, message_handler(),
	SCANLINE_STATUS_INVOCATION_ERROR,
	SCANLINE_TO_FRAME_WRITER_ADAPTER,
	"PrepareNextFrame should be called after "
	"PrepareImage, and only once");
	}

	frame_spec_ = spec;
	ScanlineStatus status = impl_->InitWithStatus(image_spec_->width,
	image_spec_->height,
	frame_spec_->pixel_format);
	if (status.Success()) {
	status = impl_->InitializeWriteWithStatus(config_, out_);
	}
	state_ = (status.Success() ? FRAME_PREPARED : ERROR);
	return status;
	}

	ScanlineStatus ScanlineToFrameWriterAdapter::WriteNextScanline(
	const void* const scanline_bytes) {
	return impl_->WriteNextScanlineWithStatus(scanline_bytes);
	}

	ScanlineStatus ScanlineToFrameWriterAdapter::FinalizeWrite() {
	return impl_->FinalizeWriteWithStatus();
	}

	ScanlineStatus ScanlineToFrameWriterAdapter::PrepareImage(
	const ImageSpec* const spec) {
	image_spec_ = spec;
	if (spec->num_frames > 1) {
	state_ = ERROR;
	return PS_LOGGED_STATUS(PS_LOG_INFO, message_handler(),
	SCANLINE_STATUS_UNSUPPORTED_FEATURE,
	SCANLINE_TO_FRAME_WRITER_ADAPTER,
	"animated images not supported in Scanline"
	"interface");
	}
	state_ = IMAGE_PREPARED;
	return ScanlineStatus(SCANLINE_STATUS_SUCCESS);
	}

	} // namespace image_compression

	} // namespace pagespeed