コード例 #1
0
  typename RGBPixelPtrType> void SDLSurface::renderImageToSurface(
    SDLSurface::ImageViewType& imageView) {
  RGBPixelPtrType pFirstPixelSurface(
      reinterpret_cast<RGBPixelPtrType>(m_pSurface->pixels));
  RGBImageViewType imageViewSurface(boost::gil::interleaved_view(
      sizePixels().width(),
      sizePixels().height(),
      pFirstPixelSurface,
      sizeRowBytes()));
  boost::gil::copy_pixels(imageView, imageViewSurface);
#ifdef DEBUG
  bool imageViewSurfaceHasData = imageHasData(imageViewSurface);
  std::cout << "image view surface " << (imageViewSurfaceHasData ? "" : "not ");
  std::cout << "has data" << std::endl;
  std::cout << "surface " << (hasData() ? "" : "not ") << "has data";
  std::cout << std::endl;
#endif
}
      typename RGBPixelPtrType> static void copyBufferIntoSample(
          ByteBuffer buffer,
          SampleRef sample) {
#ifdef DEBUG
    std::cout << "copyBufferIntoSample" << std::endl;
    std::cout << "buffer " << (buffer.hasData() ? "" : "not ") << "has data";
    std::cout << std::endl;
#endif
      if (!sample) {
        return;
      }
      RGBVideoFormat videoFormat(sample.sampleFormat());
      std::size_t sizeBytes = videoFormat.sizeBytes();
      if (sizeBytes != buffer.sizeBytes()) {
        return;
      }
      IntegerSize sizePixels(videoFormat.sizePixels());
      if (sizePixels.width() <= 0) {
        return;
      }
      if (sizePixels.height() <= 0) {
        return;
      }
      std::size_t sizeRowBytes = videoFormat.sizeRowBytes();
      if (!sizeRowBytes) {
        return;
      }
      RGBPixelPtrType pFirstPixel = reinterpret_cast<RGBPixelPtrType>(
          buffer.firstBufferByte());
      RGBImageViewType imageViewBuffer = boost::gil::interleaved_view(
          sizePixels.width(),
          sizePixels.height(),
          pFirstPixel,
          sizeRowBytes);
#ifdef DEBUG
    std::cout << "created imageViewBuffer" << std::endl;
    bool hasData = imageHasData(imageViewBuffer);
    std::cout << "imageViewBuffer " << (hasData ? "" : "not ") << "has data";
    std::cout << std::endl;
#endif
      SampleDataSharedPtr pSampleData(sample.sampleData());
#ifdef DEBUG
      std::cout << "pSampleData " << pSampleData.get() << std::endl;
#endif
      RGBVideoFrame::ImageViewType imageViewSample(pSampleData->imageView());
#ifdef DEBUG
      std::cout << "created imageViewSample" << std::endl;
#endif
      boost::gil::copy_pixels(imageViewBuffer, imageViewSample);
#ifdef DEBUG
      std::cout << "Assigned image view buffer to sample" << std::endl;
#endif
    }
