// Copyright 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chrome/utility/cloud_print/pwg_encoder.h"
#include <algorithm>
#include "base/big_endian.h"
#include "base/logging.h"
#include "base/memory/scoped_ptr.h"
#include "chrome/utility/cloud_print/bitmap_image.h"
namespace cloud_print {
namespace {
const uint32 kBitsPerColor = 8;
const uint32 kColorOrder = 0; // chunky.
// Coefficients used to convert from RGB to monochrome.
const uint32 kRedCoefficient = 2125;
const uint32 kGreenCoefficient = 7154;
const uint32 kBlueCoefficient = 0721;
const uint32 kColorCoefficientDenominator = 10000;
const char* kPwgKeyword = "RaS2";
const uint32 kHeaderSize = 1796;
const uint32 kHeaderCupsDuplex = 272;
const uint32 kHeaderCupsHwResolutionHorizontal = 276;
const uint32 kHeaderCupsHwResolutionVertical = 280;
const uint32 kHeaderCupsTumble = 368;
const uint32 kHeaderCupsWidth = 372;
const uint32 kHeaderCupsHeight = 376;
const uint32 kHeaderCupsBitsPerColor = 384;
const uint32 kHeaderCupsBitsPerPixel = 388;
const uint32 kHeaderCupsBytesPerLine = 392;
const uint32 kHeaderCupsColorOrder = 396;
const uint32 kHeaderCupsColorSpace = 400;
const uint32 kHeaderCupsNumColors = 420;
const uint32 kHeaderPwgTotalPageCount = 452;
const uint32 kHeaderPwgCrossFeedTransform = 456;
const uint32 kHeaderPwgFeedTransform = 460;
const int kPwgMaxPackedRows = 256;
const int kPwgMaxPackedPixels = 128;
struct RGBA8 {
uint8 red;
uint8 green;
uint8 blue;
uint8 alpha;
};
struct BGRA8 {
uint8 blue;
uint8 green;
uint8 red;
uint8 alpha;
};
template <class InputStruct>
inline void encodePixelToRGB(const void* pixel, std::string* output) {
const InputStruct* i = reinterpret_cast<const InputStruct*>(pixel);
output->push_back(static_cast<char>(i->red));
output->push_back(static_cast<char>(i->green));
output->push_back(static_cast<char>(i->blue));
}
template <class InputStruct>
inline void encodePixelToMonochrome(const void* pixel, std::string* output) {
const InputStruct* i = reinterpret_cast<const InputStruct*>(pixel);
output->push_back(static_cast<char>((i->red * kRedCoefficient +
i->green * kGreenCoefficient +
i->blue * kBlueCoefficient) /
kColorCoefficientDenominator));
}
} // namespace
PwgEncoder::PwgEncoder() {}
void PwgEncoder::EncodeDocumentHeader(std::string* output) const {
output->clear();
output->append(kPwgKeyword, 4);
}
void PwgEncoder::EncodePageHeader(const BitmapImage& image,
const PwgHeaderInfo& pwg_header_info,
std::string* output) const {
char header[kHeaderSize];
memset(header, 0, kHeaderSize);
uint32 num_colors =
pwg_header_info.color_space == PwgHeaderInfo::SGRAY ? 1 : 3;
uint32 bits_per_pixel = num_colors * kBitsPerColor;
base::WriteBigEndian<uint32>(header + kHeaderCupsDuplex,
pwg_header_info.duplex ? 1 : 0);
base::WriteBigEndian<uint32>(header + kHeaderCupsHwResolutionHorizontal,
pwg_header_info.dpi);
base::WriteBigEndian<uint32>(header + kHeaderCupsHwResolutionVertical,
pwg_header_info.dpi);
base::WriteBigEndian<uint32>(header + kHeaderCupsTumble,
pwg_header_info.tumble ? 1 : 0);
base::WriteBigEndian<uint32>(header + kHeaderCupsWidth, image.size().width());
base::WriteBigEndian<uint32>(header + kHeaderCupsHeight,
image.size().height());
base::WriteBigEndian<uint32>(header + kHeaderCupsBitsPerColor, kBitsPerColor);
base::WriteBigEndian<uint32>(header + kHeaderCupsBitsPerPixel,
bits_per_pixel);
base::WriteBigEndian<uint32>(header + kHeaderCupsBytesPerLine,
(bits_per_pixel * image.size().width() + 7) / 8);
base::WriteBigEndian<uint32>(header + kHeaderCupsColorOrder, kColorOrder);
base::WriteBigEndian<uint32>(header + kHeaderCupsColorSpace,
pwg_header_info.color_space);
base::WriteBigEndian<uint32>(header + kHeaderCupsNumColors, num_colors);
base::WriteBigEndian<uint32>(header + kHeaderPwgCrossFeedTransform,
pwg_header_info.flipx ? -1 : 1);
base::WriteBigEndian<uint32>(header + kHeaderPwgFeedTransform,
pwg_header_info.flipy ? -1 : 1);
base::WriteBigEndian<uint32>(header + kHeaderPwgTotalPageCount,
pwg_header_info.total_pages);
output->append(header, kHeaderSize);
}
template <typename InputStruct, class RandomAccessIterator>
void PwgEncoder::EncodeRow(RandomAccessIterator pos,
RandomAccessIterator row_end,
bool monochrome,
std::string* output) const {
// According to PWG-raster, a sequence of N identical pixels (up to 128)
// can be encoded by a byte N-1, followed by the information on
// that pixel. Any generic sequence of N pixels (up to 129) can be encoded
// with (signed) byte 1-N, followed by the information on the N pixels.
// Notice that for sequences of 1 pixel there is no difference between
// the two encodings.
// We encode every largest sequence of identical pixels together because it
// usually saves the most space. Every other pixel should be encoded in the
// smallest number of generic sequences.
// NOTE: the algorithm is not optimal especially in case of monochrome.
while (pos != row_end) {
RandomAccessIterator it = pos + 1;
RandomAccessIterator end = std::min(pos + kPwgMaxPackedPixels, row_end);
// Counts how many identical pixels (up to 128).
while (it != end && *pos == *it) {
++it;
}
if (it != pos + 1) { // More than one pixel
output->push_back(static_cast<char>((it - pos) - 1));
if (monochrome)
encodePixelToMonochrome<InputStruct>(&*pos, output);
else
encodePixelToRGB<InputStruct>(&*pos, output);
pos = it;
} else {
// Finds how many pixels there are each different from the previous one.
// IMPORTANT: even if sequences of different pixels can contain as many
// as 129 pixels, we restrict to 128 because some decoders don't manage
// it correctly. So iterating until it != end is correct.
while (it != end && *it != *(it - 1)) {
++it;
}
// Optimization: ignores the last pixel of the sequence if it is followed
// by an identical pixel, as it is more convenient for it to be the start
// of a new sequence of identical pixels. Notice that we don't compare
// to end, but row_end.
if (it != row_end && *it == *(it - 1)) {
--it;
}
output->push_back(static_cast<char>(1 - (it - pos)));
while (pos != it) {
if (monochrome)
encodePixelToMonochrome<InputStruct>(&*pos, output);
else
encodePixelToRGB<InputStruct>(&*pos, output);
++pos;
}
}
}
}
inline const uint8* PwgEncoder::GetRow(const BitmapImage& image,
int row,
bool flipy) const {
return image.GetPixel(
gfx::Point(0, flipy ? image.size().height() - 1 - row : row));
}
// Given a pointer to a struct Image, create a PWG of the image and
// put the compressed image data in the string. Returns true on success.
// The content of the string is undefined on failure.
bool PwgEncoder::EncodePage(const BitmapImage& image,
const PwgHeaderInfo& pwg_header_info,
std::string* output) const {
// pwg_header_info.color_space can only contain color spaces that are
// supported, so no sanity check is needed.
switch (image.colorspace()) {
case BitmapImage::RGBA:
return EncodePageWithColorspace<RGBA8>(image, pwg_header_info, output);
case BitmapImage::BGRA:
return EncodePageWithColorspace<BGRA8>(image, pwg_header_info, output);
default:
LOG(ERROR) << "Unsupported colorspace.";
return false;
}
}
template <typename InputStruct>
bool PwgEncoder::EncodePageWithColorspace(const BitmapImage& image,
const PwgHeaderInfo& pwg_header_info,
std::string* output) const {
bool monochrome = pwg_header_info.color_space == PwgHeaderInfo::SGRAY;
EncodePageHeader(image, pwg_header_info, output);
// Ensure no integer overflow.
CHECK(image.size().width() < INT_MAX / image.channels());
int row_size = image.size().width() * image.channels();
int row_number = 0;
while (row_number < image.size().height()) {
const uint8* current_row =
GetRow(image, row_number++, pwg_header_info.flipy);
int num_identical_rows = 1;
// We count how many times the current row is repeated.
while (num_identical_rows < kPwgMaxPackedRows &&
row_number < image.size().height() &&
!memcmp(current_row,
GetRow(image, row_number, pwg_header_info.flipy),
row_size)) {
num_identical_rows++;
row_number++;
}
output->push_back(static_cast<char>(num_identical_rows - 1));
// Both supported colorspaces have a 32-bit pixels information.
// Converts the list of uint8 to uint32 as every pixels contains 4 bytes
// of information and comparison of elements is easier. The actual
// Management of the bytes of the pixel is done by pixel_encoder function
// on the original array to avoid endian problems.
const uint32* pos = reinterpret_cast<const uint32*>(current_row);
const uint32* row_end = pos + image.size().width();
if (!pwg_header_info.flipx) {
EncodeRow<InputStruct>(pos, row_end, monochrome, output);
} else {
// We reverse the iterators.
EncodeRow<InputStruct>(std::reverse_iterator<const uint32*>(row_end),
std::reverse_iterator<const uint32*>(pos),
monochrome,
output);
}
}
return true;
}
} // namespace cloud_print