/////////////////////////////////////////////////////////
// really open the file ! (OS dependent)
//
/////////////////////////////////////////////////////////
bool imageMAGICK :: load(std::string filename, imageStruct&result, gem::Properties&props)
{
  Magick::Image image;
  try {
    ::verbose(2, "reading '%s' with ImageMagick", filename.c_str());
    // Read a file into image object
    try {
      image.read( filename );
    } catch (Magick::Warning e) {
      verbose(1, "magick loading problem: %s", e.what());
    }

    result.xsize=static_cast<GLint>(image.columns());
    result.ysize=static_cast<GLint>(image.rows());
    result.setCsizeByFormat(GL_RGBA);
    result.reallocate();

    result.upsidedown=true;

    try {
      image.write(0,0,result.xsize,result.ysize,
                  "RGBA",
                  Magick::CharPixel,
                  reinterpret_cast<void*>(result.data));
    } catch (Magick::Warning e) {
      verbose(1, "magick decoding problem: %s", e.what());
    }
  }catch( Magick::Exception e )  {
    verbose(1, "magick loading image failed with: %s", e.what());
    return false;
  }
  return true;
}

void pix_convolve :: processGrayImage(imageStruct &image)
{
  const int csize=image.csize;
  image.copy2Image(&tempImg);
  int initX = m_rows / 2;
  int initY = m_cols / 2;
  int maxX = tempImg.xsize - initX;
  int maxY = tempImg.ysize - initY;
  int xTimesc = tempImg.xsize * csize;
  int initOffset = initY * xTimesc + initX * csize;

  for (int y = initY; y < maxY; y++)    {
    int realY = y * xTimesc;
    int offsetY = realY - initOffset;

    for (int x = initX; x < maxX; x++)        {
      int offsetXY = x + offsetY;

      int new_val = 0;
      int offsetXYC = offsetXY;
      for (int matY = 0; matY < m_cols; matY++)   {
        int offsetXYCMat = matY * xTimesc + offsetXYC;
        int realMatY = matY * m_rows;
        for (int matX = 0; matX < m_rows; matX++)     {
          new_val += (tempImg.data[offsetXYCMat + matX] *
                      m_imatrix[realMatY + matX])>>8;
        }
      }
      image.data[x+realY] = CLAMP(new_val);
      //removes insult from injury ??
      // we do not use the m_irange anymore ...  remove it ??
    }
  }
}

void pix_colorreduce :: processGrayImage(imageStruct &image)
{
  tempImage.xsize=image.xsize;
  tempImage.ysize=image.ysize;
  tempImage.fromGray(image.data);

  processRGBAImage(tempImage);

  image.fromRGBA(tempImage.data);
}

/////////////////////////////////////////////////////////
// CreateBuffer
//
/////////////////////////////////////////////////////////
bool refresh_buffer(const imageStruct&reference, imageStruct&buffer)
{
  // only 1 channel !!, to keep data-size handy
  unsigned char*data = buffer.data;
  size_t dataSize = reference.xsize * reference.xsize * reference.ysize * reference.csize * sizeof(unsigned char);
  bool refresh=
    (reference.xsize != buffer.xsize) ||
    (reference.ysize != buffer.ysize) ||
    (reference.csize != buffer.csize);

  buffer.xsize = reference.xsize;
  buffer.ysize = reference.ysize;
  buffer.setCsizeByFormat(reference.format);

  if(data!=buffer.reallocate( dataSize ) || refresh) {
    buffer.setBlack();
  }
  return (0!=buffer.data);
}