コード例 #3
0
bool SDLSurface::renderToSurface(RGBVideoSample& videoSample) {
  if (!videoSample) {
    return false;
  }
  if (!isInitialized()) {
    return false;
  }
#ifdef DEBUG
  std::cout << "SDLSurface::renderToSurface" << std::endl;
#endif
  SDLSurfaceLock surfaceLock(m_pSurface);
  if (!surfaceLock) {
    return false;
  }
  RGBVideoFormat videoFormat(videoSample.sampleFormat());
  if (videoFormat.sizePixels() != sizePixels()) {
    return false;
  }
  if (videoFormat.bitsPerPixel() != bitsPerPixel()) {
    return false;
  }
  if (videoFormat.sizeRowBytes() != sizeRowBytes()) {
    return false;
  }
  if (videoFormat.sizeBytes() != sizeBytes()) {
    return false;
  }
  if (videoFormat.rgbFormat() != rgbFormat()) {
    return false;
  }
  RGBVideoFrameSharedPtr pVideoFrame(videoSample.sampleData());
  ImageViewType imageView(pVideoFrame->imageView());
  switch (rgbFormat()) {
    case RGB888:
      renderImageToSurface<rgb8_view_t, rgb8_ptr_t>(imageView);
      break;
    case RGBA8888:
      renderImageToSurface<rgba8_view_t, rgba8_ptr_t>(imageView);
      break;
    case BGR888:
      renderImageToSurface<bgr8_view_t, bgr8_ptr_t>(imageView);
      break;
    case ABGR8888:
      renderImageToSurface<abgr8_view_t, abgr8_ptr_t>(imageView);
      break;
    default:
      return false;
  }
  return true;
}
コード例 #4
0
bool SDLSurface::isInitialized() const {
  if (!m_pSurface) {
    return false;
  }
  if (!isValidRGBFormat(rgbFormat())) {
    return false;
  }
  IntegerSize sizePixelsSurface(sizePixels());
  if (!sizePixelsSurface.width()) {
    return false;
  }
  if (!sizePixelsSurface.height()) {
    return false;
  }
  return true;
}
コード例 #5
0
bool SDLRenderer::initialize(const RGBVideoFormat& videoFormat) {
  if (!videoFormat) {
    return false;
  }
  IntegerSize sizePixels(videoFormat.sizePixels());
  SizeType width = sizePixels.width();
  if (!width) {
    return false;
  }
  SizeType height = sizePixels.height();
  if (!height) {
    return false;
  }
  SizeType bitsPerPixel = videoFormat.bitsPerPixel();
  if (!bitsPerPixel) {
    return false;
  }
  Uint32 flags = SDL_SWSURFACE;
  int bitsPerPixelScreen = SDL_VideoModeOK(width, height, bitsPerPixel, flags);
  if (bitsPerPixelScreen != bitsPerPixel) {
    return false;
  }
  SDLSurfaceSharedPtr pScreenSurface(
      new SDLSurface(SDL_SetVideoMode(width, height, bitsPerPixel, flags)));
  if (!pScreenSurface) {
    return false;
  }
  m_pScreenSurface = pScreenSurface;
  SDLSurfaceSharedPtr pBackBufferSurface(
      SDLSurface::createRGBSurfaceSharedPtr(videoFormat));
  if (!pBackBufferSurface) {
    return false;
  }
  m_pBackBufferSurface = pBackBufferSurface;
  return true;
}
コード例 #6
0
SDLSurface::SDLSurfaceSharedPtr SDLSurface::createRGBSurfaceSharedPtr(
    const RGBVideoFormat& videoFormat) {
  if (!videoFormat) {
    SDLSurfaceSharedPtr pSurface;
    return pSurface;
  }
  Uint32 flags = SDL_SWSURFACE;
  IntegerSize sizePixels(videoFormat.sizePixels());
  SizeType width = sizePixels.width();
  if (!width) {
    SDLSurfaceSharedPtr pSurface;
    return pSurface;
  }
  SizeType height = sizePixels.height();
  if (!height) {
    SDLSurfaceSharedPtr pSurface;
    return pSurface;
  }
  SizeType depth = videoFormat.bitsPerPixel();
  RGBFormat rgbFormat = videoFormat.rgbFormat();
  Uint32 rMask = 0;
  Uint32 gMask = 0;
  Uint32 bMask = 0;
  Uint32 aMask = 0;
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
  switch (rgbFormat) {
    case RGB888:
      rMask = 0xff000000;
      gMask = 0x00ff0000;
      bMask = 0x0000ff00;
      break;
    case BGR888:
      rMask = 0x0000ff00;
      gMask = 0x00ff0000;
      bMask = 0xff000000;
      break;
    case RGBA8888:
      rMask = 0xff000000;
      gMask = 0x00ff0000;
      bMask = 0x0000ff00;
      aMask = 0x000000ff;
      break;
    case ABGR8888:
      rMask = 0x000000ff;
      gMask = 0x0000ff00;
      bMask = 0x00ff0000;
      aMask = 0xff000000;
      break;
  }
#else
  switch (rgbFormat) {
    case RGB888:
      rMask = 0x000000ff;
      gMask = 0x0000ff00;
      bMask = 0x00ff0000;
      break;
    case BGR888:
      rMask = 0x00ff0000;
      gMask = 0x0000ff00;
      bMask = 0x000000ff;
      break;
    case RGBA8888:
      rMask = 0x000000ff;
      gMask = 0x0000ff00;
      bMask = 0x00ff0000;
      aMask = 0xff000000;
      break;
    case ABGR8888:
      rMask = 0xff000000;
      gMask = 0x00ff0000;
      bMask = 0x0000ff00;
      aMask = 0x000000ff;
      break;
  }
#endif
  if (!rMask && !gMask && !bMask) {
    SDLSurfaceSharedPtr pSurface;
    return pSurface;
  }
  SDLSurfaceSharedPtr pSurface(
      new SDLSurface(SDL_CreateRGBSurface(
          flags,
          width,
          height,
          depth,
          rMask,
          gMask,
          bMask,
          aMask)));
  return pSurface;
}
コード例 #7
0
const QImage ImageLoaderFreeImage::imageAsRGB(const QSize &size) const
{
    const QSize resultSize = size.isValid() ? size : sizePixels();
    const bool isRGB24 = colorDataType() == Types::ColorTypeRGB && bitsPerPixel() == 24;
    const bool isARGB32 = colorDataType() == Types::ColorTypeRGBA && bitsPerPixel() == 32;
    QImage result(resultSize, isARGB32 ? QImage::Format_ARGB32 : QImage::Format_RGB32);

    const int width = resultSize.width();
    const int height = resultSize.height();
    const QSize sizePixels = this->sizePixels();

    FIBITMAP* originalImage = m_bitmap;
    FIBITMAP* temp24BPPImage = NULL;
    FIBITMAP* scaledImage = NULL;

    if (!(isRGB24 || isARGB32)) {
        if (colorDataType() == Types::ColorTypeCMYK) {
            const bool isCmykJpeg = isJpeg(); // Value range inverted
            temp24BPPImage = FreeImage_Allocate(sizePixels.width(), sizePixels.height(), 24);
            const unsigned int columnsCount = sizePixels.width();
            const unsigned int scanlinesCount = sizePixels.height();
            for (unsigned int scanline = 0; scanline < scanlinesCount; scanline++) {
                const BYTE* const cmykBits = FreeImage_GetScanLine(m_bitmap, scanline);
                tagRGBTRIPLE* const rgbBits = (tagRGBTRIPLE *)FreeImage_GetScanLine(temp24BPPImage, scanline);

                for (unsigned int column = 0; column < columnsCount; column++) {
                    const unsigned int cmykColumn = column * 4;

                    const QColor rgbColor = isCmykJpeg ?
                        QColor::fromCmyk(255 - cmykBits[cmykColumn], 255 - cmykBits[cmykColumn + 1], 255 - cmykBits[cmykColumn + 2], 255 - cmykBits[cmykColumn + 3])
                        : QColor::fromCmyk(cmykBits[cmykColumn], cmykBits[cmykColumn + 1], cmykBits[cmykColumn + 2], cmykBits[cmykColumn + 3]);

                    rgbBits[column].rgbtRed = (BYTE)rgbColor.red();
                    rgbBits[column].rgbtGreen = (BYTE)rgbColor.green();
                    rgbBits[column].rgbtBlue = (BYTE)rgbColor.blue();
                }
            }
        } else {
            temp24BPPImage = FreeImage_ConvertTo24Bits(originalImage);
        }
        originalImage = temp24BPPImage;
    }

    if (resultSize != sizePixels) {
        scaledImage = FreeImage_Rescale(originalImage, width, height, FILTER_BOX);
        originalImage = scaledImage;
    }

    for (int scanline = 0; scanline < height; scanline++) {
        QRgb *targetData = (QRgb*)result.scanLine(scanline);
        if (isARGB32) {
            const tagRGBQUAD *sourceRgba = (tagRGBQUAD*)FreeImage_GetScanLine(originalImage, height - scanline - 1);
            for (int column = 0; column < width; column++) {
                *targetData++ = qRgba(sourceRgba->rgbRed, sourceRgba->rgbGreen, sourceRgba->rgbBlue, sourceRgba->rgbReserved);
                sourceRgba++;
            }
        } else {
            const tagRGBTRIPLE *sourceRgb = (tagRGBTRIPLE*)FreeImage_GetScanLine(originalImage, height - scanline - 1);
            for (int column = 0; column < width; column++) {
                *targetData++ = qRgb(sourceRgb->rgbtRed, sourceRgb->rgbtGreen, sourceRgb->rgbtBlue);
                sourceRgb++;
            }
        }
    }

    if (temp24BPPImage)
        FreeImage_Unload(temp24BPPImage);

    if (scaledImage)
        FreeImage_Unload(scaledImage);

    return result;
}