video_overlay_t *
video_overlay_dup(video_overlay_t *src)
{
video_overlay_t *dst = malloc(sizeof(video_overlay_t));
memcpy(dst, src, sizeof(video_overlay_t));
if(src->vo_pixmap)
dst->vo_pixmap = pixmap_dup(src->vo_pixmap);
if(src->vo_text) {
dst->vo_text = malloc(src->vo_text_length * sizeof(uint32_t));
memcpy(dst->vo_text, src->vo_text, src->vo_text_length * sizeof(uint32_t));
}
return dst;
}
int
glw_tex_backend_load(glw_root_t *gr, glw_loadable_texture_t *glt, pixmap_t *pm)
{
int size;
switch(pm->pm_type) {
default:
return 0;
case PIXMAP_RGB24:
glt->glt_format = GL_RGB;
size = pm->pm_width * pm->pm_height * 4;
break;
case PIXMAP_BGR32:
glt->glt_format = GL_RGBA;
size = pm->pm_width * pm->pm_height * 4;
break;
case PIXMAP_IA:
glt->glt_format = GL_LUMINANCE_ALPHA;
size = pm->pm_width * pm->pm_height * 2;
break;
case PIXMAP_I:
glt->glt_format = GL_LUMINANCE;
size = pm->pm_width * pm->pm_height;
break;
}
if(glt->glt_pixmap != NULL)
pixmap_release(glt->glt_pixmap);
glt->glt_pixmap = pixmap_dup(pm);
return size;
}
pixmap_t *
fa_imageloader(const char *url, const struct image_meta *im,
const char **vpaths, char *errbuf, size_t errlen,
int *cache_control, cancellable_t *c)
{
uint8_t p[16];
int r;
int width = -1, height = -1, orientation = 0;
fa_handle_t *fh;
pixmap_t *pm;
pixmap_type_t fmt;
#if ENABLE_LIBAV
if(strchr(url, '#'))
return fa_image_from_video(url, im, errbuf, errlen, cache_control, c);
#endif
if(!im->im_want_thumb)
return fa_imageloader2(url, vpaths, errbuf, errlen, cache_control, c);
fa_open_extra_t foe = {
.foe_c = c
};
if((fh = fa_open_vpaths(url, vpaths, errbuf, errlen,
FA_BUFFERED_SMALL, &foe)) == NULL)
return NULL;
if(ONLY_CACHED(cache_control)) {
snprintf(errbuf, errlen, "Not cached");
return NULL;
}
if(fa_read(fh, p, sizeof(p)) != sizeof(p)) {
snprintf(errbuf, errlen, "File too short");
fa_close(fh);
return NULL;
}
/* Probe format */
if((p[6] == 'J' && p[7] == 'F' && p[8] == 'I' && p[9] == 'F') ||
(p[6] == 'E' && p[7] == 'x' && p[8] == 'i' && p[9] == 'f')) {
jpeginfo_t ji;
if(jpeg_info(&ji, jpeginfo_reader, fh,
JPEG_INFO_DIMENSIONS |
JPEG_INFO_ORIENTATION |
(im->im_want_thumb ? JPEG_INFO_THUMBNAIL : 0),
p, sizeof(p), errbuf, errlen)) {
fa_close(fh);
return NULL;
}
if(im->im_want_thumb && ji.ji_thumbnail) {
pixmap_t *pm = pixmap_dup(ji.ji_thumbnail);
fa_close(fh);
jpeg_info_clear(&ji);
return pm;
}
fmt = PIXMAP_JPEG;
width = ji.ji_width;
height = ji.ji_height;
orientation = ji.ji_orientation;
jpeg_info_clear(&ji);
} else if(!memcmp(pngsig, p, 8)) {
fmt = PIXMAP_PNG;
} else if(!memcmp(gif87sig, p, sizeof(gif87sig)) ||
!memcmp(gif89sig, p, sizeof(gif89sig))) {
fmt = PIXMAP_GIF;
} else if(!memcmp(svgsig1, p, sizeof(svgsig1)) ||
!memcmp(svgsig2, p, sizeof(svgsig2))) {
fmt = PIXMAP_SVG;
} else {
snprintf(errbuf, errlen, "Unknown format");
fa_close(fh);
return NULL;
}
int64_t s = fa_fsize(fh);
if(s < 0) {
snprintf(errbuf, errlen, "Can't read from non-seekable file");
fa_close(fh);
return NULL;
}
pm = pixmap_alloc_coded(NULL, s, fmt);
if(pm == NULL) {
snprintf(errbuf, errlen, "Out of memory");
fa_close(fh);
return NULL;
}
pm->pm_width = width;
pm->pm_height = height;
pm->pm_orientation = orientation;
fa_seek(fh, SEEK_SET, 0);
r = fa_read(fh, pm->pm_data, pm->pm_size);
fa_close(fh);
if(r != pm->pm_size) {
pixmap_release(pm);
snprintf(errbuf, errlen, "Read error");
return NULL;
}
return pm;
}
void
screenshot_deliver(pixmap_t *pm)
{
task_run(screenshot_process, pixmap_dup(pm));
}
/**
* Clone a token
*/
token_t *
glw_view_token_copy(token_t *src)
{
token_t *dst = calloc(1, sizeof(token_t));
#ifdef GLW_VIEW_ERRORINFO
dst->file = rstr_dup(src->file);
dst->line = src->line;
#endif
dst->type = src->type;
switch(src->type) {
case TOKEN_FLOAT:
dst->t_float = src->t_float;
break;
case TOKEN_INT:
dst->t_int = src->t_int;
break;
case TOKEN_PROPERTY_REF:
dst->t_prop = prop_ref_inc(src->t_prop);
break;
case TOKEN_PROPERTY_OWNER:
dst->t_prop = prop_xref_addref(src->t_prop);
break;
case TOKEN_PROPERTY_SUBSCRIPTION:
case TOKEN_DIRECTORY:
dst->propsubr = src->propsubr;
break;
case TOKEN_FUNCTION:
dst->t_func = src->t_func;
if(dst->t_func->ctor != NULL)
dst->t_func->ctor(dst);
case TOKEN_LEFT_BRACKET:
dst->t_num_args = src->t_num_args;
break;
case TOKEN_OBJECT_ATTRIBUTE:
dst->t_attrib = src->t_attrib;
break;
case TOKEN_CSTRING:
dst->t_cstring = src->t_cstring;
break;
case TOKEN_RSTRING:
dst->t_rstrtype = src->t_rstrtype;
// FALLTHRU
case TOKEN_IDENTIFIER:
case TOKEN_PROPERTY_VALUE_NAME:
case TOKEN_PROPERTY_CANONICAL_NAME:
dst->t_rstring = rstr_dup(src->t_rstring);
break;
case TOKEN_START:
case TOKEN_END:
case TOKEN_HASH:
case TOKEN_ASSIGNMENT:
case TOKEN_COND_ASSIGNMENT:
case TOKEN_END_OF_EXPR:
case TOKEN_SEPARATOR:
case TOKEN_BLOCK_OPEN:
case TOKEN_BLOCK_CLOSE:
case TOKEN_LEFT_PARENTHESIS:
case TOKEN_RIGHT_PARENTHESIS:
case TOKEN_RIGHT_BRACKET:
case TOKEN_DOT:
case TOKEN_ADD:
case TOKEN_SUB:
case TOKEN_MULTIPLY:
case TOKEN_DIVIDE:
case TOKEN_MODULO:
case TOKEN_DOLLAR:
case TOKEN_AMPERSAND:
case TOKEN_BOOLEAN_AND:
case TOKEN_BOOLEAN_OR:
case TOKEN_BOOLEAN_XOR:
case TOKEN_BOOLEAN_NOT:
case TOKEN_EQ:
case TOKEN_NEQ:
case TOKEN_LT:
case TOKEN_GT:
case TOKEN_NULL_COALESCE:
case TOKEN_EXPR:
case TOKEN_RPN:
case TOKEN_BLOCK:
case TOKEN_NOP:
case TOKEN_VOID:
break;
case TOKEN_PIXMAP:
dst->t_pixmap = pixmap_dup(src->t_pixmap);
break;
case TOKEN_LINK:
dst->t_link_rtitle = rstr_dup(src->t_link_rtitle);
dst->t_link_rurl = rstr_dup(src->t_link_rurl);
break;
case TOKEN_VECTOR_FLOAT:
case TOKEN_VECTOR_STRING:
case TOKEN_VECTOR_INT:
case TOKEN_num:
case TOKEN_EVENT:
abort();
}
return dst;
}
pixmap_t *
fa_imageloader(const char *url, const struct image_meta *im,
const char **vpaths, char *errbuf, size_t errlen)
{
uint8_t p[16];
int r;
enum CodecID codec;
int width = -1, height = -1, orientation = 0;
AVIOContext *avio;
pixmap_t *pm;
if(strchr(url, '#')) {
pm = fa_image_from_video(url, im);
if(pm == NULL)
snprintf(errbuf, errlen, "%s: Unable to extract image", url);
return pm;
}
if(!im->want_thumb)
return fa_imageloader2(url, vpaths, errbuf, errlen);
if((avio = fa_libav_open_vpaths(url, 32768, vpaths)) == NULL) {
snprintf(errbuf, errlen, "%s: Unable to open file", url);
return NULL;
}
if(avio_read(avio, p, sizeof(p)) != sizeof(p)) {
snprintf(errbuf, errlen, "%s: file too short", url);
fa_libav_close(avio);
return NULL;
}
/* Probe format */
if((p[6] == 'J' && p[7] == 'F' && p[8] == 'I' && p[9] == 'F') ||
(p[6] == 'E' && p[7] == 'x' && p[8] == 'i' && p[9] == 'f')) {
jpeginfo_t ji;
if(jpeg_info(&ji, jpeginfo_reader, avio,
JPEG_INFO_DIMENSIONS |
JPEG_INFO_ORIENTATION |
(im->want_thumb ? JPEG_INFO_THUMBNAIL : 0),
p, sizeof(p), errbuf, errlen)) {
fa_libav_close(avio);
return NULL;
}
if(im->want_thumb && ji.ji_thumbnail) {
pixmap_t *pm = pixmap_dup(ji.ji_thumbnail);
fa_libav_close(avio);
jpeg_info_clear(&ji);
return pm;
}
codec = CODEC_ID_MJPEG;
width = ji.ji_width;
height = ji.ji_height;
orientation = ji.ji_orientation;
jpeg_info_clear(&ji);
} else if(!memcmp(pngsig, p, 8)) {
codec = CODEC_ID_PNG;
} else if(!memcmp(gif87sig, p, sizeof(gif87sig)) ||
!memcmp(gif89sig, p, sizeof(gif89sig))) {
codec = CODEC_ID_GIF;
} else {
snprintf(errbuf, errlen, "%s: unknown format", url);
fa_libav_close(avio);
return NULL;
}
size_t s = avio_size(avio);
if(s < 0) {
snprintf(errbuf, errlen, "%s: Can't read from non-seekable file", url);
fa_libav_close(avio);
return NULL;
}
pm = pixmap_alloc_coded(NULL, s, codec);
if(pm == NULL) {
snprintf(errbuf, errlen, "%s: no memory", url);
fa_libav_close(avio);
return NULL;
}
pm->pm_width = width;
pm->pm_height = height;
pm->pm_orientation = orientation;
avio_seek(avio, SEEK_SET, 0);
r = avio_read(avio, pm->pm_data, pm->pm_size);
fa_libav_close(avio);
if(r != pm->pm_size) {
pixmap_release(pm);
snprintf(errbuf, errlen, "%s: read error", url);
return NULL;
}
return pm;
}