bool imageTIFF::save(const imageStruct&constimage, const std::string&filename, const std::string&mimetype, const gem::Properties&props) {
  TIFF *tif = NULL;

  if(GL_YUV422_GEM==constimage.format) {
    error("don't know how to write YUV-images with libTIFF");
    return false;
  }

  tif=TIFFOpen(filename.c_str(), "w");
  if (tif == NULL) {
    return false;
  }
  imageStruct image; constimage.copy2Image(&image);
  image.fixUpDown();

  uint32 width=image.xsize, height = image.ysize;
  short bits=8, samps=image.csize;
  int npixels = width * height;
  //int planar_conf = PLANARCONFIG_CONTIG;
  const char *gemstring = "PD/GEM";

  TIFFSetField(tif, TIFFTAG_IMAGEWIDTH, width);
  TIFFSetField(tif, TIFFTAG_IMAGELENGTH, height);
  TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, bits);
  TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, samps);
  TIFFSetField(tif, TIFFTAG_PLANARCONFIG, 1);
  TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB);

  TIFFSetField(tif, TIFFTAG_XRESOLUTION, 72);
  TIFFSetField(tif, TIFFTAG_YRESOLUTION, 72);
  TIFFSetField(tif, TIFFTAG_RESOLUTIONUNIT, RESUNIT_INCH);

  TIFFSetField(tif, TIFFTAG_SOFTWARE, gemstring);

  int yStride = image.xsize * image.csize;
  unsigned char *srcLine = &(image.data[npixels * image.csize]);
  srcLine -= yStride;

  for (uint32 row = 0; row < height; row++) {
    unsigned char *buf = srcLine;
    if (TIFFWriteScanline(tif, buf, row, 0) < 0)
      {
        error("GEM: could not write line %d to image %s", row, filename.c_str());
        TIFFClose(tif);
        delete [] buf;
        return(false);
      }
    srcLine -= yStride;
  }
  TIFFClose(tif);

  return true;
}

