static int
lbp320PrintPage(gx_device_printer *pDev, FILE *fp)
{
int i;
byte Buf[16];
long DataSize;
struct bounding Box;
BoundImage(pDev, &Box);
/* ----==== fix bounding box 4-byte align ====---- */
Box.Left &= ~1;
Box.Right |= 1;
/* ----==== JOB start ??? ====---- */
fprintf(fp, "\x1b%%-12345X@PJL CJLMODE\n@PJL JOB\n");
DataSize = CompressImage(pDev, &Box, fp, "\x1b[1;%d;%d;11;%d;.&r");
/* ----==== Set size ====---- */
sprintf(Buf, "000%ld", DataSize);
i = (DataSize+strlen(Buf)+1)&3;
/* ----==== escape to LIPS ====---- */
fprintf(fp, "\x80%s\x80\x80\x80\x80\x0c",Buf+i);
fprintf(fp, "\x1bP0J\x1b\\");
fprintf(fp, "\x1b%%-12345X@PJL CJLMODE\n@PJL EOJ\n\x1b%%-12345X");
return(0);
}
void CompressToDDS(SDL_Surface* image, unsigned int format, CDDSImage &out)
{
// Convert to ARGB
SDL_PixelFormat argbFormat;
memset(&argbFormat, 0, sizeof(SDL_PixelFormat));
argbFormat.BitsPerPixel = 32;
argbFormat.BytesPerPixel = 4;
#if SDL_BYTEORDER == SDL_LIL_ENDIAN
argbFormat.Amask = 0xff000000;
argbFormat.Ashift = 24;
argbFormat.Rmask = 0x00ff0000;
argbFormat.Rshift = 16;
argbFormat.Gmask = 0x0000ff00;
argbFormat.Gshift = 8;
argbFormat.Bmask = 0x000000ff;
argbFormat.Bshift = 0;
#else
argbFormat.Amask = 0x000000ff;
argbFormat.Ashift = 0;
argbFormat.Rmask = 0x0000ff00;
argbFormat.Rshift = 8;
argbFormat.Gmask = 0x00ff0000;
argbFormat.Gshift = 16;
argbFormat.Bmask = 0xff000000;
argbFormat.Bshift = 24;
#endif
SDL_Surface *argbImage = SDL_ConvertSurface(image, &argbFormat, 0);
double colorMSE, alphaMSE;
if (format == XB_FMT_DXT1)
CompressImage((squish::u8 *)argbImage->pixels, image->w, image->h, out.GetData(), squish::kDxt1, colorMSE, alphaMSE);
else if (format == XB_FMT_DXT5)
CompressImage((squish::u8 *)argbImage->pixels, image->w, image->h, out.GetData(), squish::kDxt5, colorMSE, alphaMSE);
// print some info about the resulting image
printf("Size: %dx%d %s in %u bytes. Quality: %5.2f\n", image->w, image->h, GetFormatString(format), out.GetSize(), colorMSE);
SDL_FreeSurface(argbImage);
}
void quicktime_recorder::append_frame(int n) {
Rect rect;
rect.left = rect.top = 0;
rect.right = m->width;
rect.bottom = m->height;
OSErr err = CompressImage(m->pixmap, &rect, codecNormalQuality,
kPNGCodecType, m->image_desc, m->ptr);
err = AddMediaSample(
m->media,
m->handle,
0,
(**m->image_desc).dataSize,
100 * n,
(SampleDescriptionHandle)m->image_desc,
1,
0,
NULL
);
}
static int
lbp310PrintPage(gx_device_printer *pDev, FILE *fp)
{
int i;
byte Buf[10];
long DataSize;
struct bounding Box;
BoundImage(pDev, &Box);
DataSize = CompressImage(pDev, &Box, fp, "\x1b[1;%d;%d;11;%d;.r");
/* ----==== Set size ====---- */
sprintf(Buf, "0%ld", DataSize);
i = (DataSize+strlen(Buf)+1)&1;
/* ----==== escape to LIPS ====---- */
fprintf(fp, "\x80%s\x80\x80\x80\x80\x0c",Buf+i);
fprintf(fp, "\x1bP0J\x1b\\");
return(0);
}
void ofQtVideoSaver::addFrame(unsigned char* data, float frameLengthInSecs){
if (!bSetupForRecordingMovie) return;
/* Save the current GWorld and set the offscreen GWorld as current.
================================================================ */
GetGWorld (&pSavedPort, &hSavedDevice);
SetGWorld (pMovieGWorld, NULL);
Ptr gwAddress, gwAddressBase;
long gwWidth;
gwAddressBase = GetPixBaseAddr( GetGWorldPixMap( pMovieGWorld ) ); /* Get head address of offscreen */
gwWidth = ( **GetGWorldPixMap( pMovieGWorld ) ).rowBytes & 0x3fff; /* Get with of offscreen */
///gwAddress = gwAddressBase + ( x * 3 ) + ( y * gwWidth ); /* Get adress for current pixel */
int myWidth = w*3;
unsigned char * myData = data;
#ifdef TARGET_OSX
//---------------------------------------------------------------
// mac's have 32 bit no matter what, so we do it like this:
for (int i = 0; i < h; i++){
gwAddress = gwAddressBase + i * gwWidth;
myData = data + i * myWidth;
for (int j = 0; j < w; j++){
memcpy(gwAddress+1, myData, 3);
/*gwAddress[1] = myData[2];
gwAddress[2] = myData[1];
gwAddress[3] = myData[0];*/
gwAddress+= 4;
myData+= 3;
}
}
#endif
#ifdef TARGET_WIN32
for (int i = 0; i < h; i++){
gwAddress = gwAddressBase + i * gwWidth;
myData = data + i * myWidth;
memcpy(gwAddress, myData, myWidth);
}
#endif
/* Compress the pixel map that has just been drawn on. Also resize
and fill in the image description. Resulting image size can be
discovered by consulting the image description field dataSize.
================================================================ */
osErr = CompressImage
(
pixMapHandle, /* the pixel map of the offscreen img */
&rect, /* portion of the image to compress */
codecQualityLevel, /* quality as set via default or #defines */
codecType, /* same codec specifier as above */
hImageDescription, /* the created image description. */
pCompressedData /* ptr to bufr that receives cmp image*/
);
if (osErr != noErr)
{
printf ("CompressImage failed %d\n", osErr);
goto bail;
}
/* Add the compressed image to the movie.
====================================== */
// converting frame length to a time duration;
float timeForQt = 1 / frameLengthInSecs;
osErr = AddMediaSample
(
media, /* the media to add the image to. */
hCompressedData, /* the compressed image to add. */
0, /* byte offs into data to begin readg */
(**hImageDescription).dataSize,/* num bytes to be copied into media. */
600 / timeForQt, /* duration of the frame (media time) */
(SampleDescriptionHandle) hImageDescription, /* image desc cast to */
/* a sample description since both */
/* both structures start with same */
/* fields. */
1, /* num samples in the data buffer. */
0, /* default flags */
NULL /* ptr to receive media time in which */
/* the image was added. */
);
if (osErr != noErr)
{
printf ("AddMediaSample failed %d\n", osErr);
//goto bail;
}
return;
bail:
SetGWorld (pSavedPort, hSavedDevice);
if (hImageDescription != NULL) DisposeHandle ((Handle) hImageDescription);
if (hCompressedData != NULL) DisposeHandle (hCompressedData);
if (pMovieGWorld != NULL) DisposeGWorld (pMovieGWorld);
}
static void QTVideo_AddVideoSamplesToMedia (Media theMedia, const Rect *trackFrame)
{
long maxCompressedSize;
GWorldPtr theGWorld = nil;
long curSample;
Handle compressedData = nil;
Ptr compressedDataPtr;
ImageDescriptionHandle imageDesc = nil;
CGrafPtr oldPort;
GDHandle oldGDeviceH;
OSErr err = noErr;
err = NewGWorld (&theGWorld,
kPixelDepth, /* pixel depth */
trackFrame,
nil,
nil,
(GWorldFlags) 0 );
CheckError (err, "NewGWorld error");
LockPixels (theGWorld->portPixMap);
err = GetMaxCompressionSize(theGWorld->portPixMap,
trackFrame,
kMgrChoose, /* let ICM choose depth */
codecNormalQuality,
kAnimationCodecType,
(CompressorComponent) anyCodec,
&maxCompressedSize);
CheckError (err, "GetMaxCompressionSize error" );
compressedData = NewHandle(maxCompressedSize);
CheckError( MemError(), "NewHandle error" );
MoveHHi( compressedData );
HLock( compressedData );
compressedDataPtr = StripAddress( *compressedData );
imageDesc = (ImageDescriptionHandle)NewHandle(4);
CheckError( MemError(), "NewHandle error" );
GetGWorld (&oldPort, &oldGDeviceH);
SetGWorld (theGWorld, nil);
for (curSample = 1; curSample <= kNumVideoFrames; curSample++)
{
EraseRect (trackFrame);
QTVideo_DrawFrame(trackFrame, curSample);
err = CompressImage (theGWorld->portPixMap,
trackFrame,
codecNormalQuality,
kAnimationCodecType,
imageDesc,
compressedDataPtr );
CheckError( err, "CompressImage error" );
err = AddMediaSample(theMedia,
compressedData,
kNoOffset, /* no offset in data */
(**imageDesc).dataSize,
kSampleDuration, /* frame duration = 1/10 sec */
(SampleDescriptionHandle)imageDesc,
kAddOneVideoSample, /* one sample */
kSyncSample, /* self-contained samples */
nil);
CheckError( err, "AddMediaSample error" );
}
SetGWorld (oldPort, oldGDeviceH);
if (imageDesc)
{
DisposeHandle ((Handle)imageDesc);
}
if (compressedData)
{
DisposeHandle (compressedData);
}
if (theGWorld)
{
DisposeGWorld (theGWorld);
}
}
void TLevelWriter3gp::save(const TImageP &img, int frameIndex)
{
if (m_cancelled)
return;
TRasterImageP image(img);
int lx = image->getRaster()->getLx();
int ly = image->getRaster()->getLy();
//void *buffer = image->getRaster()->getRawData();
int pixSize = image->getRaster()->getPixelSize();
if (pixSize != 4)
throw TImageException(getFilePath(), "Unsupported pixel type");
QMutexLocker sl(&m_mutex);
if (!m_properties)
m_properties = new Tiio::MovWriterProperties();
Tiio::MovWriterProperties *prop = (Tiio::MovWriterProperties *)(m_properties);
//CodecType compression = StandardCompressionType; prop->getCurrentCodec();
//CodecQ quality = StandardQualityType; prop->getCurrentQuality();
if (!m_initDone) {
//FSSpec fspec;
Rect frame;
long max_compressed_size;
QDErr err;
m_videoTrack = NewMovieTrack(m_movie, FixRatio((short)lx, 1), FixRatio((short)ly, 1), kNoVolume);
if ((err = GetMoviesError() != noErr))
throw TImageException(getFilePath(), "can't create video track");
m_dataRef = nil;
m_hMovieData = NewHandle(0);
// Construct the Handle data reference
err = PtrToHand(&m_hMovieData, &m_dataRef, sizeof(Handle));
if ((err = GetMoviesError() != noErr))
throw TImageException(getFilePath(), "can't create Data Ref");
m_videoMedia = NewTrackMedia(m_videoTrack, VideoMediaType, (TINT32)m_frameRate, m_dataRef, HandleDataHandlerSubType);
OpenADefaultComponent(MovieExportType, '3gpp', &m_myExporter);
// err = (short)MovieExportDoUserDialog(m_myExporter, m_movie, 0, 0, 0, &m_cancelled);
// if (m_cancelled)
// throw TImageException(getFilePath(), "User abort of 3GP render");
if ((err = GetMoviesError() != noErr))
throw TImageException(getFilePath(), "can't create video media");
if ((err = BeginMediaEdits(m_videoMedia)) != noErr)
throw TImageException(getFilePath(), "can't begin edit video media");
frame.left = 0;
frame.top = 0;
frame.right = lx;
frame.bottom = ly;
#if 0
if ((err = NewGWorld(&(m_gworld), pixSize * 8, &frame, 0, 0, 0))!=noErr)
#else /* Mac OSX 10.7 later */
if ((err = QTNewGWorld(&(m_gworld), pixSize * 8, &frame, 0, 0, 0)) != noErr)
#endif
throw TImageException(getFilePath(), "can't create movie buffer");
#ifdef WIN32
LockPixels(m_gworld->portPixMap);
if ((err = GetMaxCompressionSize(m_gworld->portPixMap, &frame, 0,
quality, compression, anyCodec,
&max_compressed_size)) != noErr)
throw TImageException(getFilePath(), "can't get max compression size");
#else
#if 0
PixMapHandle pixmapH = GetPortPixMap (m_gworld);
LockPixels(pixmapH);
#else
PixMapHandle pixmapH = NULL;
#endif
max_compressed_size = lx * ly * 4 * 20;
/*if ((err = GetMaxCompressionSize(pixmapH, &frame, 0,
quality, compression,anyCodec,
&max_compressed_size))!=noErr)
throw TImageException(getFilePath(), "can't get max compression size");*/
#endif
m_compressedData = NewHandle(max_compressed_size);
if ((err = MemError()) != noErr)
throw TImageException(getFilePath(), "can't allocate compressed data for movie");
MoveHHi(m_compressedData);
HLock(m_compressedData);
if ((err = MemError()) != noErr)
throw TImageException(getFilePath(), "can't allocate img handle");
#if 0
m_pixmap = GetGWorldPixMap(m_gworld);
if (!LockPixels(m_pixmap))
throw TImageException(getFilePath(), "can't lock pixels");
buf = (PixelXRGB*) GetPixBaseAddr(m_pixmap);
#else
m_pixmap = NULL;
buf = NULL;
#endif
buf_lx = lx;
buf_ly = ly;
m_initDone = true;
}
unsigned short rowBytes = (unsigned short)(((short)(*(m_pixmap))->rowBytes & ~(3 << 14)));
Rect frame;
ImageDescriptionHandle img_descr;
Ptr compressed_data_ptr;
QDErr err;
frame.left = 0;
frame.top = 0;
frame.right = lx;
frame.bottom = ly;
TRasterP ras = image->getRaster();
#ifdef WIN32
compressed_data_ptr = StripAddress(*(m_compressedData));
copy(ras, buf, buf_lx, buf_ly);
#else
compressed_data_ptr = *m_compressedData;
copy(ras, buf, buf_lx, buf_ly, rowBytes);
#endif
img_descr = (ImageDescriptionHandle)NewHandle(4);
#ifdef WIN32
if ((err = CompressImage(m_gworld->portPixMap,
&frame,
quality, compression,
img_descr, compressed_data_ptr)) != noErr)
throw TImageException(getFilePath(), "can't compress image");
#else
#if 0
PixMapHandle pixmapH = GetPortPixMap (m_gworld);
if ((err = CompressImage(pixmapH,
&frame,
codecNormalQuality, kJPEGCodecType,
img_descr, compressed_data_ptr))!=noErr)
{
throw TImageException(getFilePath(), "can't compress image");
}
#endif
#endif
if ((err = AddMediaSample(m_videoMedia, m_compressedData, 0,
(*img_descr)->dataSize, 1,
(SampleDescriptionHandle)img_descr,
1, 0, 0)) != noErr)
throw TImageException(getFilePath(), "can't add image to movie media");
DisposeHandle((Handle)img_descr);
}
static OSErr QTDR_AddVideoSamplesToMedia (Media theMedia, short theTrackWidth, short theTrackHeight)
{
GWorldPtr myGWorld = NULL;
PixMapHandle myPixMap = NULL;
CodecType myCodecType = kJPEGCodecType;
long myNumSample;
long myMaxComprSize = 0L;
Handle myComprDataHdl = NULL;
Ptr myComprDataPtr = NULL;
ImageDescriptionHandle myImageDesc = NULL;
CGrafPtr mySavedPort = NULL;
GDHandle mySavedDevice = NULL;
Rect myRect;
OSErr myErr = noErr;
MacSetRect(&myRect, 0, 0, theTrackWidth, theTrackHeight);
myErr = NewGWorld(&myGWorld, kPixelDepth, &myRect, NULL, NULL, (GWorldFlags)0);
if (myErr != noErr)
goto bail;
myPixMap = GetGWorldPixMap(myGWorld);
if (myPixMap == NULL)
goto bail;
LockPixels(myPixMap);
myErr = GetMaxCompressionSize( myPixMap,
&myRect,
0, // let ICM choose depth
codecNormalQuality,
myCodecType,
(CompressorComponent)anyCodec,
&myMaxComprSize);
if (myErr != noErr)
goto bail;
myComprDataHdl = NewHandle(myMaxComprSize);
if (myComprDataHdl == NULL)
goto bail;
HLockHi(myComprDataHdl);
#if TARGET_CPU_68K
myComprDataPtr = StripAddress(*myComprDataHdl);
#else
myComprDataPtr = *myComprDataHdl;
#endif
myImageDesc = (ImageDescriptionHandle)NewHandle(4);
if (myImageDesc == NULL)
goto bail;
GetGWorld(&mySavedPort, &mySavedDevice);
SetGWorld(myGWorld, NULL);
for (myNumSample = 1; myNumSample <= kNumVideoFrames; myNumSample++) {
EraseRect(&myRect);
QTDR_DrawFrame(theTrackWidth, theTrackHeight, myNumSample, myGWorld);
myErr = CompressImage( myPixMap,
&myRect,
codecNormalQuality,
myCodecType,
myImageDesc,
myComprDataPtr);
if (myErr != noErr)
goto bail;
myErr = AddMediaSample( theMedia,
myComprDataHdl,
0, // no offset in data
(**myImageDesc).dataSize,
kVideoFrameDuration, // frame duration
(SampleDescriptionHandle)myImageDesc,
1, // one sample
0, // self-contained samples
NULL);
if (myErr != noErr)
goto bail;
}
bail:
SetGWorld(mySavedPort, mySavedDevice);
if (myImageDesc != NULL)
DisposeHandle((Handle)myImageDesc);
if (myComprDataHdl != NULL)
DisposeHandle(myComprDataHdl);
if (myGWorld != NULL)
DisposeGWorld(myGWorld);
return(myErr);
}
int main(int argc, char **argv) {
int fileArg = 1;
if(fileArg == argc) {
PrintUsage();
exit(1);
}
char decompressedOutput[256]; decompressedOutput[0] = '\0';
bool bNoDecompress = false;
int numJobs = 0;
int quality = 50;
int numThreads = 1;
int numCompressions = 1;
bool bUseSIMD = false;
bool bSaveLog = false;
bool bUseAtomics = false;
bool bUsePVRTexLib = false;
bool bUseNVTT = false;
bool bVerbose = false;
FasTC::ECompressionFormat format = FasTC::eCompressionFormat_BPTC;
bool knowArg = false;
do {
knowArg = false;
if(strcmp(argv[fileArg], "-n") == 0) {
fileArg++;
if(fileArg == argc || (numCompressions = atoi(argv[fileArg])) < 0) {
PrintUsage();
exit(1);
}
fileArg++;
knowArg = true;
continue;
}
if(strcmp(argv[fileArg], "-f") == 0) {
fileArg++;
if(fileArg == argc) {
PrintUsage();
exit(1);
} else {
if(!strcmp(argv[fileArg], "PVRTC")) {
format = FasTC::eCompressionFormat_PVRTC4;
} else if(!strcmp(argv[fileArg], "PVRTCLib")) {
format = FasTC::eCompressionFormat_PVRTC4;
bUsePVRTexLib = true;
} else if(!strcmp(argv[fileArg], "BPTCLib")) {
format = FasTC::eCompressionFormat_BPTC;
bUseNVTT = true;
} else if(!strcmp(argv[fileArg], "ETC1")) {
format = FasTC::eCompressionFormat_ETC1;
} else if(!strcmp(argv[fileArg], "DXT1")) {
format = FasTC::eCompressionFormat_DXT1;
} else if(!strcmp(argv[fileArg], "DXT5")) {
format = FasTC::eCompressionFormat_DXT5;
}
}
fileArg++;
knowArg = true;
continue;
}
if(strcmp(argv[fileArg], "-d") == 0) {
fileArg++;
if(fileArg == argc) {
PrintUsage();
exit(1);
} else {
size_t sz = 255;
sz = ::std::min(sz, static_cast<size_t>(strlen(argv[fileArg])));
memcpy(decompressedOutput, argv[fileArg], sz + 1);
}
fileArg++;
knowArg = true;
continue;
}
if(strcmp(argv[fileArg], "-nd") == 0) {
fileArg++;
bNoDecompress = true;
knowArg = true;
continue;
}
if(strcmp(argv[fileArg], "-l") == 0) {
fileArg++;
bSaveLog = true;
knowArg = true;
continue;
}
if(strcmp(argv[fileArg], "-v") == 0) {
fileArg++;
bVerbose = true;
knowArg = true;
continue;
}
if(strcmp(argv[fileArg], "-simd") == 0) {
fileArg++;
bUseSIMD = true;
knowArg = true;
continue;
}
if(strcmp(argv[fileArg], "-t") == 0) {
fileArg++;
if(fileArg == argc || (numThreads = atoi(argv[fileArg])) < 1) {
PrintUsage();
exit(1);
}
fileArg++;
knowArg = true;
continue;
}
if(strcmp(argv[fileArg], "-q") == 0) {
fileArg++;
if(fileArg == argc || (quality = atoi(argv[fileArg])) < 0) {
PrintUsage();
exit(1);
}
fileArg++;
knowArg = true;
continue;
}
if(strcmp(argv[fileArg], "-j") == 0) {
fileArg++;
if(fileArg == argc || (numJobs = atoi(argv[fileArg])) < 0) {
PrintUsage();
exit(1);
}
fileArg++;
knowArg = true;
continue;
}
if(strcmp(argv[fileArg], "-a") == 0) {
fileArg++;
bUseAtomics = true;
knowArg = true;
continue;
}
} while(knowArg && fileArg < argc);
if(fileArg == argc) {
PrintUsage();
exit(1);
}
char basename[256];
ExtractBasename(argv[fileArg], basename, 256);
ImageFile file (argv[fileArg]);
if(!file.Load()) {
fprintf(stderr, "Error loading file: %s\n", argv[fileArg]);
return 1;
}
FasTC::Image<> img(*file.GetImage());
if(bVerbose) {
fprintf(stdout, "Entropy: %.5f\n", img.ComputeEntropy());
fprintf(stdout, "Mean Local Entropy: %.5f\n", img.ComputeMeanLocalEntropy());
}
std::ofstream logFile;
ThreadSafeStreambuf streamBuf(logFile);
std::ostream logStream(&streamBuf);
if(bSaveLog) {
char logname[256];
sprintf(logname, "%s.log", basename);
logFile.open(logname);
}
SCompressionSettings settings;
settings.format = format;
settings.bUseSIMD = bUseSIMD;
settings.bUseAtomics = bUseAtomics;
settings.iNumThreads = numThreads;
settings.iQuality = quality;
settings.iNumCompressions = numCompressions;
settings.iJobSize = numJobs;
settings.bUsePVRTexLib = bUsePVRTexLib;
settings.bUseNVTT = bUseNVTT;
if(bSaveLog) {
settings.logStream = &logStream;
} else {
settings.logStream = NULL;
}
CompressedImage *ci = CompressImage(&img, settings);
if(NULL == ci) {
fprintf(stderr, "Error compressing image!\n");
return 1;
}
double PSNR = img.ComputePSNR(ci);
if(PSNR > 0.0) {
fprintf(stdout, "PSNR: %.3f\n", PSNR);
}
else {
fprintf(stderr, "Error computing PSNR\n");
}
if(bVerbose) {
double SSIM = img.ComputeSSIM(ci);
if(SSIM > 0.0) {
fprintf(stdout, "SSIM: %.9f\n", SSIM);
} else {
fprintf(stderr, "Error computing SSIM\n");
}
}
if(!bNoDecompress) {
if(decompressedOutput[0] != '\0') {
memcpy(basename, decompressedOutput, 256);
} else if(format == FasTC::eCompressionFormat_BPTC) {
strcat(basename, "-bptc.png");
} else if(format == FasTC::eCompressionFormat_PVRTC4) {
strcat(basename, "-pvrtc-4bpp.png");
} else if(format == FasTC::eCompressionFormat_DXT1) {
strcat(basename, "-dxt1.png");
} else if(format == FasTC::eCompressionFormat_ETC1) {
strcat(basename, "-etc1.png");
}
EImageFileFormat fmt = ImageFile::DetectFileFormat(basename);
ImageFile cImgFile (basename, fmt, *ci);
cImgFile.Write();
}
// Cleanup
delete ci;
if(bSaveLog) {
logFile.close();
}
return 0;
}