static void *imv_loader_bg_next_frame(void *data)
{
struct imv_loader *ldr = data;
pthread_mutex_lock(&ldr->lock);
int num_frames = ldr->num_frames;
if(num_frames < 2) {
pthread_mutex_unlock(&ldr->lock);
return 0;
}
FITAG *tag = NULL;
char disposal_method = 0;
int frame_time = 0;
short top = 0;
short left = 0;
ldr->cur_frame = ldr->next_frame;
ldr->next_frame = (ldr->cur_frame + 1) % ldr->num_frames;
FIBITMAP *frame = FreeImage_LockPage(ldr->mbmp, ldr->cur_frame);
FIBITMAP *frame32 = FreeImage_ConvertTo32Bits(frame);
/* First frame is always going to use the raw frame */
if(ldr->cur_frame > 0) {
FreeImage_GetMetadata(FIMD_ANIMATION, frame, "DisposalMethod", &tag);
if(FreeImage_GetTagValue(tag)) {
disposal_method = *(char*)FreeImage_GetTagValue(tag);
}
}
FreeImage_GetMetadata(FIMD_ANIMATION, frame, "FrameLeft", &tag);
if(FreeImage_GetTagValue(tag)) {
left = *(short*)FreeImage_GetTagValue(tag);
}
FreeImage_GetMetadata(FIMD_ANIMATION, frame, "FrameTop", &tag);
if(FreeImage_GetTagValue(tag)) {
top = *(short*)FreeImage_GetTagValue(tag);
}
FreeImage_GetMetadata(FIMD_ANIMATION, frame, "FrameTime", &tag);
if(FreeImage_GetTagValue(tag)) {
frame_time = *(int*)FreeImage_GetTagValue(tag);
}
/* some gifs don't provide a frame time at all */
if(frame_time == 0) {
frame_time = 100;
}
ldr->frame_time += frame_time * 0.001;
FreeImage_UnlockPage(ldr->mbmp, frame, 0);
/* If this frame is inset, we need to expand it for compositing */
if(ldr->width != (int)FreeImage_GetWidth(frame32) ||
ldr->height != (int)FreeImage_GetHeight(frame32)) {
FIBITMAP *expanded = FreeImage_Allocate(ldr->width, ldr->height, 32, 0,0,0);
FreeImage_Paste(expanded, frame32, left, top, 255);
FreeImage_Unload(frame32);
frame32 = expanded;
}
switch(disposal_method) {
case 0: /* nothing specified, just use the raw frame */
if(ldr->bmp) {
FreeImage_Unload(ldr->bmp);
}
ldr->bmp = frame32;
break;
case 1: /* composite over previous frame */
if(ldr->bmp && ldr->cur_frame > 0) {
FIBITMAP *bg_frame = FreeImage_ConvertTo24Bits(ldr->bmp);
FreeImage_Unload(ldr->bmp);
FIBITMAP *comp = FreeImage_Composite(frame32, 1, NULL, bg_frame);
FreeImage_Unload(bg_frame);
FreeImage_Unload(frame32);
ldr->bmp = comp;
} else {
/* No previous frame, just render directly */
if(ldr->bmp) {
FreeImage_Unload(ldr->bmp);
}
ldr->bmp = frame32;
}
break;
case 2: /* TODO - set to background, composite over that */
if(ldr->bmp) {
FreeImage_Unload(ldr->bmp);
}
ldr->bmp = frame32;
break;
case 3: /* TODO - restore to previous content */
if(ldr->bmp) {
FreeImage_Unload(ldr->bmp);
}
ldr->bmp = frame32;
break;
}
if(ldr->out_bmp) {
FreeImage_Unload(ldr->out_bmp);
}
ldr->out_bmp = FreeImage_Clone(ldr->bmp);
ldr->out_is_new_image = 0;
pthread_mutex_unlock(&ldr->lock);
return 0;
}
static void *imv_loader_bg_new_img(void *data)
{
/* so we can poll for it */
block_usr1_signal();
struct imv_loader *ldr = data;
pthread_mutex_lock(&ldr->lock);
char *path = strdup(ldr->path);
pthread_mutex_unlock(&ldr->lock);
FREE_IMAGE_FORMAT fmt = FreeImage_GetFileType(path, 0);
if(fmt == FIF_UNKNOWN) {
imv_loader_error_occurred(ldr);
free(path);
return 0;
}
int num_frames = 1;
FIMULTIBITMAP *mbmp = NULL;
FIBITMAP *bmp = NULL;
int width, height;
int raw_frame_time = 100; /* default to 100 */
if(fmt == FIF_GIF) {
mbmp = FreeImage_OpenMultiBitmap(FIF_GIF, path,
/* don't create file */ 0,
/* read only */ 1,
/* keep in memory */ 1,
/* flags */ GIF_LOAD256);
free(path);
if(!mbmp) {
imv_loader_error_occurred(ldr);
return 0;
}
num_frames = FreeImage_GetPageCount(mbmp);
FIBITMAP *frame = FreeImage_LockPage(mbmp, 0);
width = FreeImage_GetWidth(frame);
height = FreeImage_GetHeight(frame);
bmp = FreeImage_ConvertTo32Bits(frame);
/* get duration of first frame */
FITAG *tag = NULL;
FreeImage_GetMetadata(FIMD_ANIMATION, frame, "FrameTime", &tag);
if(FreeImage_GetTagValue(tag)) {
raw_frame_time = *(int*)FreeImage_GetTagValue(tag);
}
FreeImage_UnlockPage(mbmp, frame, 0);
} else {
/* Future TODO: If we load image line-by-line we could stop loading large
* ones before wasting much more time/memory on them. */
FIBITMAP *image = FreeImage_Load(fmt, path, 0);
free(path);
if(!image) {
imv_loader_error_occurred(ldr);
return 0;
}
/* Check for cancellation before we convert pixel format */
if(is_thread_cancelled()) {
FreeImage_Unload(image);
return 0;
}
width = FreeImage_GetWidth(bmp);
height = FreeImage_GetHeight(bmp);
bmp = FreeImage_ConvertTo32Bits(image);
FreeImage_Unload(image);
}
/* now update the loader */
pthread_mutex_lock(&ldr->lock);
/* check for cancellation before finishing */
if(is_thread_cancelled()) {
if(mbmp) {
FreeImage_CloseMultiBitmap(mbmp, 0);
}
if(bmp) {
FreeImage_Unload(bmp);
}
pthread_mutex_unlock(&ldr->lock);
return 0;
}
if(ldr->mbmp) {
FreeImage_CloseMultiBitmap(ldr->mbmp, 0);
}
if(ldr->bmp) {
FreeImage_Unload(ldr->bmp);
}
ldr->mbmp = mbmp;
ldr->bmp = bmp;
if(ldr->out_bmp) {
FreeImage_Unload(ldr->out_bmp);
}
ldr->out_bmp = FreeImage_Clone(bmp);
ldr->out_is_new_image = 1;
ldr->width = width;
ldr->height = height;
ldr->cur_frame = 0;
ldr->next_frame = 1;
ldr->num_frames = num_frames;
ldr->frame_time = (double)raw_frame_time * 0.0001;
pthread_mutex_unlock(&ldr->lock);
return 0;
}
FIBITMAP * DLL_CALLCONV
FreeImage_ConvertToRGBF(FIBITMAP *dib) {
FIBITMAP *src = NULL;
FIBITMAP *dst = NULL;
if(!FreeImage_HasPixels(dib)) return NULL;
const FREE_IMAGE_TYPE src_type = FreeImage_GetImageType(dib);
// check for allowed conversions
switch(src_type) {
case FIT_BITMAP:
{
// allow conversion from 24- and 32-bit
const FREE_IMAGE_COLOR_TYPE color_type = FreeImage_GetColorType(dib);
if((color_type != FIC_RGB) && (color_type != FIC_RGBALPHA)) {
src = FreeImage_ConvertTo24Bits(dib);
if(!src) return NULL;
} else {
src = dib;
}
break;
}
case FIT_UINT16:
// allow conversion from 16-bit
src = dib;
break;
case FIT_RGB16:
// allow conversion from 48-bit RGB
src = dib;
break;
case FIT_RGBA16:
// allow conversion from 64-bit RGBA (ignore the alpha channel)
src = dib;
break;
case FIT_FLOAT:
// allow conversion from 32-bit float
src = dib;
break;
case FIT_RGBAF:
// allow conversion from 128-bit RGBAF
src = dib;
break;
case FIT_RGBF:
// RGBF type : clone the src
return FreeImage_Clone(dib);
break;
default:
return NULL;
}
// allocate dst image
const unsigned width = FreeImage_GetWidth(src);
const unsigned height = FreeImage_GetHeight(src);
dst = FreeImage_AllocateT(FIT_RGBF, width, height);
if(!dst) return NULL;
// copy metadata from src to dst
FreeImage_CloneMetadata(dst, src);
// convert from src type to RGBF
const unsigned src_pitch = FreeImage_GetPitch(src);
const unsigned dst_pitch = FreeImage_GetPitch(dst);
switch(src_type) {
case FIT_BITMAP:
{
// calculate the number of bytes per pixel (3 for 24-bit or 4 for 32-bit)
const unsigned bytespp = FreeImage_GetLine(src) / FreeImage_GetWidth(src);
const BYTE *src_bits = (BYTE*)FreeImage_GetBits(src);
BYTE *dst_bits = (BYTE*)FreeImage_GetBits(dst);
for(unsigned y = 0; y < height; y++) {
const BYTE *src_pixel = (BYTE*)src_bits;
FIRGBF *dst_pixel = (FIRGBF*)dst_bits;
for(unsigned x = 0; x < width; x++) {
// convert and scale to the range [0..1]
dst_pixel->red = (float)(src_pixel[FI_RGBA_RED]) / 255.0F;
dst_pixel->green = (float)(src_pixel[FI_RGBA_GREEN]) / 255.0F;
dst_pixel->blue = (float)(src_pixel[FI_RGBA_BLUE]) / 255.0F;
src_pixel += bytespp;
dst_pixel ++;
}
src_bits += src_pitch;
dst_bits += dst_pitch;
}
}
break;
case FIT_UINT16:
{
const BYTE *src_bits = (BYTE*)FreeImage_GetBits(src);
BYTE *dst_bits = (BYTE*)FreeImage_GetBits(dst);
for(unsigned y = 0; y < height; y++) {
const WORD *src_pixel = (WORD*)src_bits;
FIRGBF *dst_pixel = (FIRGBF*)dst_bits;
for(unsigned x = 0; x < width; x++) {
// convert and scale to the range [0..1]
const float dst_value = (float)src_pixel[x] / 65535.0F;
dst_pixel[x].red = dst_value;
dst_pixel[x].green = dst_value;
dst_pixel[x].blue = dst_value;
}
src_bits += src_pitch;
dst_bits += dst_pitch;
}
}
break;
case FIT_RGB16:
{
const BYTE *src_bits = (BYTE*)FreeImage_GetBits(src);
BYTE *dst_bits = (BYTE*)FreeImage_GetBits(dst);
for(unsigned y = 0; y < height; y++) {
const FIRGB16 *src_pixel = (FIRGB16*) src_bits;
FIRGBF *dst_pixel = (FIRGBF*) dst_bits;
for(unsigned x = 0; x < width; x++) {
// convert and scale to the range [0..1]
dst_pixel[x].red = (float)(src_pixel[x].red) / 65535.0F;
dst_pixel[x].green = (float)(src_pixel[x].green) / 65535.0F;
dst_pixel[x].blue = (float)(src_pixel[x].blue) / 65535.0F;
}
src_bits += src_pitch;
dst_bits += dst_pitch;
}
}
break;
case FIT_RGBA16:
{
const BYTE *src_bits = (BYTE*)FreeImage_GetBits(src);
BYTE *dst_bits = (BYTE*)FreeImage_GetBits(dst);
for(unsigned y = 0; y < height; y++) {
const FIRGBA16 *src_pixel = (FIRGBA16*) src_bits;
FIRGBF *dst_pixel = (FIRGBF*) dst_bits;
for(unsigned x = 0; x < width; x++) {
// convert and scale to the range [0..1]
dst_pixel[x].red = (float)(src_pixel[x].red) / 65535.0F;
dst_pixel[x].green = (float)(src_pixel[x].green) / 65535.0F;
dst_pixel[x].blue = (float)(src_pixel[x].blue) / 65535.0F;
}
src_bits += src_pitch;
dst_bits += dst_pitch;
}
}
break;
case FIT_FLOAT:
{
const BYTE *src_bits = (BYTE*)FreeImage_GetBits(src);
BYTE *dst_bits = (BYTE*)FreeImage_GetBits(dst);
for(unsigned y = 0; y < height; y++) {
const float *src_pixel = (float*) src_bits;
FIRGBF *dst_pixel = (FIRGBF*) dst_bits;
for(unsigned x = 0; x < width; x++) {
// convert by copying greyscale channel to each R, G, B channels
dst_pixel[x].red = src_pixel[x];
dst_pixel[x].green = src_pixel[x];
dst_pixel[x].blue = src_pixel[x];
}
src_bits += src_pitch;
dst_bits += dst_pitch;
}
}
break;
case FIT_RGBAF:
{
const BYTE *src_bits = (BYTE*)FreeImage_GetBits(src);
BYTE *dst_bits = (BYTE*)FreeImage_GetBits(dst);
for(unsigned y = 0; y < height; y++) {
const FIRGBAF *src_pixel = (FIRGBAF*) src_bits;
FIRGBF *dst_pixel = (FIRGBF*) dst_bits;
for(unsigned x = 0; x < width; x++) {
// convert and skip alpha channel
dst_pixel[x].red = src_pixel[x].red;
dst_pixel[x].green = src_pixel[x].green;
dst_pixel[x].blue = src_pixel[x].blue;
}
src_bits += src_pitch;
dst_bits += dst_pitch;
}
}
break;
}
if(src != dib) {
FreeImage_Unload(src);
}
return dst;
}
FIBITMAP * DLL_CALLCONV
FreeImage_ConvertToUINT16(FIBITMAP *dib) {
FIBITMAP *src = NULL;
FIBITMAP *dst = NULL;
if(!FreeImage_HasPixels(dib)) return NULL;
const FREE_IMAGE_TYPE src_type = FreeImage_GetImageType(dib);
// check for allowed conversions
switch(src_type) {
case FIT_BITMAP:
{
// convert to greyscale if needed
if((FreeImage_GetBPP(dib) == 8) && (FreeImage_GetColorType(dib) == FIC_MINISBLACK)) {
src = dib;
} else {
src = FreeImage_ConvertToGreyscale(dib);
if(!src) return NULL;
}
break;
}
case FIT_UINT16:
// UINT16 type : clone the src
return FreeImage_Clone(dib);
break;
case FIT_RGB16:
// allow conversion from 48-bit RGB
src = dib;
break;
case FIT_RGBA16:
// allow conversion from 64-bit RGBA (ignore the alpha channel)
src = dib;
break;
default:
return NULL;
}
// allocate dst image
const unsigned width = FreeImage_GetWidth(src);
const unsigned height = FreeImage_GetHeight(src);
dst = FreeImage_AllocateT(FIT_UINT16, width, height);
if(!dst) return NULL;
// copy metadata from src to dst
FreeImage_CloneMetadata(dst, src);
// convert from src type to UINT16
switch(src_type) {
case FIT_BITMAP:
{
for(unsigned y = 0; y < height; y++) {
const BYTE *src_bits = (BYTE*)FreeImage_GetScanLine(src, y);
WORD *dst_bits = (WORD*)FreeImage_GetScanLine(dst, y);
for(unsigned x = 0; x < width; x++) {
dst_bits[x] = src_bits[x] << 8;
}
}
}
break;
case FIT_RGB16:
{
for(unsigned y = 0; y < height; y++) {
const FIRGB16 *src_bits = (FIRGB16*)FreeImage_GetScanLine(src, y);
WORD *dst_bits = (WORD*)FreeImage_GetScanLine(dst, y);
for(unsigned x = 0; x < width; x++) {
// convert to grey
dst_bits[x] = (WORD)LUMA_REC709(src_bits[x].red, src_bits[x].green, src_bits[x].blue);
}
}
}
break;
case FIT_RGBA16:
{
for(unsigned y = 0; y < height; y++) {
const FIRGBA16 *src_bits = (FIRGBA16*)FreeImage_GetScanLine(src, y);
WORD *dst_bits = (WORD*)FreeImage_GetScanLine(dst, y);
for(unsigned x = 0; x < width; x++) {
// convert to grey
dst_bits[x] = (WORD)LUMA_REC709(src_bits[x].red, src_bits[x].green, src_bits[x].blue);
}
}
}
break;
default:
break;
}
if(src != dib) {
FreeImage_Unload(src);
}
return dst;
}
FIBITMAP * DLL_CALLCONV
FreeImage_ConvertToRGB16(FIBITMAP *dib) {
FIBITMAP *src = NULL;
FIBITMAP *dst = NULL;
if(!FreeImage_HasPixels(dib)) return NULL;
const FREE_IMAGE_TYPE src_type = FreeImage_GetImageType(dib);
// check for allowed conversions
switch(src_type) {
case FIT_BITMAP:
{
// convert to 24-bit if needed
if((FreeImage_GetBPP(dib) == 24) || (FreeImage_GetBPP(dib) == 32)) {
src = dib;
} else {
src = FreeImage_ConvertTo24Bits(dib);
if(!src) return NULL;
}
break;
}
case FIT_UINT16:
// allow conversion from unsigned 16-bit
src = dib;
break;
case FIT_RGB16:
// RGB16 type : clone the src
return FreeImage_Clone(dib);
break;
case FIT_RGBA16:
// allow conversion from 64-bit RGBA (ignore the alpha channel)
src = dib;
break;
default:
return NULL;
}
// allocate dst image
const unsigned width = FreeImage_GetWidth(src);
const unsigned height = FreeImage_GetHeight(src);
dst = FreeImage_AllocateT(FIT_RGB16, width, height);
if(!dst) {
if(src != dib) {
FreeImage_Unload(src);
}
return NULL;
}
// copy metadata from src to dst
FreeImage_CloneMetadata(dst, src);
// convert from src type to RGB16
switch(src_type) {
case FIT_BITMAP:
{
// Calculate the number of bytes per pixel (1 for 8-bit, 3 for 24-bit or 4 for 32-bit)
const unsigned bytespp = FreeImage_GetLine(src) / FreeImage_GetWidth(src);
for(unsigned y = 0; y < height; y++) {
const BYTE *src_bits = (BYTE*)FreeImage_GetScanLine(src, y);
FIRGB16 *dst_bits = (FIRGB16*)FreeImage_GetScanLine(dst, y);
for(unsigned x = 0; x < width; x++) {
dst_bits[x].red = src_bits[FI_RGBA_RED] << 8;
dst_bits[x].green = src_bits[FI_RGBA_GREEN] << 8;
dst_bits[x].blue = src_bits[FI_RGBA_BLUE] << 8;
src_bits += bytespp;
}
}
}
break;
case FIT_UINT16:
{
for(unsigned y = 0; y < height; y++) {
const WORD *src_bits = (WORD*)FreeImage_GetScanLine(src, y);
FIRGB16 *dst_bits = (FIRGB16*)FreeImage_GetScanLine(dst, y);
for(unsigned x = 0; x < width; x++) {
// convert by copying greyscale channel to each R, G, B channels
dst_bits[x].red = src_bits[x];
dst_bits[x].green = src_bits[x];
dst_bits[x].blue = src_bits[x];
}
}
}
break;
case FIT_RGBA16:
{
for(unsigned y = 0; y < height; y++) {
const FIRGBA16 *src_bits = (FIRGBA16*)FreeImage_GetScanLine(src, y);
FIRGB16 *dst_bits = (FIRGB16*)FreeImage_GetScanLine(dst, y);
for(unsigned x = 0; x < width; x++) {
// convert and skip alpha channel
dst_bits[x].red = src_bits[x].red;
dst_bits[x].green = src_bits[x].green;
dst_bits[x].blue = src_bits[x].blue;
}
}
}
break;
default:
break;
}
if(src != dib) {
FreeImage_Unload(src);
}
return dst;
}
