template <typename T> static
void im_load_color(struct jpeg_decompress_struct *cinfo, bob::io::base::array::interface& b) {
const bob::io::base::array::typeinfo& info = b.type();
long unsigned int frame_size = info.shape[1] * info.shape[2];
T *element_r = static_cast<T*>(b.ptr());
T *element_g = element_r+frame_size;
T *element_b = element_g+frame_size;
const int row_stride = cinfo->output_width * cinfo->output_components;
JSAMPROW buffer_pptr[1];
boost::shared_array<JSAMPLE> buffer(new JSAMPLE[row_stride]);
buffer_pptr[0] = buffer.get();
while (cinfo->output_scanline < cinfo->output_height) {
jpeg_read_scanlines(cinfo, buffer_pptr, 1);
if (cinfo->output_components == 3)
imbuffer_to_rgb<T>(info.shape[2], reinterpret_cast<T*>(buffer_pptr[0]), element_r, element_g, element_b);
else
cmyk_imbuffer_to_rgb<T>(info.shape[2], reinterpret_cast<T*>(buffer_pptr[0]), element_r, element_g, element_b, cinfo->saw_Adobe_marker);
element_r += cinfo->output_width;
element_g += cinfo->output_width;
element_b += cinfo->output_width;
}
}
template <typename T> static
void im_load_gray(struct jpeg_decompress_struct *cinfo, bob::io::base::array::interface& b) {
const bob::io::base::array::typeinfo& info = b.type();
T *element = static_cast<T*>(b.ptr());
const int row_stride = info.shape[1];
JSAMPROW buffer_pptr[1];
while (cinfo->output_scanline < cinfo->image_height) {
buffer_pptr[0] = element;
jpeg_read_scanlines(cinfo, buffer_pptr, 1);
element += row_stride;
}
}
static void im_save_gray(const bob::io::base::array::interface& b, struct jpeg_compress_struct *cinfo) {
const bob::io::base::array::typeinfo& info = b.type();
const T* element = static_cast<const T*>(b.ptr());
// pointer to a single row (JSAMPLE is a typedef to unsigned char or char)
JSAMPROW row_pointer[1];
int row_stride = info.shape[1]; // JSAMPLEs per row in image_buffer
while(cinfo->next_scanline < cinfo->image_height) {
row_pointer[0] = const_cast<T*>(element);
jpeg_write_scanlines(cinfo, row_pointer, 1);
element += row_stride;
}
}
void bob::io::audio::Writer::append(const bob::io::base::array::interface& data) {
if (!m_opened) {
boost::format m("audio writer for file `%s' is closed and cannot be written to");
m % m_filename;
throw std::runtime_error(m.str());
}
const bob::io::base::array::typeinfo& type = data.type();
if (type.dtype != bob::io::base::array::t_float64) {
boost::format m("input data type = `%s' does not conform to the specified input specifications (1 or 2D array of type `%s'), while writing data to file `%s'");
m % type.str() % m_typeinfo.item_str() % m_filename;
throw std::runtime_error(m.str());
}
if (type.nd == 1) { //appends single sample
blitz::TinyVector<int,1> shape;
shape = type.shape[0];
blitz::Array<double,1> tmp(const_cast<double*>(static_cast<const double*>(data.ptr())), shape, blitz::neverDeleteData);
this->append(tmp);
}
else if (type.nd == 2) { //appends multiple frames
blitz::TinyVector<int,2> shape;
shape = type.shape[0], type.shape[1];
blitz::Array<double,2> tmp(const_cast<double*>(static_cast<const double*>(data.ptr())), shape, blitz::neverDeleteData);
this->append(tmp);
}
else {
boost::format m("input data type information = `%s' does not conform to the specified input specifications (1 or 2D array of type = `%s'), while writing data to file `%s'");
m % type.str() % m_typeinfo.item_str() % m_filename;
}
}
static void im_save_color(const bob::io::base::array::interface& b, boost::shared_ptr<TIFF> out_file)
{
const bob::io::base::array::typeinfo& info = b.type();
const size_t height = info.shape[1];
const size_t width = info.shape[2];
const size_t frame_size = height * width;
// Allocate array for a row as an RGB-like array
boost::shared_array<T> row(new T[3*width*height]);
unsigned char* row_pointer = reinterpret_cast<unsigned char*>(row.get());
// pointer to a single row (tiff_bytep is a typedef to unsigned char or char)
const T *element_r = static_cast<const T*>(b.ptr());
const T *element_g = element_r + frame_size;
const T *element_b = element_g + frame_size;
rgb_to_imbuffer(frame_size, element_r, element_g, element_b, row.get());
// Write the information to the file
const size_t data_size = 3 * height * width * sizeof(T);
TIFFWriteEncodedStrip(out_file.get(), 0, row_pointer, data_size);
}
static void im_save_color(const bob::io::base::array::interface& b, struct jpeg_compress_struct *cinfo) {
const bob::io::base::array::typeinfo& info = b.type();
long unsigned int frame_size = info.shape[1] * info.shape[2];
const T *element_r = static_cast<const T*>(b.ptr());
const T *element_g = element_r + frame_size;
const T *element_b = element_g + frame_size;
// pointer to a single row (JSAMPLE is a typedef to unsigned char or char)
boost::shared_array<JSAMPLE> row(new JSAMPLE[3*info.shape[2]]);
JSAMPROW array_ptr[1];
array_ptr[0] = row.get();
int row_color_stride = info.shape[2]; // JSAMPLEs per row in image_buffer
while(cinfo->next_scanline < cinfo->image_height) {
rgb_to_imbuffer(row_color_stride, element_r, element_g, element_b, reinterpret_cast<T*>(array_ptr[0]));
jpeg_write_scanlines(cinfo, array_ptr, 1);
element_r += row_color_stride;
element_g += row_color_stride;
element_b += row_color_stride;
}
}
template <typename T> static
void im_load_gray(boost::shared_ptr<TIFF> in_file, bob::io::base::array::interface& b)
{
const bob::io::base::array::typeinfo& info = b.type();
const size_t height = info.shape[0];
const size_t width = info.shape[1];
// Read in the possibly multiple strips
tsize_t strip_size = TIFFStripSize(in_file.get());
tstrip_t n_strips = TIFFNumberOfStrips(in_file.get());
unsigned long buffer_size = n_strips * strip_size;
boost::shared_array<unsigned char> buffer_(new unsigned char[buffer_size]);
unsigned char* buffer = buffer_.get();
if(buffer == 0) throw std::runtime_error("TIFF: error while getting the color buffer");
tsize_t result;
tsize_t image_offset = 0;
for(tstrip_t strip_count=0; strip_count<n_strips; ++strip_count)
{
if((result = TIFFReadEncodedStrip(in_file.get(), strip_count, buffer+image_offset, strip_size)) == -1)
throw std::runtime_error("TIFF: error in function TIFFReadEncodedStrip()");
image_offset += result;
}
//Comment just to document
//PHOTOMETRIC_PALETTE: In this model, a color is described with a single component. The value of the component is used as an index into the red, green and blue curves in the ColorMap field to retrieve an RGB triplet that defines the color. When PhotometricInterpretation=3
// Deal with photometric interpretations
uint16 photo = PHOTOMETRIC_MINISBLACK;
if(TIFFGetField(in_file.get(), TIFFTAG_PHOTOMETRIC, &photo) == 0 || (photo != PHOTOMETRIC_MINISBLACK && photo != PHOTOMETRIC_MINISWHITE && photo != PHOTOMETRIC_PALETTE)){
throw std::runtime_error("TIFF: error in function TIFFGetField()");
}
if(photo == PHOTOMETRIC_MINISWHITE)
{
// Flip bits
for(unsigned long count=0; count<buffer_size; ++count)
buffer[count] = ~buffer[count];
}
// Deal with fillorder
uint16 fillorder = FILLORDER_MSB2LSB;
TIFFGetField(in_file.get(), TIFFTAG_FILLORDER, &fillorder);
if(fillorder != FILLORDER_MSB2LSB) {
// We need to swap bits -- ABCDEFGH becomes HGFEDCBA
for(unsigned long count=0; count<buffer_size; ++count)
{
unsigned char tempbyte = 0;
if(buffer[count] & 128) tempbyte += 1;
if(buffer[count] & 64) tempbyte += 2;
if(buffer[count] & 32) tempbyte += 4;
if(buffer[count] & 16) tempbyte += 8;
if(buffer[count] & 8) tempbyte += 16;
if(buffer[count] & 4) tempbyte += 32;
if(buffer[count] & 2) tempbyte += 64;
if(buffer[count] & 1) tempbyte += 128;
buffer[count] = tempbyte;
}
}
// Copy to output array
T *element = reinterpret_cast<T*>(b.ptr());
T *b_in = reinterpret_cast<T*>(buffer);
memcpy(element, b_in, height*width*sizeof(T));
}
static void im_save_gray(const bob::io::base::array::interface& b, boost::shared_ptr<TIFF> out_file)
{
const bob::io::base::array::typeinfo& info = b.type();
const size_t height = info.shape[0];
const size_t width = info.shape[1];
unsigned char* row_pointer = const_cast<unsigned char*>(reinterpret_cast<const unsigned char*>(b.ptr()));
const size_t data_size = height * width * sizeof(T);
// Write the information to the file
TIFFWriteEncodedStrip(out_file.get(), 0, row_pointer, data_size);
}
template <typename T> static
void im_load_color(boost::shared_ptr<TIFF> in_file, bob::io::base::array::interface& b)
{
const bob::io::base::array::typeinfo& info = b.type();
const size_t height = info.shape[1];
const size_t width = info.shape[2];
const size_t frame_size = height*width;
const size_t row_stride = width;
const size_t row_color_stride = 3*width;
// Read in the possibly multiple strips
tsize_t strip_size = TIFFStripSize(in_file.get());
tstrip_t n_strips = TIFFNumberOfStrips(in_file.get());
unsigned long buffer_size = n_strips * strip_size;
boost::shared_array<unsigned char> buffer_(new unsigned char[buffer_size]);
unsigned char* buffer = buffer_.get();
if(buffer == 0) throw std::runtime_error("TIFF: error while getting the color buffer");
tsize_t result;
tsize_t image_offset = 0;
for(tstrip_t strip_count=0; strip_count<n_strips; ++strip_count)
{
if((result = TIFFReadEncodedStrip(in_file.get(), strip_count, buffer+image_offset, strip_size)) == -1)
throw std::runtime_error("TIFF: error in function TIFFReadEncodedStrip()");
image_offset += result;
}
// Deal with photometric interpretations
uint16 photo = PHOTOMETRIC_RGB;
if(TIFFGetField(in_file.get(), TIFFTAG_PHOTOMETRIC, &photo) == 0 || photo != PHOTOMETRIC_RGB)
throw std::runtime_error("TIFF: error in function TIFFGetField()");
// Deal with fillorder
uint16 fillorder = FILLORDER_MSB2LSB;
TIFFGetField(in_file.get(), TIFFTAG_FILLORDER, &fillorder);
if(fillorder != FILLORDER_MSB2LSB) {
// We need to swap bits -- ABCDEFGH becomes HGFEDCBA
for(unsigned long count=0; count<(unsigned long)image_offset; ++count)
{
unsigned char tempbyte = 0;
if(buffer[count] & 128) tempbyte += 1;
if(buffer[count] & 64) tempbyte += 2;
if(buffer[count] & 32) tempbyte += 4;
if(buffer[count] & 16) tempbyte += 8;
if(buffer[count] & 8) tempbyte += 16;
if(buffer[count] & 4) tempbyte += 32;
if(buffer[count] & 2) tempbyte += 64;
if(buffer[count] & 1) tempbyte += 128;
buffer[count] = tempbyte;
}
}
// Read the image (one row at a time)
// This can deal with interlacing
T *element_r = reinterpret_cast<T*>(b.ptr());
T *element_g = element_r + frame_size;
T *element_b = element_g + frame_size;
unsigned char *row_pointer = buffer;
// Loop over the rows
for(size_t y=0; y<height; ++y)
{
imbuffer_to_rgb(row_stride, reinterpret_cast<T*>(row_pointer), element_r, element_g, element_b);
element_r += row_stride;
element_g += row_stride;
element_b += row_stride;
row_pointer += row_color_stride * sizeof(T);
}
}