static void writeMipMap(Common::WriteStream &stream, const ImageDecoder::MipMap &mipMap, PixelFormat format) {
const byte *data = mipMap.data.get();
uint32 count = mipMap.width * mipMap.height;
while (count-- > 0)
writePixel(stream, data, format);
}
void Image::write(string filepath) throw(ExceptionTP1) {
// Création d'un fichier (mode out)
ofstream ofs;
ofs.open(filepath);
if (ofs.is_open()) {
// Ecriture du header
ofs << CODE_PPM;
ofs << '\n';
ofs << m_largeur;
ofs << " ";
ofs << m_hauteur;
ofs << '\n';
ofs << NB_COULEURS;
ofs << '\n';
// Boucle d'écriture des pixels
int lineSize = 0;
for (int i = 0; i < (int)m_pixels.size(); i++) {
lineSize = writePixel(m_pixels[i], ofs, lineSize);
}
}
else {
throw ExceptionTP1(ERREUR_ECRITURE);
}
ofs.close();
}
void dumpTGA(const Common::UString &fileName, const byte *data, int width, int height, PixelFormat format) {
if ((width <= 0) || (height <= 0) || !data)
throw Common::Exception("Invalid image data (%dx%d %d)", width, height, data != 0);
Common::WriteFile file;
if (!file.open(fileName))
throw Common::Exception(Common::kOpenError);
file.writeByte(0); // ID Length
file.writeByte(0); // Palette size
file.writeByte(2); // Unmapped RGB
file.writeUint32LE(0); // Color map
file.writeByte(0); // Color map
file.writeUint16LE(0); // X
file.writeUint16LE(0); // Y
file.writeUint16LE(width);
file.writeUint16LE(height);
file.writeByte(32); // Pixel depths
file.writeByte(0);
uint32 count = width * height;
for (uint32 i = 0; i < count; i++)
writePixel(file, data, format);
file.close();
}
void trans_accum_save_4x4(int width, int pixelsNum, uint32_t *src,
int src_stride, uint16_t *dst, int dst_stride,
int bd) {
__m128i u[4], v[4];
const __m128i ones = _mm_set1_epi16(1);
transClipPixel(src, src_stride, u, bd);
v[0] = _mm_loadl_epi64((__m128i const *)dst);
v[1] = _mm_loadl_epi64((__m128i const *)(dst + dst_stride));
v[2] = _mm_loadl_epi64((__m128i const *)(dst + 2 * dst_stride));
v[3] = _mm_loadl_epi64((__m128i const *)(dst + 3 * dst_stride));
u[0] = _mm_add_epi16(u[0], v[0]);
u[1] = _mm_add_epi16(u[1], v[1]);
u[2] = _mm_add_epi16(u[2], v[2]);
u[3] = _mm_add_epi16(u[3], v[3]);
u[0] = _mm_add_epi16(u[0], ones);
u[1] = _mm_add_epi16(u[1], ones);
u[2] = _mm_add_epi16(u[2], ones);
u[3] = _mm_add_epi16(u[3], ones);
u[0] = _mm_srai_epi16(u[0], 1);
u[1] = _mm_srai_epi16(u[1], 1);
u[2] = _mm_srai_epi16(u[2], 1);
u[3] = _mm_srai_epi16(u[3], 1);
writePixel(u, width, pixelsNum, dst, dst_stride);
}
/* write whole image to file */
void Image::writeImage(Pixel* Pixels) {
int size = this->width*this->height;
for(int i=size-1; i >=0 ; i --) {
writePixel(Pixels[i]);
}
}
//LCD Unbuffered Functions
drawToB(int x0, int y0, int x1, int y1) {
uint8_t steep = abs(y1 - y0) > abs(x1 - x0);
uint8_t dx, dy;
int8_t err;
int8_t ystep;
if (steep) {
swap(x0, y0);
swap(x1, y1);
}
if (x0 > x1) {
swap(x0, x1);
swap(y0, y1);
}
dx = x1 - x0;
dy = abs(y1 - y0);
err = dx / 2;
if (y0 < y1) {
ystep = 1;
} else {
ystep = -1;
}
for (; x0<=x1; x0++) {
if (steep) {
writePixel(y0, x0);
} else {
writePixel(x0, y0);
}
err -= dy;
if (err < 0) {
y0 += ystep;
err += dx;
}
}
}
//--------Delivers BMP Image---------//
void serveBMP (int socket, char request[]) {
int row = -SIZE/2; //Defines where each row should start
int col = -SIZE/2; //Defines where first column should start
int iterations = 0; //Count the amount of iterations needed
//to escape the set
complex current; //The current coodinates of the point
//being tested
int colCounter = 0; //Current collum
int rowCounter = 0; //Current row
int zoom = 0; //The zoom level of the image
double xMiddle = 0; //The x (real) component of the
//center of the image
double yMiddle = 0; //The y (imaginary) component of the
//center of the image
bits8 byte = 0; //Intensity of color from each sub-pixel
writeHTTPHeader(socket);
writeBMPHeader(socket);
//get coordinates from URL
sscanf (request, "GET /tile_x%lf_y%lf_z%d.bmp",
&xMiddle,&yMiddle,&zoom);
//print each pixel out
while (rowCounter < SIZE){
current.y = yMiddle + row*exp2(-1*zoom) + exp2(-1*zoom)/2;
while (colCounter < SIZE){
current.x = xMiddle + col*exp2(-1*zoom) + exp2(-1*zoom)/2;
iterations = escapeSteps(current.x,current.y);
writePixel (socket,iterations, byte);
col++;
colCounter++;
}
col = -SIZE/2;
colCounter = 0;
row++;
rowCounter++;
}
}
void BitmapWriter::writeBitmap(Bitmap & bitmap, const char * filePath)
{
FILE * file = fopen(filePath, "wb");
writeFileHeader(bitmap.fileheader, file);
writeInfoHeader(bitmap.infoheader, file);
byte zero = 0;
for (int i = 0; i < bitmap.height; i++) {
for (int j = 0; j < bitmap.width; j++)
writePixel(bitmap.get(j, i), file);
for (int j = 0; j < bitmap.paddingZeros; j++)
fwrite(&zero, sizeof(byte), 1, file);
}
fclose(file);
}
drawTo(int x1, int y1, int x2, int y2) {
int dx;
int dy;
int yax = 0;
int xax = 0;
dx = x2 - x1;
dy = y2 - y1;
for (xax = x1; xax >= x1 && xax <= x2; xax++) {
xax++;
yax = y1 + (dy) * (xax - x1)/(dx);
writePixel(xax,yax);
if (xax > x2) {
break;
}
}
}
static Boln tgaWriteScan (Tcl_Interp *interp, tkimg_MFile *handle,
TGAFILE *tf, Int y)
{
UByte *stop, *red_end, *green_end, *blue_end, *matte_end;
Int nchan;
tf->red = tf->redScan;
tf->green = tf->greenScan;
tf->blue = tf->blueScan;
tf->matte = tf->matteScan;
stop = tf->red + tf->th.xsize;
nchan = NCHAN (tf->th.pixsize);
/* Write the scanline data to the file. */
if (! IS_COMPRESSED (tf->th.imgtyp)) {
while (tf->red < stop)
{
if (!writePixel (handle, *tf->blue, *tf->green, *tf->red, *tf->matte, nchan))
return FALSE;
tf->blue++;
tf->green++;
tf->red++;
tf->matte++;
}
}
else /* Run-length Compression */
{
red_end = tf->red + 1;
green_end = tf->green + 1;
blue_end = tf->blue + 1;
matte_end = tf->matte + 1;
while (tf->red < stop)
{
while (red_end < stop &&
*tf->red == *red_end &&
*tf->green == *green_end &&
*tf->blue == *blue_end &&
red_end - tf->red - 1 < MAXRUN)
{
if (nchan == 4)
{
if (*tf->matte != *matte_end)
break;
}
red_end++;
green_end++;
blue_end++;
matte_end++;
}
if (red_end - tf->red >= MINRUN)
{ /* Found a run of compressable data */
if (!writeByte (handle, (Byte)(((red_end - tf->red)-1)|0x80)) ||
!writePixel (handle, *tf->blue, *tf->green, *tf->red, *tf->matte, nchan))
return FALSE;
tf->red = red_end;
tf->green = green_end;
tf->blue = blue_end;
tf->matte = matte_end;
}
else
{ /* Found a run of uncompressable data */
while (red_end < stop &&
((red_end + 1 >= stop ||
*red_end != *(red_end + 1)) ||
(red_end + 2 >= stop ||
*(red_end + 1) != *(red_end + 2))) &&
((green_end + 1 >= stop ||
*green_end != *(green_end + 1)) ||
(green_end + 2 >= stop ||
*(green_end + 1) != *(green_end + 2))) &&
((blue_end + 1 >= stop ||
*blue_end != *(blue_end + 1)) ||
(blue_end + 2 >= stop ||
*(blue_end + 1) != *(blue_end + 2))) &&
red_end - tf->red < MAXRUN)
{
if (nchan == 4)
{
if (! ((matte_end + 1 >= stop ||
*matte_end != *(matte_end + 1)) ||
(matte_end + 2 >= stop ||
*(matte_end + 1) != *(matte_end + 2))))
break;
}
red_end++;
green_end++;
blue_end++;
matte_end++;
}
if (!writeByte (handle, (Byte)((red_end - tf->red) - 1)))
return FALSE;
while (tf->red < red_end)
{
if (!writePixel (handle, *tf->blue, *tf->green, *tf->red, *tf->matte, nchan))
return FALSE;
tf->red++;
tf->green++;
tf->blue++;
tf->matte++;
}
}
red_end++;
green_end++;
blue_end++;
matte_end++;
}
}
return TRUE;
}
void writePixel(int x,int y,int r,int g,int b)
{
writePixel(x,y,pixel(r,g,b));
}
// pixelsNum = 0 : all 4 rows of pixels will be saved.
// pixelsNum = 1/2/3 : residual 1/2/4 rows of pixels will be saved.
void trans_save_4x4(int width, int pixelsNum, uint32_t *src, int src_stride,
uint16_t *dst, int dst_stride, int bd) {
__m128i u[4];
transClipPixel(src, src_stride, u, bd);
writePixel(u, width, pixelsNum, dst, dst_stride);
}
void Fe65p2::configurePixels() {
// Set threshold high
uint16_t tmp1 = getValue(&Fe65p2::Vthin1Dac);
uint16_t tmp2 = getValue(&Fe65p2::Vthin2Dac);
uint16_t tmp3 = getValue(&Fe65p2::PreCompVbnDac);
uint16_t tmp4 = getValue(&Fe65p2::CompVbnDac);
uint16_t tmp5 = getValue(&Fe65p2::VffDac);
uint16_t tmp6 = getValue(&Fe65p2::PrmpVbpDac);
uint16_t tmp7 = getValue(&Fe65p2::PrmpVbnFolDac);
setValue(&Fe65p2::Vthin1Dac, 255);
setValue(&Fe65p2::Vthin2Dac, 0);
//setValue(&Fe65p2::PreCompVbnDac, 0);
//setValue(&Fe65p2::CompVbnDac, 0);
setValue(&Fe65p2::VffDac, 10);
//setValue(&Fe65p2::PrmpVbpDac, 50);
setValue(&Fe65p2::PrmpVbnFolDac, 0);
uint16_t colEn = getValue(&Fe65p2::ColEn);
uint16_t colSrEn = getValue(&Fe65p2::ColSrEn);
// Turn all off
setValue(&Fe65p2::ColSrEn, 0xFFFF);
setValue(&Fe65p2::ColEn, 0xFFFF);
configureGlobal();
writePixel((uint16_t) 0x0);
setValue(&Fe65p2::PixConfLd, 0x3);
configureGlobal();
setValue(&Fe65p2::PixConfLd, 0x0);
configureGlobal();
// Configure global regs
//configureGlobal();
// Configure pixel regs
for(unsigned i=0; i<Fe65p2Cfg::n_QC; i++) {
setValue(&Fe65p2::ColSrEn, (0x1<<i));
setValue(&Fe65p2::OneSr, 0);
configureGlobal();
for(unsigned bit=0; bit<Fe65p2Cfg::n_Bits; bit++) {
writePixel(getCfg(bit, i));
switch (bit) {
case 0:
setValue(&Fe65p2::SignLd, 0x1);
break;
case 1:
setValue(&Fe65p2::InjEnLd, 0x1);
break;
case 2:
setValue(&Fe65p2::TDacLd, 0x1);
break;
case 3:
setValue(&Fe65p2::TDacLd, 0x2);
break;
case 4:
setValue(&Fe65p2::TDacLd, 0x4);
break;
case 5:
setValue(&Fe65p2::TDacLd, 0x8);
break;
case 6:
setValue(&Fe65p2::PixConfLd, 0x1);
break;
case 7:
setValue(&Fe65p2::PixConfLd, 0x2);
break;
default:
break;
}
configureGlobal();
// Unset Shadow registers
setValue(&Fe65p2::SignLd, 0x0);
setValue(&Fe65p2::InjEnLd, 0x0);
setValue(&Fe65p2::TDacLd, 0x0);
setValue(&Fe65p2::PixConfLd, 0x0);
configureGlobal();
writePixel((uint16_t) 0x0);
}
}
// Reset SR
writePixel((uint16_t) 0x0);
// Reset threshold
setValue(&Fe65p2::Vthin1Dac, tmp1);
setValue(&Fe65p2::Vthin2Dac, tmp2);
setValue(&Fe65p2::PreCompVbnDac, tmp3);
setValue(&Fe65p2::CompVbnDac, tmp4);
setValue(&Fe65p2::VffDac, tmp5);
setValue(&Fe65p2::PrmpVbpDac, tmp6);
setValue(&Fe65p2::PrmpVbnFolDac, tmp7);
setValue(&Fe65p2::ColSrEn, colSrEn);
setValue(&Fe65p2::ColEn, colEn);
configureGlobal();
}
int cropImage(FILE* inFile, struct bmpFileHeader* fileHead,
struct bmpInfoHeader* infoHead, char* outFileName, int cropWidth,
int cropHeight, int cropStart[])
{
// check that cropping parameters make sense
if (((cropWidth + cropStart[0]) > infoHead->width) ||
((cropHeight + cropStart[1]) > infoHead->height))
{
fprintf(stderr, "Cropping parameters incorrect.\n");
return EXIT_FAILURE;
}
// open file for writing
FILE *outFile = fopen(outFileName, "w+");
// check that file opened okay
if (outFile == NULL)
{
fprintf(stderr, "Unable to open file: %s for writing.\n", outFileName);
return EXIT_FAILURE;
}
// store old width/height for use in loop
LONG oldWidth = infoHead->width;
LONG oldHeight = infoHead->height;
// calculate padding used in old image
int oldPadding = (4 - (oldWidth*sizeof(struct pixel) % 4)) % 4;
// calculate padding to be used in new image
int newPadding = (4 - (cropWidth*sizeof(struct pixel) % 4)) % 4;
// new image size
infoHead->imageSize = (cropWidth*sizeof(struct pixel) +
newPadding)*cropHeight;
// file size
fileHead->fileSize = sizeof(struct bmpFileHeader) +
sizeof(struct bmpInfoHeader) + infoHead->imageSize;
// new dimensions
infoHead->width = cropWidth;
infoHead->height = cropHeight;
// write the headers to the output file, checking for errors
if (writeFileHeader(fileHead, outFile) != 0)
{
fprintf(stderr, "Unable to write file header.\n");
return EXIT_FAILURE;
}
if (writeInfoHeader(infoHead, outFile) != 0)
{
fprintf(stderr, "Unable to write info header.\n");
return EXIT_FAILURE;
}
// to store pixel being worked on
struct pixel* curPixel = NULL;
// run through old pixels, discarding those which are to be cropped
// and writing the rest to file
for (int i = 0; i < oldHeight; i++)
{
// only run through line if we're out of region to be cropped
if (!(i < (oldHeight - cropStart[1] - cropHeight) ||
i > (oldHeight - cropStart[1])))
{
for (int j = 0; j < oldWidth; j++)
{
// only write to file if not in cropped region
if (!(j < cropStart[0] || j > cropStart[0] + cropWidth))
{
// read in the current pixel
curPixel = getPixel(inFile);
// make sure read worked
if (curPixel == NULL)
{
fprintf(stderr, "Unable to read pixel.\n");
return EXIT_FAILURE;
}
// write current pixel, checking for error
if (writePixel(curPixel, outFile) != EXIT_SUCCESS)
{
fprintf(stderr, "Unable to write pixel.\n");
return EXIT_FAILURE;
}
}
else
{
// move old file on by a pixel
fseek(inFile, sizeof(struct pixel), SEEK_CUR);
}
}
}
else
{
// move old file on by width + padding
fseek(inFile, oldWidth*sizeof(struct pixel) + oldPadding, SEEK_CUR);
}
// move old file on by padding
fseek(inFile, oldPadding, SEEK_CUR);
// add padding to new file
for (int k = 0; k < newPadding; k++)
{
fputc(0x00, outFile);
}
}
// free memory allocated to current pixel storage
free(curPixel);
// close the output file, checking for error
if (fclose(outFile) != 0)
{
fprintf(stderr, "Unable to close output file: %s.\n", outFileName);
return EXIT_FAILURE;
}
// if program gets to here, everything is okay
return EXIT_SUCCESS;
}