void pix_convolve :: processYUVImage(imageStruct &image)
{
  image.copy2Image(&tempImg);
  //float range = 1;
  int initX = m_rows / 2;
  int initY = m_cols / 2;
  int maxX = tempImg.xsize - initX;
  int maxY = tempImg.ysize - initY;
  int xTimesc = tempImg.xsize * tempImg.csize;
  int initOffset = initY * xTimesc + initX * tempImg.csize;

//   calculate3x3YUV(image,tempImg);

//quick fix for Intel 3x3YUV problems
#ifdef __BIG_ENDIAN__
  if (m_rows == 3 && m_cols == 3) {
    calculate3x3YUV(image,tempImg);
    return;
  }
#endif
  if (m_chroma) {
    for (int y = initY; y < maxY; y++)   {
      int realY = y * xTimesc;
      int offsetY = realY - initOffset;

      for (int x = initX; x < maxX; x++) {
        int realPos = x * tempImg.csize + realY;
        int offsetXY = x * tempImg.csize + offsetY;

        // skip the UV
        for (int c = 1; c < 3; c+=2) {
          int new_val = 0;
          int offsetXYC = offsetXY + c;
          for (int matY = 0; matY < m_cols; matY++) {
            int offsetXYCMat = matY * xTimesc + offsetXYC;
            int realMatY = matY * m_rows;
            for (int matX = 0; matX < m_rows; matX++) {
              new_val += (tempImg.data[offsetXYCMat + matX * tempImg.csize] *
                          m_imatrix[realMatY + matX])>>8;
            }
          }
          image.data[realPos + c] = CLAMP(new_val);
          // image.data[realPos + c-1] = 128;  //remove the U+V
        }
      }
    }
  } else {
    for (int y = initY; y < maxY; y++) {

/////////////////////////////////////////////////////////
// processImage
//
/////////////////////////////////////////////////////////
void pix_frei0r :: processRGBAImage(imageStruct &image)
{
  static double time=0;
  if(!m_plugin)return;

  m_image.xsize=image.xsize;
  m_image.ysize=image.ysize;
  m_image.reallocate();

  m_plugin->process(time, image, m_image);
  time++;

  image.data   = m_image.data;
  image.notowned = true;
  image.setCsizeByFormat(m_image.format);
}

void GemPixDualObj :: processImage(imageStruct &image)
{
  if (!m_cacheRight || m_cacheRight->m_magic!=GEMCACHE_MAGIC){
    m_cacheRight=NULL;
    return;
  }

  //if (!m_cacheRight || !&image || !&m_pixRight || !&m_pixRight->image) return;
  if (!m_pixRightValid || !&image || !&m_pixRight || !&m_pixRight->image) return;

    if (image.xsize != m_pixRight->image.xsize ||
    	image.ysize != m_pixRight->image.ysize)    {
      error("two images do not have equal dimensions (%dx%d != %dx%d)",
	    image.xsize, image.ysize,
	    m_pixRight->image.xsize, m_pixRight->image.ysize);
      m_pixRightValid = 0;
    	return;
    }

    if(image.upsidedown != m_pixRight->image.upsidedown) {
      image.fixUpDown();
      m_pixRight->image.fixUpDown();
    }

    bool found = false;
    switch (image.format) {
    case GL_RGBA:
    case GL_BGRA_EXT:
      PROCESS_COLORSPACE(PROCESS_DUALIMAGE_SIMD(RGBA),
			 PROCESS_DUALIMAGE(RGBA, YUV),
			 PROCESS_DUALIMAGE(RGBA, Gray));
      break;
    case GL_LUMINANCE:
      PROCESS_COLORSPACE(PROCESS_DUALIMAGE(Gray, RGBA),
			 PROCESS_DUALIMAGE(Gray, YUV),
			 PROCESS_DUALIMAGE_SIMD(Gray));
      break;
    case GL_YCBCR_422_GEM:
      PROCESS_COLORSPACE(PROCESS_DUALIMAGE(YUV, RGBA),
			 PROCESS_DUALIMAGE_SIMD(YUV),
			 PROCESS_DUALIMAGE(YUV, Gray));
      break;
    default: break;
    }
    if (!found)processDualImage(image, m_pixRight->image);
}

void pix_convolve :: processRGBAImage(imageStruct &image)
{
  image.copy2Image(&tempImg);
  int initX = m_rows / 2;
  int initY = m_cols / 2;
  int maxX = tempImg.xsize - initX;
  int maxY = tempImg.ysize - initY;
  int xTimesc = tempImg.xsize * tempImg.csize;
  int initOffset = initY * xTimesc + initX * tempImg.csize;
  const int csize = tempImg.csize;

  if (m_rows == 3 && m_cols == 3) {
    calculateRGBA3x3(image,tempImg);
    return;
  }

  for (int y = initY; y < maxY; y++) {
    int realY = y * xTimesc;
    int offsetY = realY - initOffset;

    for (int x = initX; x < maxX; x++) {
      int realPos = x * csize + realY;
      int offsetXY = x * csize + offsetY;

      // skip the alpha value
      for (int c = 1; c < csize; c++) {
        int new_val = 0;
        int offsetXYC = offsetXY + c;
        for (int matY = 0; matY < m_cols; matY++) {
          int offsetXYCMat = matY * xTimesc + offsetXYC;
          int realMatY = matY * m_rows;
          for (int matX = 0; matX < m_rows; matX++) {
            new_val += (tempImg.data[offsetXYCMat + matX * csize] *
                        m_imatrix[realMatY + matX])>>8;
          }
        }
        image.data[realPos + c] = CLAMP(new_val);
        //removes insult from injury ??
        // we do not use the m_irange anymore ...  remove it ??

      }
    }
  }

}

bool imageJPEG::save(const imageStruct&constimage, const std::string&filename, const std::string&mimetype, const gem::Properties&props) {
  struct jpeg_compress_struct cinfo;

  /* More stuff */
  FILE * outfile=NULL;		/* target file */
  JSAMPROW row_pointer;	/* pointer to JSAMPLE row[s] */
  int row_stride;		/* physical row width in image buffer */

  // We set up the normal JPEG error routines, then override error_exit
  my_error_mgr jerr;
  cinfo.err = jpeg_std_error(&jerr.pub);
  jerr.pub.error_exit = my_error_exit;

  // Establish the setjmp return context for my_error_exit to use.
  if ( setjmp(jerr.setjmp_buffer) ) {
    // If we get here, the JPEG code has signaled an error.
    // We need to clean up the JPEG object, close the input file, and return.
    jpeg_destroy_compress(&cinfo);
    if(outfile)
      fclose(outfile);
    return(false);
  }

  double fquality=100;
  props.get("quality", fquality);
  int quality=fquality;

  if(GL_YUV422_GEM==constimage.format) {
    error("don't know how to write YUV-images with libJPEG");
    return false;
  }

  /* Now we can initialize the JPEG compression object. */
  jpeg_create_compress(&cinfo);

  if ((outfile = fopen(filename.c_str(), "wb")) == NULL) {
    error("can't open %s\n", filename.c_str());
    return (false);
  }
  jpeg_stdio_dest(&cinfo, outfile);

  imageStruct image;
  constimage.convertTo(&image, GL_RGB);
  //  image.fixUpDown();
  JSAMPLE *image_buffer = image.data;

  cinfo.image_width = image.xsize; 	/* image width and height, in pixels */
  cinfo.image_height = image.ysize;
  cinfo.input_components = 3;		/* # of color components per pixel */
  cinfo.in_color_space = JCS_RGB; 	/* colorspace of input image */

  jpeg_set_defaults(&cinfo);
  jpeg_set_quality(&cinfo, quality, TRUE /* limit to baseline-JPEG values */);
  jpeg_start_compress(&cinfo, TRUE);

  row_stride = image.xsize * image.csize;	/* JSAMPLEs per row in image_buffer */

  while (cinfo.next_scanline < cinfo.image_height) {
    /* jpeg_write_scanlines expects an array of pointers to scanlines.
     * Here the array is only one element long, but you could pass
     * more than one scanline at a time if that's more convenient.
     */
    int rowindex=cinfo.next_scanline;
    if(!image.upsidedown)
      rowindex=(cinfo.image_height-cinfo.next_scanline-1);
    row_pointer = & image_buffer[rowindex * row_stride];

    if(jpeg_write_scanlines(&cinfo, &row_pointer, 1) < 0){
      error("GEM: could not write line %d to image %s", cinfo.next_scanline, filename.c_str());
      jpeg_finish_compress(&cinfo);
      fclose(outfile);
      jpeg_destroy_compress(&cinfo);
      return(false);
    }
  }

  jpeg_finish_compress(&cinfo);
  fclose(outfile);
  jpeg_destroy_compress(&cinfo);

  return true;
}

/////////////////////////////////////////////////////////
// really open the file ! (OS dependent)
//
/////////////////////////////////////////////////////////
bool imageJPEG :: load(std::string filename, imageStruct&result, gem::Properties&props)
{
  // open up the file
  FILE * infile;
  ::verbose(2, "reading '%s' with libJPEG", filename.c_str());
  if ((infile = fopen(filename.c_str(), "rb")) == NULL) {
    //verbose(2, "GemImageLoad(JPEG): Unable to open image file: %s", filename.c_str());
    return(false);
  }

  // create the jpeg structures
  jpeg_decompress_struct cinfo;
  my_error_mgr jerr;

  // We set up the normal JPEG error routines, then override error_exit
  cinfo.err = jpeg_std_error(&jerr.pub);
  jerr.pub.error_exit = my_error_exit;

  // Establish the setjmp return context for my_error_exit to use.
  if ( setjmp(jerr.setjmp_buffer) ) {
    // If we get here, the JPEG code has signaled an error.
    // We need to clean up the JPEG object, close the input file, and return.
    jpeg_destroy_decompress(&cinfo);
    fclose(infile);
    return(false);
  }

  // create the decompression structure
  jpeg_create_decompress(&cinfo);

  // associate the decompress struct with the file
  jpeg_stdio_src(&cinfo, infile);

  // read in the file info
  jpeg_read_header(&cinfo, TRUE);


  // do we have an RGB image?
  if (cinfo.jpeg_color_space == JCS_RGB) {
    result.setCsizeByFormat(GL_RGBA);
  } else if (cinfo.jpeg_color_space == JCS_GRAYSCALE) {
    // do we have a gray8 image?
    result.setCsizeByFormat(GL_LUMINANCE);
  } else {
    // something else, so decompress as RGB
    result.setCsizeByFormat(GL_RGBA);
    cinfo.out_color_space = JCS_RGB;
  }

  // start the decompression
  jpeg_start_decompress(&cinfo);
  int xSize = cinfo.output_width;
  int ySize = cinfo.output_height;
  int cSize = result.csize;
  result.upsidedown=true;
  result.xsize = xSize;
  result.ysize = ySize;
  result.reallocate();

  // cycle through the scan lines
  unsigned char *srcLine = new unsigned char[xSize * cSize];
  unsigned char *dstLine = result.data;
  int yStride = xSize * cSize;
  int lines = ySize;
  int pixes = xSize;

  // do RGBA/RGB data
  if (cSize == 4) {
    while (lines--) {
      unsigned char *src = srcLine;
      unsigned char *dst = dstLine;
      jpeg_read_scanlines(&cinfo, &src, 1);
      pixes = xSize;
      while (pixes--) {
	dst[chRed]   = src[0];
	dst[chGreen] = src[1];
	dst[chBlue]  = src[2];
	dst[chAlpha] = 255;
	dst += 4;
	src += 3;
      }
      dstLine += yStride;
    }
  } else {
    // do grayscale data
    while (lines--) {
      unsigned char *src = srcLine;
      unsigned char *dst = dstLine;
      jpeg_read_scanlines(&cinfo, &src, 1);
      pixes = xSize;
      while (pixes--) {
	*dst++ = *src++;
      }
      dstLine += yStride;
    }
  }
//.........这里部分代码省略.........

/////////////////////////////////////////////////////////
// processImage
//
/////////////////////////////////////////////////////////
void pix_flip :: processRGBAImage(imageStruct &image)
{
    // eventually should do this inline, but in the interest of getting it done...
    imageStruct tempImg;
    if (image.data==0)return;
    image.copy2Image(&tempImg);
    int ySrcStride = image.xsize * image.csize;
    int yDstStride = image.xsize * image.csize;
    int xSrcStride = image.csize;
    int xDstStride = image.csize;
    unsigned char *srcLine = tempImg.data;
    unsigned char *dstLine = image.data;

    FlipType flip=m_flip;
    if(!image.upsidedown) {
      switch(flip) {
      case(HORIZONTAL) : flip=BOTH;break;
      case(VERTICAL)   : flip=NONE;break;
      case(BOTH)       : flip=HORIZONTAL;break;
      case(NONE)       : flip=VERTICAL  ;break;
      default   :break;
      }
    }
    image.upsidedown=true;

    switch(flip)
    {
    	case(HORIZONTAL):
            srcLine = tempImg.data + ySrcStride - xSrcStride;
            xSrcStride = -xSrcStride;
    	    break;
    	case(VERTICAL):
            srcLine = tempImg.data + ySrcStride * image.ysize - ySrcStride;
            ySrcStride = -ySrcStride;
    	    break;
    	case(BOTH):
            srcLine = tempImg.data + ySrcStride * image.ysize - xSrcStride;
            xSrcStride = -xSrcStride;
            ySrcStride = -ySrcStride;
    	    break;
    	default:
            return;
    	    // break;
    }
    int ySize = image.ysize;
    int xHold = image.xsize;

    while(ySize--)
    {
      unsigned char *srcPixels = srcLine;
      unsigned char *dstPixels = dstLine;
      int xSize = xHold;
      while(xSize--)        {
	dstPixels[chRed] = srcPixels[chRed];
	dstPixels[chGreen] = srcPixels[chGreen];
	dstPixels[chBlue] = srcPixels[chBlue];
	dstPixels[chAlpha] = srcPixels[chAlpha];
	dstPixels += xDstStride;
	srcPixels += xSrcStride;
      }
      dstLine += yDstStride;
      srcLine += ySrcStride;
    }
}

/////////////////////////////////////////////////////////
// really open the file ! (OS dependent)
//
/////////////////////////////////////////////////////////
bool imageTIFF :: load(std::string filename, imageStruct&result, gem::Properties&props)
{
  ::logpost(NULL, 6, "reading '%s' with libTIFF", filename.c_str());
  TIFF *tif = TIFFOpen(filename.c_str(), "r");
  if (tif == NULL) {
      return(NULL);
    }

  uint32 width, height;
  short bits, samps;
  TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &width);
  TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &height);
  TIFFGetField(tif, TIFFTAG_BITSPERSAMPLE, &bits);
  TIFFGetField(tif, TIFFTAG_SAMPLESPERPIXEL, &samps);
    
  int npixels = width * height;

  result.xsize=width;
  result.ysize=height;
  result.upsidedown=true;
  result.type=GL_UNSIGNED_BYTE; //?

  bool knownFormat = false;
  // Is it a gray8 image?
  if (bits == 8 && samps == 1)
    {
      result.setCsizeByFormat(GL_LUMINANCE);
      knownFormat = true;
    }
  // Is it an RGB image?
  else if (bits == 8 && samps == 3)
    {
      result.setCsizeByFormat(GL_RGBA);
      knownFormat = true;
    }
  // Is it an RGBA image?
  else if (bits == 8 && samps == 4)
    {
      result.setCsizeByFormat(GL_RGBA);
      knownFormat = true;
    }

  // can we handle the raw data?
  if (knownFormat) {
    unsigned char *buf = new unsigned char [TIFFScanlineSize(tif)];
    if (buf == NULL) {
      error("GemImageLoad(TIFF): can't allocate memory for scanline buffer: %s", filename.c_str());
      TIFFClose(tif);
      return(false);
    }
    
    result.reallocate();
    unsigned char *dstLine = result.data;
    int yStride = result.xsize * result.csize;
    for (uint32 row = 0; row < height; row++)
      {
	unsigned char *pixels = dstLine;
	if (TIFFReadScanline(tif, buf, row, 0) < 0) {
	  error("GemImageLoad(TIFF): bad image data read on line: %d: %s", row, filename.c_str());
	  TIFFClose(tif);
	  return false;
	}
	unsigned char *inp = buf;
	if (samps == 1) {
	  for (uint32 i = 0; i < width; i++) {
	    *pixels++ = *inp++;         // Gray8
	  }
	}
	else if (samps == 3)  {
	  for (uint32 i = 0; i < width; i++) {   
	    pixels[chRed]   = inp[0];   // Red
	    pixels[chGreen] = inp[1];   // Green
	    pixels[chBlue]  = inp[2];   // Blue
	    pixels[chAlpha] = 255;      // Alpha
	    pixels += 4;
	    inp += 3;
	  }
	} else {
	  for (uint32 i = 0; i < width; i++) {               
	    pixels[chRed]   = inp[0];   // Red
	    pixels[chGreen] = inp[1];   // Green
	    pixels[chBlue]  = inp[2];   // Blue
	    pixels[chAlpha] = inp[3];   // Alpha
	    pixels += 4;
	    inp += 4;
	  }
	}
	dstLine += yStride;
      }
    delete [] buf;
  }
  // nope, so use the automatic conversion
  else {
    char emsg[1024];
    TIFFRGBAImage img;
    if (TIFFRGBAImageBegin(&img, tif, 0, emsg) == 0) {
//.........这里部分代码省略.........

  bool convertTo(imageStruct&img) {
    img.convertFrom(&image);
	return true;
  }

static bool QuickTimeImage2mem(GraphicsImportComponent inImporter,
                               imageStruct&result)
{
  Rect      r;
  if (::GraphicsImportGetNaturalBounds(inImporter, &r)) {
    return NULL;  //get an image size
  }
  ::OffsetRect(&r, -r.left, -r.top);
  if (::GraphicsImportSetBoundsRect(inImporter, &r)) {
    return NULL;
  }
  ImageDescriptionHandle imageDescH = NULL;
  if (::GraphicsImportGetImageDescription(inImporter, &imageDescH)) {
    return NULL;
  }

  result.xsize   = (*imageDescH)->width;
  result.ysize   = (*imageDescH)->height;
  result.upsidedown = true;

  OSType pixelformat = 0;

  /* afaik, there is no 8bit grayscale format....
   * and even if it was, k8GrayPixelFormat would not be a define...
   */
#ifdef k8GrayPixelFormat
  /* from the docs on "depth": what depth is this data (1-32) or ( 33-40 grayscale ) */
  if ((*imageDescH)->depth <= 32) {
    result.setCsizeByFormat(GL_RGBA_GEM);
    pixelformat = IMAGEQT_RGBA_PIXELFORMAT;
  } else {
    result.setCsizeByFormat(GL_LUMINANCE);
    pixelformat = k8GrayPixelFormat;
  }
#else
  result.setCsizeByFormat(GL_RGBA_GEM);
  pixelformat = IMAGEQT_RGBA_PIXELFORMAT;
#endif

  ::DisposeHandle(reinterpret_cast<Handle>(imageDescH));
  imageDescH = NULL;
  result.reallocate();

  verbose(1, "[GEM:imageQT] QuickTimeImage2mem() allocate %d bytes",
          result.xsize*result.ysize*result.csize);
  if (result.data == NULL) {
    verbose(0, "[GEM:imageQT] Can't allocate memory for an image.");
    return false;
  }

  GWorldPtr   gw = NULL;

  OSErr err = QTNewGWorldFromPtr(&gw,
                                 /* taken from pix_filmDarwin */
                                 pixelformat,   // gives noErr
                                 &r, NULL, NULL, 0,
                                 // keepLocal,
                                 //useDistantHdwrMem,
                                 result.data,
                                 static_cast<long>(result.xsize * result.csize));
  if (err) {
    verbose(0, "[GEM:imageQT] Can't create QTNewWorld");
  }

  ::GraphicsImportSetGWorld(inImporter, gw, NULL);
  ::GraphicsImportDraw(inImporter);
  ::DisposeGWorld(gw);         //dispose the offscreen
  gw = NULL;

  return true;
}

/////////////////////////////////////////////////////////
// processImage
//
/////////////////////////////////////////////////////////
void pix_freeframe :: processImage(imageStruct &image)
{
  unsigned int format=m_image.format;
  unsigned char*data=image.data;

  if(m_plugin==NULL)return;

  // convert the current image into a format that suits the FreeFrame-plugin
  if(image.format!=format){
    switch (image.format){
    case GL_RGBA:
      m_image.fromRGBA(image.data);
      break;
    case GL_BGRA_EXT: /* "RGBA" on apple */
      m_image.fromBGRA(image.data);
      break;
    case GL_LUMINANCE: // greyscale
      m_image.fromGray(image.data);
      break;
    case GL_YUV422_GEM: // YUV
      m_image.fromYUV422(image.data);
      break;
    }
    m_plugin->processFrame(m_image);
    data=m_image.data;
  } else {
    m_plugin->processFrame(image);
    data=image.data;
  }

  // check whether we have converted our image data
  if(image.data!=data)
    // it seems, like we did: convert it back

  // just copied the code from [pix_rgba]
    switch(format) {
    case GL_RGBA:
      image.fromRGBA(m_image.data);
      break;
    case GL_RGB:
      image.fromRGB(m_image.data);
      break;
    case GL_BGR_EXT:
      image.fromBGR(m_image.data);
      break;
    case GL_BGRA_EXT: /* "RGBA" on apple */
      image.fromBGRA(m_image.data);
      break;
    case GL_LUMINANCE:
      image.fromGray(m_image.data);
      break;
    case GL_YCBCR_422_GEM: // YUV
      image.fromUYVY(m_image.data);
      break;
    default:
      error("no method for this format !!!");
      error("if you know how to convert this format (%X),\n"
            "please contact the authors of this software", image.format);
      return;
    }
}

bool imageTIFF::save(const imageStruct&constimage, const std::string&filename, const std::string&mimetype, const gem::Properties&props) {
  TIFF *tif = NULL;

  if(GL_YUV422_GEM==constimage.format) {
    error("don't know how to write YUV-images with libTIFF");
    return false;
  }

  tif=TIFFOpen(filename.c_str(), "w");
  if (tif == NULL) {
    return false;
  }
  imageStruct image; constimage.copy2Image(&image);
  image.fixUpDown();

  uint32 width=image.xsize, height = image.ysize;
  short bits=8, samps=image.csize;
  int npixels = width * height;
  //int planar_conf = PLANARCONFIG_CONTIG;
  std::string software = "PD/GEM";
  std::string artist;
  std::string hostcomputer;

  double xresolution = 72., yresolution=72.;
  short resunit = RESUNIT_INCH;

  props.get("xresolution", xresolution);
  props.get("yresolution", yresolution);
  std::string resunit_s;
  if(props.get("resolutionunit", resunit_s)) {
    if(("inch"==resunit_s) || ("english"==resunit_s) || ("imperial"==resunit_s))
      resunit=RESUNIT_INCH;
    else if(("centimeter"==resunit_s) || ("metric"==resunit_s))
      resunit=RESUNIT_CENTIMETER;
    else
      resunit=RESUNIT_NONE;
  }
  props.get("software", software);
  props.get("artist", artist);
  props.get("hostcomputer", hostcomputer);


  TIFFSetField(tif, TIFFTAG_IMAGEWIDTH, width);
  TIFFSetField(tif, TIFFTAG_IMAGELENGTH, height);
  TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, bits);
  TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, samps);
  TIFFSetField(tif, TIFFTAG_PLANARCONFIG, 1);
  TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB);

  TIFFSetField(tif, TIFFTAG_XRESOLUTION, xresolution); // RATIONAL
  TIFFSetField(tif, TIFFTAG_YRESOLUTION, yresolution); // RATIONAL
  TIFFSetField(tif, TIFFTAG_RESOLUTIONUNIT, resunit);

  if(!software.empty())
    TIFFSetField(tif, TIFFTAG_SOFTWARE, software.c_str());
  if(!artist.empty())
    TIFFSetField(tif, TIFFTAG_ARTIST, artist.c_str());
  if(!hostcomputer.empty())
    TIFFSetField(tif, TIFFTAG_HOSTCOMPUTER, hostcomputer.c_str());

  int yStride = image.xsize * image.csize;
  unsigned char *srcLine = &(image.data[npixels * image.csize]);
  srcLine -= yStride;

  for (uint32 row = 0; row < height; row++) {
    unsigned char *buf = srcLine;
    if (TIFFWriteScanline(tif, buf, row, 0) < 0)
      {
        error("GEM: could not write line %d to image %s", row, filename.c_str());
        TIFFClose(tif);
        delete [] buf;
        return(false);
      }
    srcLine -= yStride;
  }
  TIFFClose(tif);

  return true;
}