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
}
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;
}
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;
}
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;
}
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;
}
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;
}
