526 lines
19 KiB
C++
526 lines
19 KiB
C++
|
#include "ImageWriter.h"
|
||
|
|
|
||
|
|
#include <QLibrary>
|
||
|
|
#include <QString>
|
||
|
|
#include <QSharedPointer>
|
||
|
|
#include <QDebug>
|
||
|
|
#include <stdint.h>
|
||
|
|
#include "VmbTransform.h"
|
||
|
|
#include <QMutex>
|
||
|
|
#include <QMutexLocker>
|
||
|
|
typedef struct tiff TIFF;
|
||
|
|
|
||
|
|
// constants for configuring Tiff tag data
|
||
|
|
#define IMGWRITER_IMAGEWIDTH 256 /* image width in pixels (TIFFTAG_IMAGEWIDTH) */
|
||
|
|
#define IMGWRITER_IMAGELENGTH 257 /* image height in pixels (TIFFTAG_IMAGELENGTH) */
|
||
|
|
#define IMGWRITER_BITSPERSAMPLE 258 /* bits per channel (sample) (TIFFTAG_BITSPERSAMPLE) */
|
||
|
|
#define IMGWRITER_COMPRESSION 259 /* data compression technique (TIFFTAG_COMPRESSION) */
|
||
|
|
#define IMGWRITER_PHOTOMETRIC 262 /* photometric interpretation (TIFFTAG_PHOTOMETRIC) */
|
||
|
|
#define IMGWRITER_XRESOLUTION 282 /* pixels/resolution in x (TIFFTAG_XRESOLUTION) */
|
||
|
|
#define IMGWRITER_YRESOLUTION 283 /* pixels/resolution in y (TIFFTAG_YRESOLUTION) */
|
||
|
|
#define IMGWRITER_RESOLUTIONUNIT 296 /* units of resolutions (TIFFTAG_RESOLUTIONUNIT) */
|
||
|
|
#define IMGWRITER_PLANARCONFIG 284 /* storage organization (TIFFTAG_PLANARCONFIG) */
|
||
|
|
#define IMGWRITER_SAMPLESPERPIXEL 277 /* samples per pixel (TIFFTAG_SAMPLESPERPIXEL) */
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
class TiffLibrary
|
||
|
|
{
|
||
|
|
bool m_DidLoad;
|
||
|
|
QLibrary m_LibTiffLibrary;
|
||
|
|
static QMutex m_LibraryLock;
|
||
|
|
|
||
|
|
// function pointer typedefs
|
||
|
|
typedef TIFF* (*TIFFOpenPrototype)( const char*, const char* );
|
||
|
|
typedef void (*TIFFClosePrototype)( TIFF* );
|
||
|
|
typedef int (*TIFFSetFieldProtoype)( TIFF*, uint32_t, ... );
|
||
|
|
typedef int (*TIFFWriteScanlinePrototype)( TIFF*, void*, uint32_t, uint16_t );
|
||
|
|
|
||
|
|
TiffLibrary()
|
||
|
|
{
|
||
|
|
m_LibTiffLibrary.setFileNameAndVersion("libtiff", 5);
|
||
|
|
m_DidLoad = m_LibTiffLibrary.load();
|
||
|
|
|
||
|
|
if (!m_DidLoad )
|
||
|
|
{
|
||
|
|
m_LibTiffLibrary.setFileNameAndVersion("libtiff", 4);
|
||
|
|
m_DidLoad = m_LibTiffLibrary.load();
|
||
|
|
}
|
||
|
|
if( m_DidLoad )
|
||
|
|
{
|
||
|
|
TiffOpen = (TIFFOpenPrototype) m_LibTiffLibrary.resolve("TIFFOpen");
|
||
|
|
if( TiffOpen == NULL)
|
||
|
|
{
|
||
|
|
m_DidLoad = false;
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
TiffClose = (TIFFClosePrototype) m_LibTiffLibrary.resolve("TIFFClose");
|
||
|
|
if( TiffClose == NULL)
|
||
|
|
{
|
||
|
|
m_DidLoad = false;
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
TiffSetField = (TIFFSetFieldProtoype) m_LibTiffLibrary.resolve("TIFFSetField");
|
||
|
|
if( TiffSetField == NULL)
|
||
|
|
{
|
||
|
|
m_DidLoad = false;
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
TiffWriteScanLine = (TIFFWriteScanlinePrototype) m_LibTiffLibrary.resolve("TIFFWriteScanline");
|
||
|
|
if( TiffWriteScanLine == NULL)
|
||
|
|
{
|
||
|
|
m_DidLoad = false;
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
public:
|
||
|
|
static const TiffLibrary& Get()
|
||
|
|
{
|
||
|
|
QMutexLocker local_lock( &m_LibraryLock );
|
||
|
|
static const TiffLibrary staticLibrary;
|
||
|
|
return staticLibrary;
|
||
|
|
}
|
||
|
|
bool Valid() const { return m_DidLoad; }
|
||
|
|
QString GetLastError( void ) const
|
||
|
|
{
|
||
|
|
return m_LibTiffLibrary.errorString();
|
||
|
|
}
|
||
|
|
|
||
|
|
TIFFOpenPrototype TiffOpen;
|
||
|
|
TIFFClosePrototype TiffClose;
|
||
|
|
TIFFSetFieldProtoype TiffSetField;
|
||
|
|
TIFFWriteScanlinePrototype TiffWriteScanLine;
|
||
|
|
};
|
||
|
|
// static init
|
||
|
|
QMutex TiffLibrary::m_LibraryLock;
|
||
|
|
|
||
|
|
VmbError_t GetBitsPerPixelUsed( VmbUint32_t * BitsPerPixelUsed, VmbPixelFormat_t PixelFormat)
|
||
|
|
{
|
||
|
|
if( BitsPerPixelUsed == 0 ) return VmbErrorBadParameter;
|
||
|
|
switch(PixelFormat)
|
||
|
|
{
|
||
|
|
case VmbPixelFormatBayerGR8:
|
||
|
|
case VmbPixelFormatBayerRG8:
|
||
|
|
case VmbPixelFormatBayerGB8:
|
||
|
|
case VmbPixelFormatBayerBG8:
|
||
|
|
case VmbPixelFormatMono8:
|
||
|
|
*BitsPerPixelUsed = 8;
|
||
|
|
return VmbErrorSuccess;
|
||
|
|
case VmbPixelFormatBayerGR10:
|
||
|
|
case VmbPixelFormatBayerRG10:
|
||
|
|
case VmbPixelFormatBayerGB10:
|
||
|
|
case VmbPixelFormatBayerBG10:
|
||
|
|
case VmbPixelFormatBayerGR10p:
|
||
|
|
case VmbPixelFormatBayerRG10p:
|
||
|
|
case VmbPixelFormatBayerGB10p:
|
||
|
|
case VmbPixelFormatBayerBG10p:
|
||
|
|
case VmbPixelFormatMono10:
|
||
|
|
case VmbPixelFormatMono10p:
|
||
|
|
*BitsPerPixelUsed = 10;
|
||
|
|
return VmbErrorSuccess;
|
||
|
|
case VmbPixelFormatBayerGR12:
|
||
|
|
case VmbPixelFormatBayerRG12:
|
||
|
|
case VmbPixelFormatBayerGB12:
|
||
|
|
case VmbPixelFormatBayerBG12:
|
||
|
|
case VmbPixelFormatMono12:
|
||
|
|
case VmbPixelFormatMono12Packed:
|
||
|
|
case VmbPixelFormatMono12p:
|
||
|
|
case VmbPixelFormatBayerGR12Packed:
|
||
|
|
case VmbPixelFormatBayerRG12Packed:
|
||
|
|
case VmbPixelFormatBayerGB12Packed:
|
||
|
|
case VmbPixelFormatBayerBG12Packed:
|
||
|
|
case VmbPixelFormatBayerGR12p:
|
||
|
|
case VmbPixelFormatBayerRG12p:
|
||
|
|
case VmbPixelFormatBayerGB12p:
|
||
|
|
case VmbPixelFormatBayerBG12p:
|
||
|
|
*BitsPerPixelUsed = 12;
|
||
|
|
return VmbErrorSuccess;
|
||
|
|
case VmbPixelFormatMono14:
|
||
|
|
*BitsPerPixelUsed = 14;
|
||
|
|
return VmbErrorSuccess;
|
||
|
|
case VmbPixelFormatBayerGR16:
|
||
|
|
case VmbPixelFormatBayerRG16:
|
||
|
|
case VmbPixelFormatBayerGB16:
|
||
|
|
case VmbPixelFormatBayerBG16:
|
||
|
|
case VmbPixelFormatMono16:
|
||
|
|
*BitsPerPixelUsed = 16;
|
||
|
|
return VmbErrorSuccess;
|
||
|
|
case VmbPixelFormatRgb8:
|
||
|
|
case VmbPixelFormatBgr8:
|
||
|
|
*BitsPerPixelUsed = 24;
|
||
|
|
return VmbErrorSuccess;
|
||
|
|
case VmbPixelFormatArgb8:
|
||
|
|
case VmbPixelFormatBgra8:
|
||
|
|
*BitsPerPixelUsed = 32;
|
||
|
|
return VmbErrorSuccess;
|
||
|
|
case VmbPixelFormatRgb10:
|
||
|
|
case VmbPixelFormatBgr10:
|
||
|
|
*BitsPerPixelUsed = 30;
|
||
|
|
return VmbErrorSuccess;
|
||
|
|
case VmbPixelFormatRgb12:
|
||
|
|
case VmbPixelFormatBgr12:
|
||
|
|
*BitsPerPixelUsed = 36;
|
||
|
|
return VmbErrorSuccess;
|
||
|
|
case VmbPixelFormatRgb14:
|
||
|
|
case VmbPixelFormatBgr14:
|
||
|
|
*BitsPerPixelUsed = 42;
|
||
|
|
return VmbErrorSuccess;
|
||
|
|
case VmbPixelFormatRgb16:
|
||
|
|
case VmbPixelFormatBgr16:
|
||
|
|
*BitsPerPixelUsed = 48;
|
||
|
|
return VmbErrorSuccess;
|
||
|
|
case VmbPixelFormatRgba10:
|
||
|
|
case VmbPixelFormatBgra10:
|
||
|
|
*BitsPerPixelUsed = 40;
|
||
|
|
return VmbErrorSuccess;
|
||
|
|
case VmbPixelFormatRgba12:
|
||
|
|
case VmbPixelFormatBgra12:
|
||
|
|
*BitsPerPixelUsed = 48;
|
||
|
|
return VmbErrorSuccess;
|
||
|
|
case VmbPixelFormatRgba14:
|
||
|
|
case VmbPixelFormatBgra14:
|
||
|
|
*BitsPerPixelUsed = 56;
|
||
|
|
return VmbErrorSuccess;
|
||
|
|
case VmbPixelFormatRgba16:
|
||
|
|
case VmbPixelFormatBgra16:
|
||
|
|
*BitsPerPixelUsed = 64;
|
||
|
|
return VmbErrorSuccess;
|
||
|
|
case VmbPixelFormatYuv411:
|
||
|
|
case VmbPixelFormatYCbCr411_8_CbYYCrYY:
|
||
|
|
*BitsPerPixelUsed = 12;
|
||
|
|
return VmbErrorSuccess;
|
||
|
|
case VmbPixelFormatYuv422:
|
||
|
|
case VmbPixelFormatYCbCr422_8_CbYCrY:
|
||
|
|
*BitsPerPixelUsed = 16;
|
||
|
|
return VmbErrorSuccess;
|
||
|
|
case VmbPixelFormatYuv444:
|
||
|
|
case VmbPixelFormatYCbCr8_CbYCr:
|
||
|
|
*BitsPerPixelUsed = 24;
|
||
|
|
return VmbErrorSuccess;
|
||
|
|
default:
|
||
|
|
return VmbErrorBadParameter;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// helper functions to test if pixel format is of type Mono
|
||
|
|
bool IsMonochrome( VmbPixelFormat_t format )
|
||
|
|
{
|
||
|
|
bool isMono;
|
||
|
|
|
||
|
|
switch(format)
|
||
|
|
{
|
||
|
|
case VmbPixelFormatMono8:
|
||
|
|
case VmbPixelFormatMono10:
|
||
|
|
case VmbPixelFormatMono10p:
|
||
|
|
case VmbPixelFormatMono12:
|
||
|
|
case VmbPixelFormatMono12Packed:
|
||
|
|
case VmbPixelFormatMono12p:
|
||
|
|
case VmbPixelFormatMono14:
|
||
|
|
case VmbPixelFormatMono16:
|
||
|
|
isMono = true;
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
isMono = false;
|
||
|
|
}
|
||
|
|
|
||
|
|
return isMono;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// helper functions to test if pixel format is packed
|
||
|
|
bool IsPackedFormat( VmbPixelFormat_t format )
|
||
|
|
{
|
||
|
|
bool isPacked;
|
||
|
|
|
||
|
|
switch(format)
|
||
|
|
{
|
||
|
|
case VmbPixelFormatMono10p:
|
||
|
|
case VmbPixelFormatMono12Packed:
|
||
|
|
case VmbPixelFormatMono12p:
|
||
|
|
case VmbPixelFormatBayerGR12Packed:
|
||
|
|
case VmbPixelFormatBayerRG12Packed:
|
||
|
|
case VmbPixelFormatBayerGB12Packed:
|
||
|
|
case VmbPixelFormatBayerBG12Packed:
|
||
|
|
case VmbPixelFormatBayerGR10p:
|
||
|
|
case VmbPixelFormatBayerRG10p:
|
||
|
|
case VmbPixelFormatBayerGB10p:
|
||
|
|
case VmbPixelFormatBayerBG10p:
|
||
|
|
case VmbPixelFormatBayerGR12p:
|
||
|
|
case VmbPixelFormatBayerRG12p:
|
||
|
|
case VmbPixelFormatBayerGB12p:
|
||
|
|
case VmbPixelFormatBayerBG12p:
|
||
|
|
isPacked = true;
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
isPacked = false;
|
||
|
|
}
|
||
|
|
|
||
|
|
return isPacked;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// Helper function to fill in the TIFF file parameters
|
||
|
|
bool WriteStandardTags( TIFF* TiffFile, const tFrameInfo &frame_info)
|
||
|
|
{
|
||
|
|
int result = 0;
|
||
|
|
VmbUint32_t BitsPerPixelUsed;
|
||
|
|
// calculate bit depth
|
||
|
|
GetBitsPerPixelUsed(&BitsPerPixelUsed, frame_info.PixelFormat() );
|
||
|
|
VmbUint16_t BitsPerSample = static_cast<VmbUint16_t>( ( BitsPerPixelUsed > 8 ) ? 16 : 8 );
|
||
|
|
|
||
|
|
// check if function symbol could be resolved (using QLibrary)
|
||
|
|
result = (*TiffLibrary::Get().TiffSetField)( TiffFile, IMGWRITER_IMAGEWIDTH, static_cast<unsigned long>(frame_info.Width() ));
|
||
|
|
if (result == 0)
|
||
|
|
return false;
|
||
|
|
result = (*TiffLibrary::Get().TiffSetField)( TiffFile, IMGWRITER_IMAGELENGTH, static_cast<unsigned long>(frame_info.Height() ));
|
||
|
|
if (result == 0)
|
||
|
|
return false;
|
||
|
|
result = (*TiffLibrary::Get().TiffSetField)( TiffFile, IMGWRITER_COMPRESSION, static_cast<unsigned short>(1) ); // No compression
|
||
|
|
if (result == 0)
|
||
|
|
return false;
|
||
|
|
result = (*TiffLibrary::Get().TiffSetField)( TiffFile, IMGWRITER_XRESOLUTION, static_cast<float>(1.0F));
|
||
|
|
if (result == 0)
|
||
|
|
return false;
|
||
|
|
result = (*TiffLibrary::Get().TiffSetField)( TiffFile, IMGWRITER_YRESOLUTION, static_cast<float>(1.0F));
|
||
|
|
if (result == 0)
|
||
|
|
return false;
|
||
|
|
result = (*TiffLibrary::Get().TiffSetField)( TiffFile, IMGWRITER_RESOLUTIONUNIT, static_cast<unsigned short>(1)); // No units
|
||
|
|
if (result == 0)
|
||
|
|
return false;
|
||
|
|
result = (*TiffLibrary::Get().TiffSetField)( TiffFile, IMGWRITER_PLANARCONFIG, static_cast<unsigned short>(1));
|
||
|
|
if (result == 0)
|
||
|
|
return false;
|
||
|
|
|
||
|
|
// raw image data, bayer or mono
|
||
|
|
if ( IsMonochrome( frame_info.PixelFormat() ) || ! frame_info.UseColorInterpolation() )
|
||
|
|
{
|
||
|
|
// Monochrome
|
||
|
|
result = (*TiffLibrary::Get().TiffSetField)( TiffFile, IMGWRITER_BITSPERSAMPLE, BitsPerSample );
|
||
|
|
if (result == 0)
|
||
|
|
return false;
|
||
|
|
result = (*TiffLibrary::Get().TiffSetField)( TiffFile, IMGWRITER_PHOTOMETRIC, static_cast<unsigned short>(1)); // Monochrome, black=0
|
||
|
|
if (result == 0)
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
else // bayer format && color interpolation on
|
||
|
|
{
|
||
|
|
// Color
|
||
|
|
result = (*TiffLibrary::Get().TiffSetField)( TiffFile, IMGWRITER_BITSPERSAMPLE, BitsPerSample, BitsPerSample, BitsPerSample );
|
||
|
|
if (result == 0)
|
||
|
|
return false;
|
||
|
|
result = (*TiffLibrary::Get().TiffSetField)( TiffFile, IMGWRITER_SAMPLESPERPIXEL, static_cast<unsigned short>(3));
|
||
|
|
if (result == 0)
|
||
|
|
return false;
|
||
|
|
result = (*TiffLibrary::Get().TiffSetField)( TiffFile, IMGWRITER_PHOTOMETRIC, static_cast<unsigned short>(2)); // RGB color
|
||
|
|
if (result == 0)
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Helper function to write the data buffer to the TIFF file
|
||
|
|
bool WriteFrameBuffer( TIFF* TiffFile, const tFrameInfo &frame_info )
|
||
|
|
{
|
||
|
|
const VmbUint32_t ImageSizePixels = frame_info.Width() * frame_info.Height();
|
||
|
|
VmbUint32_t BitsPerPixelUsed;
|
||
|
|
GetBitsPerPixelUsed(&BitsPerPixelUsed, frame_info.PixelFormat() );
|
||
|
|
VmbUint32_t BytesPerPixel = ( BitsPerPixelUsed > 8 ) ? 2 : 1;
|
||
|
|
|
||
|
|
// allocate the temporary buffer used to write to the file
|
||
|
|
try
|
||
|
|
{
|
||
|
|
QSharedPointer<unsigned char> tmpBuffer;
|
||
|
|
|
||
|
|
// copy or manipulate data into temporary buffer
|
||
|
|
if ( IsMonochrome(frame_info.PixelFormat() )
|
||
|
|
|| !frame_info.UseColorInterpolation()
|
||
|
|
) // raw mono or bayer (no color interpolation)
|
||
|
|
{
|
||
|
|
if( 8 == BitsPerPixelUsed ) // mono or raw 8 bit transfer
|
||
|
|
{
|
||
|
|
tmpBuffer = frame_info.DataPtr();
|
||
|
|
}
|
||
|
|
else // 16 bit tranfer formats
|
||
|
|
{
|
||
|
|
if( IsPackedFormat(frame_info.PixelFormat() ) ) // unpack mono_p raw_p
|
||
|
|
{
|
||
|
|
tmpBuffer = QSharedPointer<unsigned char> (new unsigned char [ImageSizePixels * 2], DeleteArray<unsigned char> ); // space for mono 16
|
||
|
|
if( tmpBuffer == NULL)
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
VmbImage sourceImage;
|
||
|
|
VmbImage destinationImage;
|
||
|
|
|
||
|
|
// set size member for verification inside API
|
||
|
|
sourceImage.Size = sizeof ( sourceImage );
|
||
|
|
destinationImage.Size = sizeof ( destinationImage );
|
||
|
|
|
||
|
|
// attach the data buffers
|
||
|
|
sourceImage.Data = (void*) frame_info.Data(); // hard cast from const
|
||
|
|
destinationImage.Data = tmpBuffer.data();
|
||
|
|
|
||
|
|
// fill image info from pixel format string
|
||
|
|
VmbSetImageInfoFromPixelFormat ( frame_info.PixelFormat(), frame_info.Width(), frame_info.Height(), &sourceImage );
|
||
|
|
|
||
|
|
// fill image info from pixel format
|
||
|
|
VmbSetImageInfoFromInputImage(&sourceImage, VmbPixelLayoutMono, 16, &destinationImage);
|
||
|
|
|
||
|
|
// perform the transformation
|
||
|
|
if ( VmbErrorSuccess != VmbImageTransform ( &sourceImage , &destinationImage , 0 , 0 ) )
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
tmpBuffer = frame_info.DataPtr();
|
||
|
|
}
|
||
|
|
// change to msb
|
||
|
|
unsigned short* pData = (unsigned short*)tmpBuffer.data();
|
||
|
|
const unsigned short* pDataEnd = pData + ImageSizePixels;
|
||
|
|
const unsigned short bitshift = 16 - BitsPerPixelUsed;
|
||
|
|
|
||
|
|
while (pData < pDataEnd)
|
||
|
|
{
|
||
|
|
*(pData) <<= bitshift;
|
||
|
|
++pData;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else // bayer && color interpolation on
|
||
|
|
{
|
||
|
|
if( BytesPerPixel == 1 ) // bayer8
|
||
|
|
{
|
||
|
|
tmpBuffer = QSharedPointer<unsigned char>( new unsigned char[ ImageSizePixels * 3], DeleteArray<unsigned char> ); // storage for RGB pixel
|
||
|
|
|
||
|
|
VmbImage sourceImage, destinationImage;
|
||
|
|
|
||
|
|
sourceImage.Size = sizeof( destinationImage );
|
||
|
|
sourceImage.Data = (void*)frame_info.Data();
|
||
|
|
VmbSetImageInfoFromPixelFormat( frame_info.PixelFormat(), frame_info.Width(), frame_info.Height(), &sourceImage );
|
||
|
|
|
||
|
|
destinationImage.Size = sizeof( destinationImage );
|
||
|
|
destinationImage.Data = tmpBuffer.data();
|
||
|
|
|
||
|
|
VmbSetImageInfoFromInputImage(&sourceImage, VmbPixelLayoutRGB, 8, &destinationImage);
|
||
|
|
|
||
|
|
if( VmbErrorSuccess != VmbImageTransform( &sourceImage, &destinationImage, NULL, 0) )
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
tmpBuffer = QSharedPointer<unsigned char>( new unsigned char[ ImageSizePixels * 3 * BytesPerPixel ], DeleteArray<unsigned char> ); // storage for RGB 16 bit
|
||
|
|
|
||
|
|
|
||
|
|
VmbImage sourceImage;
|
||
|
|
sourceImage.Size = sizeof( sourceImage );
|
||
|
|
sourceImage.Data = (void*)frame_info.Data();
|
||
|
|
VmbSetImageInfoFromPixelFormat( frame_info.PixelFormat(), frame_info.Width(), frame_info.Height(), &sourceImage );
|
||
|
|
|
||
|
|
VmbImage destinationImage;
|
||
|
|
destinationImage.Size = sizeof( destinationImage );
|
||
|
|
destinationImage.Data = tmpBuffer.data();
|
||
|
|
VmbSetImageInfoFromInputImage(&sourceImage, VmbPixelLayoutRGB, 16, &destinationImage);
|
||
|
|
|
||
|
|
if( VmbErrorSuccess != VmbImageTransform( &sourceImage, &destinationImage, NULL, 0) )
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
unsigned short* pDest = (unsigned short*)tmpBuffer.data();
|
||
|
|
const unsigned short* const pDestEnd = pDest + ImageSizePixels * 3;
|
||
|
|
const unsigned short bitshift = 16 - BitsPerPixelUsed;
|
||
|
|
while (pDest < pDestEnd)
|
||
|
|
{
|
||
|
|
*(pDest++) <<= bitshift;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Write data into TIFF file.
|
||
|
|
const VmbUint32_t ColorsPerPixel = ( IsMonochrome( frame_info.PixelFormat() ) || !frame_info.UseColorInterpolation() ) ? 1 : 3;
|
||
|
|
const VmbUint32_t LineSize = BytesPerPixel * frame_info.Width() * ColorsPerPixel; // in bytes
|
||
|
|
unsigned char* pScanLine = tmpBuffer.data();
|
||
|
|
for (unsigned long i = 0; i < frame_info.Height(); i++)
|
||
|
|
{
|
||
|
|
int result = (*TiffLibrary::Get().TiffWriteScanLine)( TiffFile, pScanLine, i, 0);
|
||
|
|
if (result == 0)
|
||
|
|
return false;
|
||
|
|
|
||
|
|
pScanLine += LineSize;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
catch (std::bad_alloc& badAlloc)
|
||
|
|
{
|
||
|
|
qDebug() << "bad_alloc caught: " << badAlloc.what() << '\n';
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
catch(...)
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Attempts to load the LibTiff library dynamically using Qt QLibrary
|
||
|
|
bool ImageWriter::IsAvailable( void )
|
||
|
|
{
|
||
|
|
return TiffLibrary::Get().Valid();
|
||
|
|
}
|
||
|
|
|
||
|
|
// Get the error message from the last QLibrary call
|
||
|
|
QString ImageWriter::GetLastError( void )
|
||
|
|
{
|
||
|
|
return TiffLibrary::Get().GetLastError();
|
||
|
|
}
|
||
|
|
|
||
|
|
// Write the frame to the specified file
|
||
|
|
bool ImageWriter::WriteTiff( const tFrameInfo & frame_info, const char* filename, ILogTarget *log)
|
||
|
|
{
|
||
|
|
bool result = true;
|
||
|
|
// Create a new TIFF file by constructing a Tiff object
|
||
|
|
TIFF *TiffFile = (*TiffLibrary::Get().TiffOpen)(filename, "w");
|
||
|
|
|
||
|
|
if( NULL != TiffFile )
|
||
|
|
{
|
||
|
|
// Set the TIFF tags
|
||
|
|
result = WriteStandardTags(TiffFile, frame_info );
|
||
|
|
|
||
|
|
if( true == result)
|
||
|
|
{
|
||
|
|
// Write the image data
|
||
|
|
result = WriteFrameBuffer(TiffFile, frame_info);
|
||
|
|
if( !result)
|
||
|
|
{
|
||
|
|
if( NULL != log)
|
||
|
|
{
|
||
|
|
log->Log("error could not write frame buffer");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if( NULL != log)
|
||
|
|
{
|
||
|
|
log->Log("error could not write TIFF standard flags");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
(*TiffLibrary::Get().TiffClose)(TiffFile);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if( NULL != log)
|
||
|
|
{
|
||
|
|
log->Log("error could not open tiff file for writing");
|
||
|
|
}
|
||
|
|
result = false;
|
||
|
|
}
|
||
|
|
return result;
|
||
|
|
}
|