| public WriteEncodedStrip ( int strip, byte buffer, int count ) : int | ||
| strip | int | The zero-based index of the strip to write. |
| buffer | byte | The buffer with image data to be encoded and written. |
| count | int | The maximum number of strip bytes to be read from
/// |
| return | int | |
/*
* Strip -> strip for change in encoding.
*/
bool cpDecodedStrips(Tiff inImage, Tiff outImage, int imagelength, int imagewidth, short spp)
{
int stripsize = inImage.StripSize();
byte[] buf = new byte[stripsize];
int ns = inImage.NumberOfStrips();
int row = 0;
for (int s = 0; s < ns; s++)
{
int cc = (row + m_rowsperstrip > imagelength) ? inImage.VStripSize(imagelength - row) : stripsize;
if (inImage.ReadEncodedStrip(s, buf, 0, cc) < 0 && !m_ignore)
{
Tiff.Error(inImage.FileName(), "Error, can't read strip {0}", s);
return false;
}
if (outImage.WriteEncodedStrip(s, buf, cc) < 0)
{
Tiff.Error(outImage.FileName(), "Error, can't write strip {0}", s);
return false;
}
row += m_rowsperstrip;
}
return true;
}
static bool writeBufferToSeparateStrips(Tiff outImage, byte[] buf, int imagelength, int imagewidth, short spp)
{
byte[] obuf = new byte[outImage.StripSize()];
FieldValue[] result = outImage.GetFieldDefaulted(TiffTag.ROWSPERSTRIP);
int rowsperstrip = result[0].ToInt();
int rowsize = imagewidth * spp;
int strip = 0;
for (short s = 0; s < spp; s++)
{
for (int row = 0; row < imagelength; row += rowsperstrip)
{
int nrows = (row + rowsperstrip > imagelength) ? imagelength - row : rowsperstrip;
int stripsize = outImage.VStripSize(nrows);
cpContigBufToSeparateBuf(obuf, buf, row * rowsize + s, nrows, imagewidth, 0, 0, spp, 1);
if (outImage.WriteEncodedStrip(strip++, obuf, stripsize) < 0)
{
Tiff.Error(outImage.FileName(), "Error, can't write strip {0}", strip - 1);
return false;
}
}
}
return true;
}
/// <summary>
/// Read the whole image into one big RGBA buffer and then write out
/// strips from that. This is using the traditional TIFFReadRGBAImage()
/// API that we trust.
/// </summary>
private bool cvt_whole_image(Tiff inImage, Tiff outImage, int width, int height)
{
int pixel_count = width * height;
/* XXX: Check the integer overflow. */
if (width == 0 || height == 0 || (pixel_count / width) != height)
{
Tiff.Error(inImage.FileName(),
"Malformed input file; can't allocate buffer for raster of {0}x{1} size",
width, height);
return false;
}
m_rowsPerStrip = outImage.DefaultStripSize(m_rowsPerStrip);
outImage.SetField(TiffTag.ROWSPERSTRIP, m_rowsPerStrip);
int[] raster = new int[pixel_count];
/* Read the image in one chunk into an RGBA array */
if (!inImage.ReadRGBAImageOriented(width, height, raster, Orientation.TOPLEFT, false))
return false;
/*
* Do we want to strip away alpha components?
*/
byte[] rasterBytes;
int rasterByteSize;
if (m_noAlpha)
{
rasterByteSize = pixel_count * 3;
rasterBytes = new byte[rasterByteSize];
for (int i = 0, rasterBytesPos = 0; i < pixel_count; i++)
{
byte[] bytes = BitConverter.GetBytes(raster[i]);
rasterBytes[rasterBytesPos++] = bytes[0];
rasterBytes[rasterBytesPos++] = bytes[1];
rasterBytes[rasterBytesPos++] = bytes[2];
}
}
else
{
rasterByteSize = pixel_count * 4;
rasterBytes = new byte[rasterByteSize];
Buffer.BlockCopy(raster, 0, rasterBytes, 0, rasterByteSize);
}
/*
* Write out the result in strips
*/
for (int row = 0; row < height; row += m_rowsPerStrip)
{
int bytes_per_pixel;
if (m_noAlpha)
bytes_per_pixel = 3;
else
bytes_per_pixel = 4;
int rows_to_write;
if (row + m_rowsPerStrip > height)
rows_to_write = height - row;
else
rows_to_write = m_rowsPerStrip;
int offset = bytes_per_pixel * row * width;
int count = bytes_per_pixel * rows_to_write * width;
if (outImage.WriteEncodedStrip(row / m_rowsPerStrip, rasterBytes, offset, count) == -1)
return false;
}
return true;
}
static bool writeBufferToContigStrips(Tiff outImage, byte[] buffer, int imagelength, int imagewidth, short spp)
{
FieldValue[] result = outImage.GetFieldDefaulted(TiffTag.ROWSPERSTRIP);
int rowsperstrip = result[0].ToInt();
int strip = 0;
int offset = 0;
for (int row = 0; row < imagelength; row += rowsperstrip)
{
int nrows = (row + rowsperstrip > imagelength) ? imagelength - row : rowsperstrip;
int stripsize = outImage.VStripSize(nrows);
if (outImage.WriteEncodedStrip(strip++, buffer, offset, stripsize) < 0)
{
Tiff.Error(outImage.FileName(), "Error, can't write strip {0}", strip - 1);
return false;
}
offset += stripsize;
}
return true;
}
private bool cvt_by_strip(Tiff inImage, Tiff outImage, int width, int height)
{
FieldValue[] result = inImage.GetField(TiffTag.ROWSPERSTRIP);
if (result == null)
{
Tiff.Error(inImage.FileName(), "Source image not in strips");
return false;
}
m_rowsPerStrip = result[0].ToInt();
outImage.SetField(TiffTag.ROWSPERSTRIP, m_rowsPerStrip);
// Allocate strip buffer
int raster_size = multiply(width, m_rowsPerStrip);
int rasterByteSize = multiply(raster_size, sizeof(int));
if (raster_size == 0 || rasterByteSize == 0)
{
Tiff.Error(inImage.FileName(),
"Can't allocate buffer for raster of size {0}x{1}", width, m_rowsPerStrip);
return false;
}
int[] raster = new int[raster_size];
byte[] rasterBytes = new byte[rasterByteSize];
// Allocate a scanline buffer for swapping during the vertical mirroring pass.
// (Request can't overflow given prior checks.)
int[] wrk_line = new int[width];
// Loop over the strips.
for (int row = 0; row < height; row += m_rowsPerStrip)
{
// Read the strip into an RGBA array
if (!inImage.ReadRGBAStrip(row, raster))
return false;
// Figure out the number of scanlines actually in this strip.
int rows_to_write;
if (row + m_rowsPerStrip > height)
rows_to_write = height - row;
else
rows_to_write = m_rowsPerStrip;
// For some reason the TIFFReadRGBAStrip() function chooses the lower left corner
// as the origin. Vertically mirror scanlines.
for (int i_row = 0; i_row < rows_to_write / 2; i_row++)
{
int topIndex = width * i_row * sizeof(int);
int bottomIndex = width * (rows_to_write - i_row - 1) * sizeof(int);
Buffer.BlockCopy(raster, topIndex, wrk_line, 0, width * sizeof(int));
Buffer.BlockCopy(raster, bottomIndex, raster, topIndex, width * sizeof(int));
Buffer.BlockCopy(wrk_line, 0, raster, bottomIndex, width * sizeof(int));
}
// Write out the result in a strip
int bytesToWrite = rows_to_write * width * sizeof(int);
Buffer.BlockCopy(raster, 0, rasterBytes, 0, bytesToWrite);
if (outImage.WriteEncodedStrip(row / m_rowsPerStrip, rasterBytes, bytesToWrite) == -1)
return false;
}
return true;
}
