/* Parses a packet record header. There are two possible formats:
1) output to a control blade with date and time
2002-5-10,20:1:31.4: l2-tx (FR:3/7/1:1), Length:18, Pro:0, Off:0, Pri:0, RM:0, Err:0 [0x4000, 0x0]
2) output to PE without date and time
l2-tx (FR:3/7/1:1), Length:18, Pro:0, Off:0, Pri:0, RM:0, Err:0 [0x4000, 0x0] */
static gboolean
parse_cosine_packet(FILE_T fh, struct wtap_pkthdr *phdr, Buffer *buf,
char *line, int *err, gchar **err_info)
{
union wtap_pseudo_header *pseudo_header = &phdr->pseudo_header;
int num_items_scanned;
int yy, mm, dd, hr, min, sec, csec, pkt_len;
int pro, off, pri, rm, error;
guint code1, code2;
char if_name[COSINE_MAX_IF_NAME_LEN] = "", direction[6] = "";
struct tm tm;
guint8 *pd;
int i, hex_lines, n, caplen = 0;
if (sscanf(line, "%4d-%2d-%2d,%2d:%2d:%2d.%9d:",
&yy, &mm, &dd, &hr, &min, &sec, &csec) == 7) {
/* appears to be output to a control blade */
num_items_scanned = sscanf(line,
"%4d-%2d-%2d,%2d:%2d:%2d.%9d: %5s (%127[A-Za-z0-9/:]), Length:%9d, Pro:%9d, Off:%9d, Pri:%9d, RM:%9d, Err:%9d [%8x, %8x]",
&yy, &mm, &dd, &hr, &min, &sec, &csec,
direction, if_name, &pkt_len,
&pro, &off, &pri, &rm, &error,
&code1, &code2);
if (num_items_scanned != 17) {
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup("cosine: purported control blade line doesn't have code values");
return FALSE;
}
} else {
/* appears to be output to PE */
num_items_scanned = sscanf(line,
"%5s (%127[A-Za-z0-9/:]), Length:%9d, Pro:%9d, Off:%9d, Pri:%9d, RM:%9d, Err:%9d [%8x, %8x]",
direction, if_name, &pkt_len,
&pro, &off, &pri, &rm, &error,
&code1, &code2);
if (num_items_scanned != 10) {
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup("cosine: header line is neither control blade nor PE output");
return FALSE;
}
yy = mm = dd = hr = min = sec = csec = 0;
}
if (pkt_len < 0) {
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup("cosine: packet header has a negative packet length");
return FALSE;
}
if (pkt_len > WTAP_MAX_PACKET_SIZE) {
/*
* Probably a corrupt capture file; don't blow up trying
* to allocate space for an immensely-large packet.
*/
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup_printf("cosine: File has %u-byte packet, bigger than maximum of %u",
pkt_len, WTAP_MAX_PACKET_SIZE);
return FALSE;
}
phdr->rec_type = REC_TYPE_PACKET;
phdr->presence_flags = WTAP_HAS_TS|WTAP_HAS_CAP_LEN;
tm.tm_year = yy - 1900;
tm.tm_mon = mm - 1;
tm.tm_mday = dd;
tm.tm_hour = hr;
tm.tm_min = min;
tm.tm_sec = sec;
tm.tm_isdst = -1;
phdr->ts.secs = mktime(&tm);
phdr->ts.nsecs = csec * 10000000;
phdr->len = pkt_len;
/* XXX need to handle other encapsulations like Cisco HDLC,
Frame Relay and ATM */
if (strncmp(if_name, "TEST:", 5) == 0) {
pseudo_header->cosine.encap = COSINE_ENCAP_TEST;
} else if (strncmp(if_name, "PPoATM:", 7) == 0) {
pseudo_header->cosine.encap = COSINE_ENCAP_PPoATM;
} else if (strncmp(if_name, "PPoFR:", 6) == 0) {
pseudo_header->cosine.encap = COSINE_ENCAP_PPoFR;
} else if (strncmp(if_name, "ATM:", 4) == 0) {
pseudo_header->cosine.encap = COSINE_ENCAP_ATM;
} else if (strncmp(if_name, "FR:", 3) == 0) {
pseudo_header->cosine.encap = COSINE_ENCAP_FR;
} else if (strncmp(if_name, "HDLC:", 5) == 0) {
pseudo_header->cosine.encap = COSINE_ENCAP_HDLC;
} else if (strncmp(if_name, "PPP:", 4) == 0) {
pseudo_header->cosine.encap = COSINE_ENCAP_PPP;
} else if (strncmp(if_name, "ETH:", 4) == 0) {
pseudo_header->cosine.encap = COSINE_ENCAP_ETH;
} else {
pseudo_header->cosine.encap = COSINE_ENCAP_UNKNOWN;
}
if (strncmp(direction, "l2-tx", 5) == 0) {
pseudo_header->cosine.direction = COSINE_DIR_TX;
} else if (strncmp(direction, "l2-rx", 5) == 0) {
pseudo_header->cosine.direction = COSINE_DIR_RX;
}
g_strlcpy(pseudo_header->cosine.if_name, if_name,
COSINE_MAX_IF_NAME_LEN);
pseudo_header->cosine.pro = pro;
pseudo_header->cosine.off = off;
pseudo_header->cosine.pri = pri;
pseudo_header->cosine.rm = rm;
pseudo_header->cosine.err = error;
/* Make sure we have enough room for the packet */
ws_buffer_assure_space(buf, pkt_len);
pd = ws_buffer_start_ptr(buf);
/* Calculate the number of hex dump lines, each
* containing 16 bytes of data */
hex_lines = pkt_len / 16 + ((pkt_len % 16) ? 1 : 0);
for (i = 0; i < hex_lines; i++) {
if (file_gets(line, COSINE_LINE_LENGTH, fh) == NULL) {
*err = file_error(fh, err_info);
if (*err == 0) {
*err = WTAP_ERR_SHORT_READ;
}
return FALSE;
}
if (empty_line(line)) {
break;
}
if ((n = parse_single_hex_dump_line(line, pd, i*16)) == -1) {
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup("cosine: hex dump line doesn't have 16 numbers");
return FALSE;
}
caplen += n;
}
phdr->caplen = caplen;
return TRUE;
}
static int register_storage(lua_State *L)
{
lua_settop(L, 7);
lua_getfield(L, LUA_REGISTRYINDEX, "dt_lua_storages");
lua_newtable(L);
dt_imageio_module_storage_t *storage = malloc(sizeof(dt_imageio_module_storage_t));
memcpy(storage, &ref_storage, sizeof(dt_imageio_module_storage_t));
storage->gui_data = malloc(sizeof(lua_storage_gui_t));
lua_storage_gui_t *data = storage->gui_data;
const char *plugin_name = luaL_checkstring(L, 1);
lua_pushvalue(L, 1);
lua_setfield(L, -2, "plugin_name");
g_strlcpy(storage->plugin_name, plugin_name, sizeof(storage->plugin_name));
const char *name = luaL_checkstring(L, 2);
lua_pushvalue(L, 2);
lua_setfield(L, -2, "name");
data->name = strdup(name);
data->supported_formats = NULL;
data->widget = NULL;
if(!lua_isnoneornil(L, 3))
{
luaL_checktype(L, 3, LUA_TFUNCTION);
lua_pushvalue(L, 3);
lua_setfield(L, -2, "store");
}
if(lua_isnil(L, 4))
{
storage->finalize_store = NULL;
}
else
{
luaL_checktype(L, 4, LUA_TFUNCTION);
lua_pushvalue(L, 4);
lua_setfield(L, -2, "finalize_store");
}
if(!lua_isnoneornil(L, 5))
{
luaL_checktype(L, 5, LUA_TFUNCTION);
lua_pushvalue(L, 5);
lua_setfield(L, -2, "supported");
}
if(lua_isnil(L, 6))
{
storage->initialize_store = NULL;
}
else
{
luaL_checktype(L, 6, LUA_TFUNCTION);
lua_pushvalue(L, 6);
lua_setfield(L, -2, "initialize_store");
}
if(lua_isnil(L, 7))
{
storage->gui_init = empty_wrapper;
storage->gui_reset = empty_wrapper;
storage->gui_cleanup = empty_wrapper;
}
else
{
lua_widget widget;
luaA_to(L,lua_widget,&widget,7);
dt_lua_widget_bind(L,widget);
data->widget = widget;
}
lua_setfield(L, -2, plugin_name);
char tmp[1024];
snprintf(tmp, sizeof(tmp), "dt_imageio_module_data_pseudo_%s", storage->plugin_name);
luaA_Type type_id = luaA_type_add(L, tmp, storage->params_size(storage));
storage->parameter_lua_type = dt_lua_init_type_type(darktable.lua_state.state, type_id);
luaA_struct_type(darktable.lua_state.state, type_id);
dt_lua_register_storage_type(darktable.lua_state.state, storage, type_id);
GList *it = darktable.imageio->plugins_format;
if(!lua_isnoneornil(L, 5))
{
while(it)
{
lua_pushvalue(L, 5);
dt_imageio_module_format_t *format = (dt_imageio_module_format_t *)it->data;
dt_imageio_module_data_t *sdata = storage->get_params(storage);
dt_imageio_module_data_t *fdata = format->get_params(format);
luaA_push_type(L, storage->parameter_lua_type, sdata);
luaA_push_type(L, format->parameter_lua_type, fdata);
format->free_params(format, fdata);
storage->free_params(storage, sdata);
dt_lua_treated_pcall(L,2,1);
int result = lua_toboolean(L, -1);
lua_pop(L, 1);
if(result)
{
data->supported_formats = g_list_prepend(data->supported_formats, format);
}
it = g_list_next(it);
}
}
else
{
// all formats are supported
while(it)
{
dt_imageio_module_format_t *format = (dt_imageio_module_format_t *)it->data;
data->supported_formats = g_list_prepend(data->supported_formats, format);
it = g_list_next(it);
}
}
storage->gui_init(storage);
if(storage->widget) g_object_ref(storage->widget);
dt_imageio_insert_storage(storage);
return 0;
}
/**
* Create a tempfile with the given prefix (e.g. "wireshark").
*
* @param namebuf If not NULL, receives the full path of the temp file.
* Should NOT be freed.
* @param pfx A prefix for the temporary file.
* @param sfx [in] A file extension for the temporary file. NULL can be passed
* if no file extension is needed
* @return The file descriptor of the new tempfile, from mkstemps().
*/
int
create_tempfile(char **namebuf, const char *pfx, const char *sfx)
{
static struct _tf {
char *path;
size_t len;
} tf[MAX_TEMPFILES];
static int idx;
const char *tmp_dir;
int old_umask;
int fd;
time_t current_time;
char timestr[14 + 1];
gchar *tmp_file;
gchar *safe_pfx;
gchar sep[2] = {0, 0};
/* The characters in "delimiters" come from:
* http://msdn.microsoft.com/en-us/library/aa365247%28VS.85%29.aspx.
* Add to the list as necessary for other OS's.
*/
const gchar *delimiters = "<>:\"/\\|?*"
"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a"
"\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14"
"\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f";
/* Sanitize the pfx to resolve bug 7877 */
safe_pfx = g_strdup(pfx);
safe_pfx = g_strdelimit(safe_pfx, delimiters, '-');
idx = (idx + 1) % MAX_TEMPFILES;
/*
* Allocate the buffer if it's not already allocated.
*/
if (tf[idx].path == NULL) {
tf[idx].len = INITIAL_PATH_SIZE;
tf[idx].path = (char *)g_malloc(tf[idx].len);
}
tmp_dir = g_get_tmp_dir();
#ifdef _WIN32
_tzset();
#endif
current_time = time(NULL);
/* We trust the OS not to return a time before the Epoch. */
strftime(timestr, sizeof(timestr), "%Y%m%d%H%M%S", localtime(¤t_time));
sep[0] = G_DIR_SEPARATOR;
tmp_file = g_strconcat(tmp_dir, sep, safe_pfx, "_", timestr, "_", TMP_FILE_SUFFIX, sfx, NULL);
g_free(safe_pfx);
if (strlen(tmp_file) > tf[idx].len) {
tf[idx].len = strlen(tmp_file) + 1;
tf[idx].path = (char *)g_realloc(tf[idx].path, tf[idx].len);
}
g_strlcpy(tf[idx].path, tmp_file, tf[idx].len);
g_free(tmp_file);
if (namebuf) {
*namebuf = tf[idx].path;
}
/* The Single UNIX Specification doesn't say that "mkstemps()"
creates the temporary file with mode rw-------, so we
won't assume that all UNIXes will do so; instead, we set
the umask to 0077 to take away all group and other
permissions, attempt to create the file, and then put
the umask back. */
old_umask = ws_umask(0077);
fd = mkstemps(tf[idx].path, sfx ? (int) strlen(sfx) : 0);
ws_umask(old_umask);
return fd;
}
// internal function: to avoid exif blob reading + 8-bit byteorder flag + high-quality override
int dt_imageio_export_with_flags(
const uint32_t imgid,
const char *filename,
dt_imageio_module_format_t *format,
dt_imageio_module_data_t *format_params,
const int32_t ignore_exif,
const int32_t display_byteorder,
const gboolean high_quality,
const int32_t thumbnail_export,
const char *filter,
const gboolean copy_metadata,
dt_imageio_module_storage_t *storage,
dt_imageio_module_data_t *storage_params)
{
dt_develop_t dev;
dt_dev_init(&dev, 0);
dt_mipmap_buffer_t buf;
if(thumbnail_export && dt_conf_get_bool("plugins/lighttable/low_quality_thumbnails"))
dt_mipmap_cache_read_get(darktable.mipmap_cache, &buf, imgid, DT_MIPMAP_F, DT_MIPMAP_BLOCKING);
else
dt_mipmap_cache_read_get(darktable.mipmap_cache, &buf, imgid, DT_MIPMAP_FULL, DT_MIPMAP_BLOCKING);
dt_dev_load_image(&dev, imgid);
const dt_image_t *img = &dev.image_storage;
const int wd = img->width;
const int ht = img->height;
int res = 0;
dt_times_t start;
dt_get_times(&start);
dt_dev_pixelpipe_t pipe;
res = thumbnail_export ? dt_dev_pixelpipe_init_thumbnail(&pipe, wd, ht) : dt_dev_pixelpipe_init_export(&pipe, wd, ht, format->levels(format_params));
if(!res)
{
dt_control_log(_("failed to allocate memory for %s, please lower the threads used for export or buy more memory."), thumbnail_export ? C_("noun", "thumbnail export") : C_("noun", "export"));
dt_dev_cleanup(&dev);
dt_mipmap_cache_read_release(darktable.mipmap_cache, &buf);
return 1;
}
if(!buf.buf)
{
dt_control_log(_("image `%s' is not available!"), img->filename);
dt_mipmap_cache_read_release(darktable.mipmap_cache, &buf);
dt_dev_cleanup(&dev);
return 1;
}
// If a style is to be applied during export, add the iop params into the history
if (!thumbnail_export && format_params->style[0] != '\0')
{
GList *stls;
GList *modules = dev.iop;
dt_iop_module_t *m = NULL;
if ((stls=dt_styles_get_item_list(format_params->style, TRUE, -1)) == 0)
{
dt_control_log(_("cannot find the style '%s' to apply during export."), format_params->style);
dt_dev_cleanup(&dev);
dt_mipmap_cache_read_release(darktable.mipmap_cache, &buf);
return 1;
}
// Add each params
while (stls)
{
dt_style_item_t *s = (dt_style_item_t *) stls->data;
modules = dev.iop;
while (modules)
{
m = (dt_iop_module_t *)modules->data;
// since the name in the style is returned with a possible multi-name, just check the start of the name
if (strncmp(m->op, s->name, strlen(m->op)) == 0)
{
dt_dev_history_item_t *h = malloc(sizeof(dt_dev_history_item_t));
h->params = s->params;
h->blend_params = s->blendop_params;
h->enabled = s->enabled;
h->module = m;
h->multi_priority = 1;
g_strlcpy(h->multi_name, "", sizeof(h->multi_name));
if(m->legacy_params && (s->module_version != m->version()))
{
void *new_params = malloc(m->params_size);
m->legacy_params (m, h->params, s->module_version, new_params, labs(m->version()));
free (h->params);
h->params = new_params;
}
dev.history_end++;
dev.history = g_list_append(dev.history, h);
break;
}
modules = g_list_next(modules);
}
stls = g_list_next(stls);
}
}
dt_dev_pixelpipe_set_input(&pipe, &dev, (float *)buf.buf, buf.width, buf.height, 1.0);
dt_dev_pixelpipe_create_nodes(&pipe, &dev);
dt_dev_pixelpipe_synch_all(&pipe, &dev);
dt_dev_pixelpipe_get_dimensions(&pipe, &dev, pipe.iwidth, pipe.iheight, &pipe.processed_width, &pipe.processed_height);
if(filter)
{
if(!strncmp(filter, "pre:", 4))
dt_dev_pixelpipe_disable_after(&pipe, filter+4);
if(!strncmp(filter, "post:", 5))
dt_dev_pixelpipe_disable_before(&pipe, filter+5);
}
dt_show_times(&start, "[export] creating pixelpipe", NULL);
// find output color profile for this image:
int sRGB = 1;
gchar *overprofile = dt_conf_get_string("plugins/lighttable/export/iccprofile");
if(overprofile && !strcmp(overprofile, "sRGB"))
{
sRGB = 1;
}
else if(!overprofile || !strcmp(overprofile, "image"))
{
GList *modules = dev.iop;
dt_iop_module_t *colorout = NULL;
while (modules)
{
colorout = (dt_iop_module_t *)modules->data;
if(colorout->get_p && strcmp(colorout->op, "colorout") == 0)
{
const char *iccprofile = colorout->get_p(colorout->params, "iccprofile");
if(!strcmp(iccprofile, "sRGB")) sRGB = 1;
else sRGB = 0;
}
modules = g_list_next(modules);
}
}
else
{
sRGB = 0;
}
g_free(overprofile);
// get only once at the beginning, in case the user changes it on the way:
const gboolean high_quality_processing = ((format_params->max_width == 0 || format_params->max_width >= pipe.processed_width ) &&
(format_params->max_height == 0 || format_params->max_height >= pipe.processed_height)) ? FALSE :
high_quality;
const int width = high_quality_processing ? 0 : format_params->max_width;
const int height = high_quality_processing ? 0 : format_params->max_height;
const double scalex = width > 0 ? fminf(width /(double)pipe.processed_width, 1.0) : 1.0;
const double scaley = height > 0 ? fminf(height/(double)pipe.processed_height, 1.0) : 1.0;
const double scale = fminf(scalex, scaley);
int processed_width = scale*pipe.processed_width + .5f;
int processed_height = scale*pipe.processed_height + .5f;
const int bpp = format->bpp(format_params);
// downsampling done last, if high quality processing was requested:
uint8_t *outbuf = pipe.backbuf;
uint8_t *moutbuf = NULL; // keep track of alloc'ed memory
dt_get_times(&start);
if(high_quality_processing)
{
dt_dev_pixelpipe_process_no_gamma(&pipe, &dev, 0, 0, processed_width, processed_height, scale);
const double scalex = format_params->max_width > 0 ? fminf(format_params->max_width /(double)pipe.processed_width, 1.0) : 1.0;
const double scaley = format_params->max_height > 0 ? fminf(format_params->max_height/(double)pipe.processed_height, 1.0) : 1.0;
const double scale = fminf(scalex, scaley);
processed_width = scale*pipe.processed_width + .5f;
processed_height = scale*pipe.processed_height + .5f;
moutbuf = (uint8_t *)dt_alloc_align(64, (size_t)sizeof(float)*processed_width*processed_height*4);
outbuf = moutbuf;
// now downscale into the new buffer:
dt_iop_roi_t roi_in, roi_out;
roi_in.x = roi_in.y = roi_out.x = roi_out.y = 0;
roi_in.scale = 1.0;
roi_out.scale = scale;
roi_in.width = pipe.processed_width;
roi_in.height = pipe.processed_height;
roi_out.width = processed_width;
roi_out.height = processed_height;
dt_iop_clip_and_zoom((float *)outbuf, (float *)pipe.backbuf, &roi_out, &roi_in, processed_width, pipe.processed_width);
}
else
{
// do the processing (8-bit with special treatment, to make sure we can use openmp further down):
if(bpp == 8)
dt_dev_pixelpipe_process(&pipe, &dev, 0, 0, processed_width, processed_height, scale);
else
dt_dev_pixelpipe_process_no_gamma(&pipe, &dev, 0, 0, processed_width, processed_height, scale);
outbuf = pipe.backbuf;
}
dt_show_times(&start, thumbnail_export ? "[dev_process_thumbnail] pixel pipeline processing" : "[dev_process_export] pixel pipeline processing", NULL);
// downconversion to low-precision formats:
if(bpp == 8)
{
if(display_byteorder)
{
if(high_quality_processing)
{
const float *const inbuf = (float *)outbuf;
for(size_t k=0; k<(size_t)processed_width*processed_height; k++)
{
// convert in place, this is unfortunately very serial..
const uint8_t r = CLAMP(inbuf[4*k+2]*0xff, 0, 0xff);
const uint8_t g = CLAMP(inbuf[4*k+1]*0xff, 0, 0xff);
const uint8_t b = CLAMP(inbuf[4*k+0]*0xff, 0, 0xff);
outbuf[4*k+0] = r;
outbuf[4*k+1] = g;
outbuf[4*k+2] = b;
}
}
// else processing output was 8-bit already, and no need to swap order
}
else // need to flip
{
// ldr output: char
if(high_quality_processing)
{
const float *const inbuf = (float *)outbuf;
for(size_t k=0; k<(size_t)processed_width*processed_height; k++)
{
// convert in place, this is unfortunately very serial..
const uint8_t r = CLAMP(inbuf[4*k+0]*0xff, 0, 0xff);
const uint8_t g = CLAMP(inbuf[4*k+1]*0xff, 0, 0xff);
const uint8_t b = CLAMP(inbuf[4*k+2]*0xff, 0, 0xff);
outbuf[4*k+0] = r;
outbuf[4*k+1] = g;
outbuf[4*k+2] = b;
}
}
else
{ // !display_byteorder, need to swap:
uint8_t *const buf8 = pipe.backbuf;
#ifdef _OPENMP
#pragma omp parallel for default(none) shared(processed_width, processed_height) schedule(static)
#endif
// just flip byte order
for(size_t k=0; k<(size_t)processed_width*processed_height; k++)
{
uint8_t tmp = buf8[4*k+0];
buf8[4*k+0] = buf8[4*k+2];
buf8[4*k+2] = tmp;
}
}
}
}
else if(bpp == 16)
{
// uint16_t per color channel
float *buff = (float *) outbuf;
uint16_t *buf16 = (uint16_t *)outbuf;
for(int y=0; y<processed_height; y++) for(int x=0; x<processed_width ; x++)
{
// convert in place
const size_t k = (size_t)processed_width*y + x;
for(int i=0; i<3; i++) buf16[4*k+i] = CLAMP(buff[4*k+i]*0x10000, 0, 0xffff);
}
}
// else output float, no further harm done to the pixels :)
format_params->width = processed_width;
format_params->height = processed_height;
if(!ignore_exif)
{
int length;
uint8_t exif_profile[65535]; // C++ alloc'ed buffer is uncool, so we waste some bits here.
char pathname[PATH_MAX];
gboolean from_cache = TRUE;
dt_image_full_path(imgid, pathname, sizeof(pathname), &from_cache);
// last param is dng mode, it's false here
length = dt_exif_read_blob(exif_profile, pathname, imgid, sRGB, processed_width, processed_height, 0);
res = format->write_image (format_params, filename, outbuf, exif_profile, length, imgid);
}
else
{
res = format->write_image (format_params, filename, outbuf, NULL, 0, imgid);
}
dt_dev_pixelpipe_cleanup(&pipe);
dt_dev_cleanup(&dev);
dt_mipmap_cache_read_release(darktable.mipmap_cache, &buf);
dt_free_align(moutbuf);
/* now write xmp into that container, if possible */
if(copy_metadata && (format->flags(format_params) & FORMAT_FLAGS_SUPPORT_XMP)) {
dt_exif_xmp_attach(imgid, filename);
// no need to cancel the export if this fail
}
if(!thumbnail_export && strcmp(format->mime(format_params), "memory"))
{
dt_control_signal_raise(darktable.signals,DT_SIGNAL_IMAGE_EXPORT_TMPFILE,imgid,filename,format,format_params,storage,storage_params);
}
return res;
}
int dt_film_import(const char *dirname)
{
int rc;
sqlite3_stmt *stmt;
GError *error = NULL;
/* initialize a film object*/
dt_film_t *film = (dt_film_t *)malloc(sizeof(dt_film_t));
dt_film_init(film);
film->id = -1;
/* lookup if film exists and reuse id */
DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db), "SELECT id FROM main.film_rolls WHERE folder = ?1",
-1, &stmt, NULL);
DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 1, dirname, -1, SQLITE_STATIC);
if(sqlite3_step(stmt) == SQLITE_ROW) film->id = sqlite3_column_int(stmt, 0);
sqlite3_finalize(stmt);
/* if we didn't find an id, lets instantiate a new filmroll */
if(film->id <= 0)
{
char datetime[20];
dt_gettime(datetime, sizeof(datetime));
/* insert a new film roll into database */
DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db),
"INSERT INTO main.film_rolls (id, datetime_accessed, folder) VALUES "
"(NULL, ?1, ?2)",
-1, &stmt, NULL);
DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 1, datetime, -1, SQLITE_STATIC);
DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 2, dirname, -1, SQLITE_STATIC);
rc = sqlite3_step(stmt);
if(rc != SQLITE_DONE)
fprintf(stderr, "[film_import] failed to insert film roll! %s\n",
sqlite3_errmsg(dt_database_get(darktable.db)));
sqlite3_finalize(stmt);
/* requery for filmroll and fetch new id */
DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db), "SELECT id FROM main.film_rolls WHERE folder=?1",
-1, &stmt, NULL);
DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 1, dirname, -1, SQLITE_STATIC);
if(sqlite3_step(stmt) == SQLITE_ROW) film->id = sqlite3_column_int(stmt, 0);
sqlite3_finalize(stmt);
}
/* bail out if we got troubles */
if(film->id <= 0)
{
// if the film is empty => remove it again.
if(dt_film_is_empty(film->id))
{
dt_film_remove(film->id);
}
dt_film_cleanup(film);
free(film);
return 0;
}
// when called without job system running the import will be done synchronously and destroy the film object
int filmid = film->id;
/* at last put import film job on queue */
film->last_loaded = 0;
g_strlcpy(film->dirname, dirname, sizeof(film->dirname));
char *last = &film->dirname[strlen(film->dirname) - 1];
if(*last == '/' && last != film->dirname) *last = '\0'; // remove the closing /, unless it's also the start
film->dir = g_dir_open(film->dirname, 0, &error);
if(error)
{
fprintf(stderr, "[film_import] failed to open directory %s: %s\n", film->dirname, error->message);
g_error_free(error);
dt_film_cleanup(film);
free(film);
return 0;
}
dt_control_add_job(darktable.control, DT_JOB_QUEUE_USER_BG, dt_film_import1_create(film));
return filmid;
}
void commit_params(struct dt_iop_module_t *self, dt_iop_params_t *p1, dt_dev_pixelpipe_t *pipe,
dt_dev_pixelpipe_iop_t *piece)
{
dt_iop_colorout_params_t *p = (dt_iop_colorout_params_t *)p1;
dt_iop_colorout_data_t *d = (dt_iop_colorout_data_t *)piece->data;
const dt_colorspaces_color_profile_type_t over_type = dt_conf_get_int("plugins/lighttable/export/icctype");
gchar *over_filename = dt_conf_get_string("plugins/lighttable/export/iccprofile");
const dt_iop_color_intent_t over_intent = dt_conf_get_int("plugins/lighttable/export/iccintent");
const int force_lcms2 = dt_conf_get_bool("plugins/lighttable/export/force_lcms2");
dt_colorspaces_color_profile_type_t out_type = DT_COLORSPACE_SRGB;
gchar *out_filename = NULL;
dt_iop_color_intent_t out_intent = DT_INTENT_PERCEPTUAL;
const cmsHPROFILE Lab = dt_colorspaces_get_profile(DT_COLORSPACE_LAB, "", DT_PROFILE_DIRECTION_ANY)->profile;
cmsHPROFILE output = NULL;
cmsHPROFILE softproof = NULL;
d->mode = pipe->type == DT_DEV_PIXELPIPE_FULL ? darktable.color_profiles->mode : DT_PROFILE_NORMAL;
if(d->xform)
{
cmsDeleteTransform(d->xform);
d->xform = NULL;
}
d->cmatrix[0] = NAN;
d->lut[0][0] = -1.0f;
d->lut[1][0] = -1.0f;
d->lut[2][0] = -1.0f;
piece->process_cl_ready = 1;
/* if we are exporting then check and set usage of override profile */
if(pipe->type == DT_DEV_PIXELPIPE_EXPORT)
{
if(over_type != DT_COLORSPACE_NONE)
{
p->type = over_type;
g_strlcpy(p->filename, over_filename, sizeof(p->filename));
}
if((unsigned int)over_intent < DT_INTENT_LAST) p->intent = over_intent;
out_type = p->type;
out_filename = p->filename;
out_intent = p->intent;
}
else if(pipe->type == DT_DEV_PIXELPIPE_THUMBNAIL)
{
out_type = dt_mipmap_cache_get_colorspace();
out_filename = (out_type == DT_COLORSPACE_DISPLAY ? darktable.color_profiles->display_filename : "");
out_intent = darktable.color_profiles->display_intent;
}
else
{
/* we are not exporting, using display profile as output */
out_type = darktable.color_profiles->display_type;
out_filename = darktable.color_profiles->display_filename;
out_intent = darktable.color_profiles->display_intent;
}
/*
* Setup transform flags
*/
uint32_t transformFlags = 0;
/* creating output profile */
if(out_type == DT_COLORSPACE_DISPLAY) pthread_rwlock_rdlock(&darktable.color_profiles->xprofile_lock);
const dt_colorspaces_color_profile_t *out_profile
= dt_colorspaces_get_profile(out_type, out_filename, DT_PROFILE_DIRECTION_OUT | DT_PROFILE_DIRECTION_DISPLAY);
output = out_profile->profile;
/* creating softproof profile if softproof is enabled */
if(d->mode != DT_PROFILE_NORMAL && pipe->type == DT_DEV_PIXELPIPE_FULL)
{
softproof = dt_colorspaces_get_profile(darktable.color_profiles->softproof_type,
darktable.color_profiles->softproof_filename,
DT_PROFILE_DIRECTION_OUT | DT_PROFILE_DIRECTION_DISPLAY)->profile;
/* TODO: the use of bpc should be userconfigurable either from module or preference pane */
/* softproof flag and black point compensation */
transformFlags |= cmsFLAGS_SOFTPROOFING | cmsFLAGS_NOCACHE | cmsFLAGS_BLACKPOINTCOMPENSATION;
if(d->mode == DT_PROFILE_GAMUTCHECK) transformFlags |= cmsFLAGS_GAMUTCHECK;
}
/*
* NOTE: theoretically, we should be passing
* UsedDirection = LCMS_USED_AS_PROOF into
* dt_colorspaces_get_matrix_from_output_profile() so that
* dt_colorspaces_get_matrix_from_profile() knows it, but since we do not try
* to use our matrix codepath when softproof is enabled, this seemed redundant.
*/
/* get matrix from profile, if softproofing or high quality exporting always go xform codepath */
if(d->mode != DT_PROFILE_NORMAL || force_lcms2
|| dt_colorspaces_get_matrix_from_output_profile(output, d->cmatrix, d->lut[0], d->lut[1], d->lut[2],
LUT_SAMPLES, out_intent))
{
d->cmatrix[0] = NAN;
piece->process_cl_ready = 0;
d->xform = cmsCreateProofingTransform(Lab, TYPE_LabA_FLT, output, TYPE_RGBA_FLT, softproof,
out_intent, INTENT_RELATIVE_COLORIMETRIC, transformFlags);
}
// user selected a non-supported output profile, check that:
if(!d->xform && isnan(d->cmatrix[0]))
{
dt_control_log(_("unsupported output profile has been replaced by sRGB!"));
fprintf(stderr, "unsupported output profile `%s' has been replaced by sRGB!\n", out_profile->name);
output = dt_colorspaces_get_profile(DT_COLORSPACE_SRGB, "", DT_PROFILE_DIRECTION_OUT)->profile;
if(d->mode != DT_PROFILE_NORMAL
|| dt_colorspaces_get_matrix_from_output_profile(output, d->cmatrix, d->lut[0], d->lut[1],
d->lut[2], LUT_SAMPLES, out_intent))
{
d->cmatrix[0] = NAN;
piece->process_cl_ready = 0;
d->xform = cmsCreateProofingTransform(Lab, TYPE_LabA_FLT, output, TYPE_RGBA_FLT, softproof,
out_intent, INTENT_RELATIVE_COLORIMETRIC, transformFlags);
}
}
if(out_type == DT_COLORSPACE_DISPLAY) pthread_rwlock_unlock(&darktable.color_profiles->xprofile_lock);
// now try to initialize unbounded mode:
// we do extrapolation for input values above 1.0f.
// unfortunately we can only do this if we got the computation
// in our hands, i.e. for the fast builtin-dt-matrix-profile path.
for(int k = 0; k < 3; k++)
{
// omit luts marked as linear (negative as marker)
if(d->lut[k][0] >= 0.0f)
{
const float x[4] = { 0.7f, 0.8f, 0.9f, 1.0f };
const float y[4] = { lerp_lut(d->lut[k], x[0]), lerp_lut(d->lut[k], x[1]), lerp_lut(d->lut[k], x[2]),
lerp_lut(d->lut[k], x[3]) };
dt_iop_estimate_exp(x, y, 4, d->unbounded_coeffs[k]);
}
else
d->unbounded_coeffs[k][0] = -1.0f;
}
g_free(over_filename);
}
/*
* @brief A connection request that did not come from the master.
*/
static void Svc_Connect(void) {
char user_info[MAX_USER_INFO_STRING];
sv_client_t *cl, *client;
int32_t i;
Com_Debug("Svc_Connect()\n");
net_addr_t *addr = &net_from;
const int32_t version = strtol(Cmd_Argv(1), NULL, 0);
// resolve protocol
if (version != PROTOCOL) {
Netchan_OutOfBandPrint(NS_UDP_SERVER, addr, "print\nServer is version %d.\n", PROTOCOL);
return;
}
const uint8_t qport = strtoul(Cmd_Argv(2), NULL, 0);
const uint32_t challenge = strtoul(Cmd_Argv(3), NULL, 0);
// copy user_info, leave room for ip stuffing
g_strlcpy(user_info, Cmd_Argv(4), sizeof(user_info) - 25);
if (*user_info == '\0') { // catch empty user_info
Com_Print("Empty user_info from %s\n", Net_NetaddrToString(addr));
Netchan_OutOfBandPrint(NS_UDP_SERVER, addr, "print\nConnection refused\n");
return;
}
if (strchr(user_info, '\xFF')) { // catch end of message in string exploit
Com_Print("Illegal user_info contained xFF from %s\n", Net_NetaddrToString(addr));
Netchan_OutOfBandPrint(NS_UDP_SERVER, addr, "print\nConnection refused\n");
return;
}
if (strlen(GetUserInfo(user_info, "ip"))) { // catch spoofed ips
Com_Print("Illegal user_info contained ip from %s\n", Net_NetaddrToString(addr));
Netchan_OutOfBandPrint(NS_UDP_SERVER, addr, "print\nConnection refused\n");
return;
}
if (!ValidateUserInfo(user_info)) { // catch otherwise invalid user_info
Com_Print("Invalid user_info from %s\n", Net_NetaddrToString(addr));
Netchan_OutOfBandPrint(NS_UDP_SERVER, addr, "print\nConnection refused\n");
return;
}
// force the ip so the game can filter on it
SetUserInfo(user_info, "ip", Net_NetaddrToString(addr));
// enforce a valid challenge to avoid denial of service attack
for (i = 0; i < MAX_CHALLENGES; i++) {
if (Net_CompareClientNetaddr(addr, &svs.challenges[i].addr)) {
if (challenge == svs.challenges[i].challenge) {
svs.challenges[i].challenge = 0;
break; // good
}
Netchan_OutOfBandPrint(NS_UDP_SERVER, addr, "print\nBad challenge\n");
return;
}
}
if (i == MAX_CHALLENGES) {
Netchan_OutOfBandPrint(NS_UDP_SERVER, addr, "print\nNo challenge for address\n");
return;
}
// resolve the client slot
client = NULL;
// first check for an ungraceful reconnect (client crashed, perhaps)
for (i = 0, cl = svs.clients; i < sv_max_clients->integer; i++, cl++) {
const net_chan_t *ch = &cl->net_chan;
if (cl->state == SV_CLIENT_FREE) // not in use, not interested
continue;
// the base address and either the qport or real port must match
if (Net_CompareClientNetaddr(addr, &ch->remote_address)) {
if (addr->port == ch->remote_address.port || qport == ch->qport) {
client = cl;
break;
}
}
}
// otherwise, treat as a fresh connect to a new slot
if (!client) {
for (i = 0, cl = svs.clients; i < sv_max_clients->integer; i++, cl++) {
if (cl->state == SV_CLIENT_FREE && !cl->edict->ai) { // we have a free one
client = cl;
break;
}
}
}
// no soup for you, next!!
if (!client) {
Netchan_OutOfBandPrint(NS_UDP_SERVER, addr, "print\nServer is full\n");
Com_Debug("Rejected a connection\n");
return;
}
// give the game a chance to reject this connection or modify the user_info
if (!(svs.game->ClientConnect(client->edict, user_info))) {
const char *rejmsg = GetUserInfo(user_info, "rejmsg");
if (strlen(rejmsg)) {
Netchan_OutOfBandPrint(NS_UDP_SERVER, addr, "print\n%s\nConnection refused\n", rejmsg);
} else {
Netchan_OutOfBandPrint(NS_UDP_SERVER, addr, "print\nConnection refused\n");
}
Com_Debug("Game rejected a connection\n");
return;
}
// parse some info from the info strings
g_strlcpy(client->user_info, user_info, sizeof(client->user_info));
Sv_UserInfoChanged(client);
// send the connect packet to the client
Netchan_OutOfBandPrint(NS_UDP_SERVER, addr, "client_connect %s", sv_download_url->string);
Netchan_Setup(NS_UDP_SERVER, &client->net_chan, addr, qport);
Mem_InitBuffer(&client->datagram.buffer, client->datagram.data, sizeof(client->datagram.data));
client->datagram.buffer.allow_overflow = true;
client->last_message = svs.real_time; // don't timeout
client->state = SV_CLIENT_CONNECTED;
}
/* initialize the tap t38_info and the conversation */
static void
init_t38_info_conv(packet_info *pinfo)
{
/* tap info */
t38_info_current++;
if (t38_info_current==MAX_T38_MESSAGES_IN_PACKET) {
t38_info_current=0;
}
t38_info = &t38_info_arr[t38_info_current];
t38_info->seq_num = 0;
t38_info->type_msg = 0;
t38_info->data_value = 0;
t38_info->t30ind_value =0;
t38_info->setup_frame_number = 0;
t38_info->Data_Field_field_type_value = 0;
t38_info->desc[0] = '\0';
t38_info->desc_comment[0] = '\0';
t38_info->time_first_t4_data = 0;
t38_info->frame_num_first_t4_data = 0;
/*
p_t38_packet_conv hold the conversation info in each of the packets.
p_t38_conv hold the conversation info used to reassemble the HDLC packets, and also the Setup info (e.g SDP)
If we already have p_t38_packet_conv in the packet, it means we already reassembled the HDLC packets, so we don't
need to use p_t38_conv
*/
p_t38_packet_conv = NULL;
p_t38_conv = NULL;
/* Use existing packet info if available */
p_t38_packet_conv = p_get_proto_data(pinfo->fd, proto_t38);
/* find the conversation used for Reassemble and Setup Info */
p_conv = find_conversation(pinfo->fd->num, &pinfo->net_dst, &pinfo->net_src,
pinfo->ptype,
pinfo->destport, pinfo->srcport, NO_ADDR_B | NO_PORT_B);
/* create a conv if it doen't exist */
if (!p_conv) {
p_conv = conversation_new(pinfo->fd->num, &pinfo->net_src, &pinfo->net_dst,
pinfo->ptype, pinfo->srcport, pinfo->destport, NO_ADDR_B | NO_PORT_B);
/* Set dissector */
conversation_set_dissector(p_conv, t38_udp_handle);
}
if (!p_t38_packet_conv) {
p_t38_conv = conversation_get_proto_data(p_conv, proto_t38);
/* create the conversation if it doen't exist */
if (!p_t38_conv) {
p_t38_conv = se_alloc(sizeof(t38_conv));
p_t38_conv->setup_method[0] = '\0';
p_t38_conv->setup_frame_number = 0;
p_t38_conv->src_t38_info.reass_ID = 0;
p_t38_conv->src_t38_info.reass_start_seqnum = -1;
p_t38_conv->src_t38_info.reass_data_type = 0;
p_t38_conv->src_t38_info.last_seqnum = -1;
p_t38_conv->src_t38_info.packet_lost = 0;
p_t38_conv->src_t38_info.burst_lost = 0;
p_t38_conv->src_t38_info.time_first_t4_data = 0;
p_t38_conv->dst_t38_info.reass_ID = 0;
p_t38_conv->dst_t38_info.reass_start_seqnum = -1;
p_t38_conv->dst_t38_info.reass_data_type = 0;
p_t38_conv->dst_t38_info.last_seqnum = -1;
p_t38_conv->dst_t38_info.packet_lost = 0;
p_t38_conv->dst_t38_info.burst_lost = 0;
p_t38_conv->dst_t38_info.time_first_t4_data = 0;
conversation_add_proto_data(p_conv, proto_t38, p_t38_conv);
}
/* copy the t38 conversation info to the packet t38 conversation */
p_t38_packet_conv = se_alloc(sizeof(t38_conv));
g_strlcpy(p_t38_packet_conv->setup_method, p_t38_conv->setup_method, MAX_T38_SETUP_METHOD_SIZE);
p_t38_packet_conv->setup_frame_number = p_t38_conv->setup_frame_number;
memcpy(&(p_t38_packet_conv->src_t38_info), &(p_t38_conv->src_t38_info), sizeof(t38_conv_info));
memcpy(&(p_t38_packet_conv->dst_t38_info), &(p_t38_conv->dst_t38_info), sizeof(t38_conv_info));
p_add_proto_data(pinfo->fd, proto_t38, p_t38_packet_conv);
}
if (ADDRESSES_EQUAL(&p_conv->key_ptr->addr1, &pinfo->net_src)) {
p_t38_conv_info = &(p_t38_conv->src_t38_info);
p_t38_packet_conv_info = &(p_t38_packet_conv->src_t38_info);
} else {
p_t38_conv_info = &(p_t38_conv->dst_t38_info);
p_t38_packet_conv_info = &(p_t38_packet_conv->dst_t38_info);
}
/* update t38_info */
t38_info->setup_frame_number = p_t38_packet_conv->setup_frame_number;
}
char *
msn_message_gen_payload(MsnMessage *msg, size_t *ret_size)
{
GList *l;
char *n, *base, *end;
int len;
size_t body_len;
const void *body;
g_return_val_if_fail(msg != NULL, NULL);
len = MSN_BUF_LEN;
base = n = end = g_malloc(len + 1);
end += len;
/* Standard header. */
if (msg->charset == NULL)
{
g_snprintf(n, len,
"MIME-Version: 1.0\r\n"
"Content-Type: %s\r\n",
msg->content_type);
}
else
{
g_snprintf(n, len,
"MIME-Version: 1.0\r\n"
"Content-Type: %s; charset=%s\r\n",
msg->content_type, msg->charset);
}
n += strlen(n);
for (l = msg->attr_list; l != NULL; l = l->next)
{
const char *key;
const char *value;
key = l->data;
value = msn_message_get_attr(msg, key);
g_snprintf(n, end - n, "%s: %s\r\n", key, value);
n += strlen(n);
}
n += g_strlcpy(n, "\r\n", end - n);
body = msn_message_get_bin_data(msg, &body_len);
if (msg->msnslp_message)
{
MsnSlpHeader header;
MsnSlpFooter footer;
header.session_id = GUINT32_TO_LE(msg->msnslp_header.session_id);
header.id = GUINT32_TO_LE(msg->msnslp_header.id);
header.offset = GUINT64_TO_LE(msg->msnslp_header.offset);
header.total_size = GUINT64_TO_LE(msg->msnslp_header.total_size);
header.length = GUINT32_TO_LE(msg->msnslp_header.length);
header.flags = GUINT32_TO_LE(msg->msnslp_header.flags);
header.ack_id = GUINT32_TO_LE(msg->msnslp_header.ack_id);
header.ack_sub_id = GUINT32_TO_LE(msg->msnslp_header.ack_sub_id);
header.ack_size = GUINT64_TO_LE(msg->msnslp_header.ack_size);
memcpy(n, &header, 48);
n += 48;
if (body != NULL)
{
memcpy(n, body, body_len);
n += body_len;
}
footer.value = GUINT32_TO_BE(msg->msnslp_footer.value);
memcpy(n, &footer, 4);
n += 4;
}
else
{
if (body != NULL)
{
memcpy(n, body, body_len);
n += body_len;
}
}
if (ret_size != NULL)
{
*ret_size = n - base;
if (*ret_size > 1664)
*ret_size = 1664;
}
return base;
}
/**
* Try to connect to the list of nodes given by in following form:
*
* list = <node> | <node>, 1*<node>
* port = 1..65535
* hostname = 1*[a-zA-Z0-9.-]
* node = hostname [":" <port>]
* | <IPv4 address>[":" <port>]
* | <IPv6 address>
* | "[" <IPv6 address> "]:" <port>
* peer = ["tls:"]["g2:"]<node>
*
* If the port is omitted, the default port (GTA_PORT: 6346) is used.
* The case-insensitive prefix "tls:" requests a TLS (encrypted) connection.
*/
void
nodes_gui_common_connect_by_name(const gchar *line)
{
const gchar *q;
g_assert(line);
q = line;
while ('\0' != *q) {
const gchar *endptr, *hostname;
size_t hostname_len;
host_addr_t addr;
guint32 flags;
guint16 port;
bool g2;
q = skip_ascii_spaces(q);
if (',' == *q) {
q++;
continue;
}
addr = zero_host_addr;
port = GTA_PORT;
flags = SOCK_F_FORCE;
endptr = NULL;
hostname = NULL;
hostname_len = 0;
endptr = is_strcaseprefix(q, "tls:");
if (endptr) {
flags |= SOCK_F_TLS;
q = endptr;
}
endptr = is_strcaseprefix(q, "g2:");
if (endptr) {
g2 = TRUE;
q = endptr;
} else {
g2 = FALSE;
}
if (!string_to_host_or_addr(q, &endptr, &addr)) {
g_message("expected hostname or IP address");
break;
}
if (!is_host_addr(addr)) {
hostname = q;
hostname_len = endptr - q;
}
q = endptr;
if (':' == *q) {
gint error;
port = parse_uint16(&q[1], &endptr, 10, &error);
if (error || 0 == port) {
g_message("cannot parse port");
break;
}
q = skip_ascii_spaces(endptr);
} else {
q = skip_ascii_spaces(endptr);
if ('\0' != *q && ',' != *q) {
g_message("expected \",\" or \":\"");
break;
}
}
if (!hostname) {
if (g2) {
guc_node_g2_add(addr, port, flags);
} else {
guc_node_add(addr, port, flags);
}
} else {
struct add_node_context *ctx;
gchar *p;
if ('\0' == hostname[hostname_len]) {
p = NULL;
} else {
size_t n = 1 + hostname_len;
g_assert(n > hostname_len);
p = halloc(n);
g_strlcpy(p, hostname, n);
hostname = p;
}
WALLOC(ctx);
ctx->port = port;
ctx->flags = flags;
ctx->g2 = g2;
guc_adns_resolve(hostname, add_node_helper, ctx);
HFREE_NULL(p);
}
}
}
/* Set up an T38 conversation */
void t38_add_address(packet_info *pinfo,
address *addr, int port,
int other_port,
const gchar *setup_method, guint32 setup_frame_number)
{
address null_addr;
conversation_t* p_conv;
t38_conv* p_conv_data = NULL;
/*
* If this isn't the first time this packet has been processed,
* we've already done this work, so we don't need to do it
* again.
*/
if (pinfo->fd->flags.visited)
{
return;
}
SET_ADDRESS(&null_addr, AT_NONE, 0, NULL);
/*
* Check if the ip address and port combination is not
* already registered as a conversation.
*/
p_conv = find_conversation( setup_frame_number, addr, &null_addr, PT_UDP, port, other_port,
NO_ADDR_B | (!other_port ? NO_PORT_B : 0));
/*
* If not, create a new conversation.
*/
if ( !p_conv || p_conv->setup_frame != setup_frame_number) {
p_conv = conversation_new( setup_frame_number, addr, &null_addr, PT_UDP,
(guint32)port, (guint32)other_port,
NO_ADDR2 | (!other_port ? NO_PORT2 : 0));
}
/* Set dissector */
conversation_set_dissector(p_conv, t38_udp_handle);
/*
* Check if the conversation has data associated with it.
*/
p_conv_data = conversation_get_proto_data(p_conv, proto_t38);
/*
* If not, add a new data item.
*/
if ( ! p_conv_data ) {
/* Create conversation data */
p_conv_data = se_alloc(sizeof(t38_conv));
conversation_add_proto_data(p_conv, proto_t38, p_conv_data);
}
/*
* Update the conversation data.
*/
g_strlcpy(p_conv_data->setup_method, setup_method, MAX_T38_SETUP_METHOD_SIZE);
p_conv_data->setup_frame_number = setup_frame_number;
p_conv_data->src_t38_info.reass_ID = 0;
p_conv_data->src_t38_info.reass_start_seqnum = -1;
p_conv_data->src_t38_info.reass_data_type = 0;
p_conv_data->src_t38_info.last_seqnum = -1;
p_conv_data->src_t38_info.packet_lost = 0;
p_conv_data->src_t38_info.burst_lost = 0;
p_conv_data->src_t38_info.time_first_t4_data = 0;
p_conv_data->dst_t38_info.reass_ID = 0;
p_conv_data->dst_t38_info.reass_start_seqnum = -1;
p_conv_data->dst_t38_info.reass_data_type = 0;
p_conv_data->dst_t38_info.last_seqnum = -1;
p_conv_data->dst_t38_info.packet_lost = 0;
p_conv_data->dst_t38_info.burst_lost = 0;
p_conv_data->dst_t38_info.time_first_t4_data = 0;
}
void gui_init(struct dt_iop_module_t *self)
{
const int force_lcms2 = dt_conf_get_bool("plugins/lighttable/export/force_lcms2");
self->gui_data = calloc(1, sizeof(dt_iop_colorout_gui_data_t));
dt_iop_colorout_gui_data_t *g = (dt_iop_colorout_gui_data_t *)self->gui_data;
g->profiles = NULL;
dt_iop_color_profile_t *prof = (dt_iop_color_profile_t *)g_malloc0(sizeof(dt_iop_color_profile_t));
g_strlcpy(prof->filename, "sRGB", sizeof(prof->filename));
g_strlcpy(prof->name, "sRGB", sizeof(prof->name));
int pos;
int display_pos;
prof->pos = 0;
prof->display_pos = 0;
g->profiles = g_list_append(g->profiles, prof);
prof = (dt_iop_color_profile_t *)g_malloc0(sizeof(dt_iop_color_profile_t));
g_strlcpy(prof->filename, "adobergb", sizeof(prof->filename));
g_strlcpy(prof->name, "adobergb", sizeof(prof->name));
prof->pos = 1;
prof->display_pos = 1;
g->profiles = g_list_append(g->profiles, prof);
prof = (dt_iop_color_profile_t *)g_malloc0(sizeof(dt_iop_color_profile_t));
g_strlcpy(prof->filename, "X profile", sizeof(prof->filename));
g_strlcpy(prof->name, "X profile", sizeof(prof->name));
prof->pos = -1;
prof->display_pos = 2;
g->profiles = g_list_append(g->profiles, prof);
prof = (dt_iop_color_profile_t *)g_malloc0(sizeof(dt_iop_color_profile_t));
g_strlcpy(prof->filename, "linear_rgb", sizeof(prof->filename));
g_strlcpy(prof->name, "linear_rgb", sizeof(prof->name));
pos = prof->pos = 2;
display_pos = prof->display_pos = 3;
g->profiles = g_list_append(g->profiles, prof);
prof = (dt_iop_color_profile_t *)g_malloc0(sizeof(dt_iop_color_profile_t));
g_strlcpy(prof->filename, "linear_rec2020_rgb", sizeof(prof->filename));
g_strlcpy(prof->name, "linear_rec2020_rgb", sizeof(prof->name));
pos = prof->pos = 3;
display_pos = prof->display_pos = 4;
g->profiles = g_list_append(g->profiles, prof);
// read {conf,data}dir/color/out/*.icc
char datadir[PATH_MAX] = { 0 };
char confdir[PATH_MAX] = { 0 };
char dirname[PATH_MAX] = { 0 };
char filename[PATH_MAX] = { 0 };
dt_loc_get_user_config_dir(confdir, sizeof(confdir));
dt_loc_get_datadir(datadir, sizeof(datadir));
snprintf(dirname, sizeof(dirname), "%s/color/out", confdir);
if(!g_file_test(dirname, G_FILE_TEST_IS_DIR)) snprintf(dirname, sizeof(dirname), "%s/color/out", datadir);
cmsHPROFILE tmpprof;
const gchar *d_name;
GDir *dir = g_dir_open(dirname, 0, NULL);
if(dir)
{
while((d_name = g_dir_read_name(dir)))
{
snprintf(filename, sizeof(filename), "%s/%s", dirname, d_name);
tmpprof = cmsOpenProfileFromFile(filename, "r");
if(tmpprof)
{
char *lang = getenv("LANG");
if(!lang) lang = "en_US";
dt_iop_color_profile_t *prof = (dt_iop_color_profile_t *)g_malloc0(sizeof(dt_iop_color_profile_t));
dt_colorspaces_get_profile_name(tmpprof, lang, lang + 3, prof->name, sizeof(prof->name));
g_strlcpy(prof->filename, d_name, sizeof(prof->filename));
prof->pos = ++pos;
prof->display_pos = ++display_pos;
cmsCloseProfile(tmpprof);
g->profiles = g_list_append(g->profiles, prof);
}
}
g_dir_close(dir);
}
self->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_BAUHAUS_SPACE);
// TODO:
g->cbox1 = dt_bauhaus_combobox_new(self);
gtk_box_pack_start(GTK_BOX(self->widget), g->cbox1, TRUE, TRUE, 0);
dt_bauhaus_widget_set_label(g->cbox1, NULL, _("output intent"));
dt_bauhaus_combobox_add(g->cbox1, _("perceptual"));
dt_bauhaus_combobox_add(g->cbox1, _("relative colorimetric"));
dt_bauhaus_combobox_add(g->cbox1, C_("rendering intent", "saturation"));
dt_bauhaus_combobox_add(g->cbox1, _("absolute colorimetric"));
g->cbox4 = dt_bauhaus_combobox_new(self);
dt_bauhaus_widget_set_label(g->cbox4, NULL, _("display intent"));
gtk_box_pack_start(GTK_BOX(self->widget), g->cbox4, TRUE, TRUE, 0);
dt_bauhaus_combobox_add(g->cbox4, _("perceptual"));
dt_bauhaus_combobox_add(g->cbox4, _("relative colorimetric"));
dt_bauhaus_combobox_add(g->cbox4, C_("rendering intent", "saturation"));
dt_bauhaus_combobox_add(g->cbox4, _("absolute colorimetric"));
if(!force_lcms2)
{
gtk_widget_set_no_show_all(g->cbox1, TRUE);
gtk_widget_set_visible(g->cbox1, FALSE);
gtk_widget_set_no_show_all(g->cbox4, TRUE);
gtk_widget_set_visible(g->cbox4, FALSE);
}
g->cbox2 = dt_bauhaus_combobox_new(self);
g->cbox3 = dt_bauhaus_combobox_new(self);
g->cbox5 = dt_bauhaus_combobox_new(self);
dt_bauhaus_widget_set_label(g->cbox2, NULL, _("output profile"));
dt_bauhaus_widget_set_label(g->cbox5, NULL, _("softproof profile"));
dt_bauhaus_widget_set_label(g->cbox3, NULL, _("display profile"));
gtk_box_pack_start(GTK_BOX(self->widget), g->cbox2, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), g->cbox5, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), g->cbox3, TRUE, TRUE, 0);
GList *l = g->profiles;
while(l)
{
dt_iop_color_profile_t *prof = (dt_iop_color_profile_t *)l->data;
if(!strcmp(prof->name, "X profile"))
{
// the system display profile is only suitable for display purposes
dt_bauhaus_combobox_add(g->cbox3, _("system display profile"));
}
else if(!strcmp(prof->name, "linear_rec709_rgb") || !strcmp(prof->name, "linear_rgb"))
{
dt_bauhaus_combobox_add(g->cbox2, _("linear Rec709 RGB"));
dt_bauhaus_combobox_add(g->cbox3, _("linear Rec709 RGB"));
dt_bauhaus_combobox_add(g->cbox5, _("linear Rec709 RGB"));
}
else if(!strcmp(prof->name, "linear_rec2020_rgb"))
{
dt_bauhaus_combobox_add(g->cbox2, _("linear Rec2020 RGB"));
dt_bauhaus_combobox_add(g->cbox3, _("linear Rec2020 RGB"));
dt_bauhaus_combobox_add(g->cbox5, _("linear Rec2020 RGB"));
}
else if(!strcmp(prof->name, "sRGB"))
{
dt_bauhaus_combobox_add(g->cbox2, _("sRGB (web-safe)"));
dt_bauhaus_combobox_add(g->cbox3, _("sRGB (web-safe)"));
dt_bauhaus_combobox_add(g->cbox5, _("sRGB (web-safe)"));
}
else if(!strcmp(prof->name, "adobergb"))
{
dt_bauhaus_combobox_add(g->cbox2, _("Adobe RGB (compatible)"));
dt_bauhaus_combobox_add(g->cbox3, _("Adobe RGB (compatible)"));
dt_bauhaus_combobox_add(g->cbox5, _("Adobe RGB (compatible)"));
}
else
{
dt_bauhaus_combobox_add(g->cbox2, prof->name);
dt_bauhaus_combobox_add(g->cbox3, prof->name);
dt_bauhaus_combobox_add(g->cbox5, prof->name);
}
l = g_list_next(l);
}
char tooltip[1024];
g_object_set(G_OBJECT(g->cbox1), "tooltip-text", _("rendering intent"), (char *)NULL);
snprintf(tooltip, sizeof(tooltip), _("ICC profiles in %s/color/out or %s/color/out"), confdir, datadir);
g_object_set(G_OBJECT(g->cbox2), "tooltip-text", tooltip, (char *)NULL);
snprintf(tooltip, sizeof(tooltip), _("display ICC profiles in %s/color/out or %s/color/out"), confdir,
datadir);
g_object_set(G_OBJECT(g->cbox3), "tooltip-text", tooltip, (char *)NULL);
snprintf(tooltip, sizeof(tooltip), _("softproof ICC profiles in %s/color/out or %s/color/out"), confdir,
datadir);
g_object_set(G_OBJECT(g->cbox5), "tooltip-text", tooltip, (char *)NULL);
g_signal_connect(G_OBJECT(g->cbox1), "value-changed", G_CALLBACK(intent_changed), (gpointer)self);
g_signal_connect(G_OBJECT(g->cbox4), "value-changed", G_CALLBACK(display_intent_changed), (gpointer)self);
g_signal_connect(G_OBJECT(g->cbox2), "value-changed", G_CALLBACK(output_profile_changed), (gpointer)self);
g_signal_connect(G_OBJECT(g->cbox3), "value-changed", G_CALLBACK(display_profile_changed), (gpointer)self);
g_signal_connect(G_OBJECT(g->cbox5), "value-changed", G_CALLBACK(softproof_profile_changed), (gpointer)self);
// reload the profiles when the display profile changed!
dt_control_signal_connect(darktable.signals, DT_SIGNAL_CONTROL_PROFILE_CHANGED,
G_CALLBACK(_signal_profile_changed), self->dev);
}
/* Parsing something like
* <rawMsg
* protocol="Diameter"
* version="1">
* [truncated]010001244000012C01000...
* </rawMsg>
*/
static wtap_open_return_val
write_packet_data(wtap_dumper *wdh, struct wtap_pkthdr *phdr, int *err, gchar **err_info, guint8 *file_buf, time_t start_time, int ms, exported_pdu_info_t *exported_pdu_info)
{
char *curr_pos, *next_pos;
char proto_name_str[16];
int tag_str_len = 0;
int proto_str_len, raw_data_len, pkt_data_len, exp_pdu_tags_len, i, j;
guint8 *packet_buf;
gchar chr;
gint val1, val2;
gboolean port_type_defined = FALSE;
memset(proto_name_str, 0, sizeof(proto_name_str));
/* Extract the protocol name */
curr_pos = strstr(file_buf, "protocol=\"");
if (!curr_pos){
return WTAP_OPEN_ERROR;
}
curr_pos = curr_pos + 10;
next_pos = strstr(curr_pos, "\"");
proto_str_len = (int)(next_pos - curr_pos);
if (proto_str_len > 15){
return WTAP_OPEN_ERROR;
}
g_strlcpy(proto_name_str, curr_pos, proto_str_len+1);
ascii_strdown_inplace(proto_name_str);
/* Do string matching and replace with Wiresharks protocol name */
if (strcmp(proto_name_str, "gtpv2-c") == 0){
/* Change to gtpv2 */
proto_name_str[5] = '\0';
proto_name_str[6] = '\0';
proto_str_len = 5;
}
/* XXX Do we need to check for function="S1" */
if (strcmp(proto_name_str, "nas") == 0){
/* Change to nas-eps_plain */
g_strlcpy(proto_name_str, "nas-eps_plain", 14);
proto_name_str[13] = '\0';
proto_str_len = 13;
}
/* Find the start of the raw data*/
curr_pos = strstr(next_pos, ">") + 1;
next_pos = strstr(next_pos, "<");
raw_data_len = (int)(next_pos - curr_pos);
/* Calculate the space needed for exp pdu tags*/
tag_str_len = (proto_str_len + 3) & 0xfffffffc;
exp_pdu_tags_len = tag_str_len + 4;
if ((exported_pdu_info->precense_flags & EXP_PDU_TAG_IP_SRC_BIT) == EXP_PDU_TAG_IP_SRC_BIT) {
exp_pdu_tags_len += 4 + EXP_PDU_TAG_IPV4_SRC_LEN;
}
if ((exported_pdu_info->precense_flags & EXP_PDU_TAG_SRC_PORT_BIT) == EXP_PDU_TAG_SRC_PORT_BIT) {
if (!port_type_defined) {
exp_pdu_tags_len += 4 + EXP_PDU_TAG_PORT_TYPE_LEN;
port_type_defined = TRUE;
}
exp_pdu_tags_len += 4 + EXP_PDU_TAG_SRC_PORT_LEN;
}
if ((exported_pdu_info->precense_flags & EXP_PDU_TAG_IP_DST_BIT) == EXP_PDU_TAG_IP_DST_BIT) {
exp_pdu_tags_len += 4 + EXP_PDU_TAG_IPV4_DST_LEN;
}
if ((exported_pdu_info->precense_flags & EXP_PDU_TAG_DST_PORT_BIT) == EXP_PDU_TAG_DST_PORT_BIT) {
if (!port_type_defined) {
exp_pdu_tags_len += 4 + EXP_PDU_TAG_PORT_TYPE_LEN;
port_type_defined = TRUE;
}
exp_pdu_tags_len += 4 + EXP_PDU_TAG_SRC_PORT_LEN;
}
port_type_defined = FALSE;
/* Allocate the packet buf */
pkt_data_len = raw_data_len / 2;
packet_buf = (guint8 *)g_malloc0(pkt_data_len + exp_pdu_tags_len +4);
/* Fill packet buff */
packet_buf[0] = 0;
packet_buf[1] = 12; /* EXP_PDU_TAG_PROTO_NAME */
packet_buf[2] = 0;
packet_buf[3] = tag_str_len;
for (i = 4, j = 0; j < tag_str_len; i++, j++){
packet_buf[i] = proto_name_str[j];
}
if ((exported_pdu_info->precense_flags & EXP_PDU_TAG_IP_SRC_BIT) == EXP_PDU_TAG_IP_SRC_BIT) {
packet_buf[i] = 0;
i++;
packet_buf[i] = EXP_PDU_TAG_IPV4_SRC;
i++;
packet_buf[i] = 0;
i++;
packet_buf[i] = EXP_PDU_TAG_IPV4_SRC_LEN; /* tag length */;
i++;
packet_buf[i] = exported_pdu_info->src_ipv4_d1;
i++;
packet_buf[i] = exported_pdu_info->src_ipv4_d2;
i++;
packet_buf[i] = exported_pdu_info->src_ipv4_d3;
i++;
packet_buf[i] = exported_pdu_info->src_ipv4_d4;
i++;
}
if ((exported_pdu_info->precense_flags & EXP_PDU_TAG_SRC_PORT_BIT) == EXP_PDU_TAG_SRC_PORT_BIT) {
if (!port_type_defined) {
port_type_defined = TRUE;
packet_buf[i] = 0;
i++;
packet_buf[i] = EXP_PDU_TAG_PORT_TYPE;
i++;
packet_buf[i] = 0;
i++;
packet_buf[i] = EXP_PDU_TAG_PORT_TYPE_LEN; /* tag length */;
i++;
packet_buf[i] = (exported_pdu_info->ptype & 0xff000000) >> 24;
i++;
packet_buf[i] = (exported_pdu_info->ptype & 0x00ff0000) >> 16;
i++;
packet_buf[i] = (exported_pdu_info->ptype & 0x0000ff00) >> 8;
i++;
packet_buf[i] = (exported_pdu_info->ptype & 0x000000ff);
i++;
}
packet_buf[i] = 0;
i++;
packet_buf[i] = EXP_PDU_TAG_SRC_PORT;
i++;
packet_buf[i] = 0;
i++;
packet_buf[i] = EXP_PDU_TAG_SRC_PORT_LEN; /* tag length */;
i++;
packet_buf[i] = (exported_pdu_info->src_port & 0xff000000) >> 24;
i++;
packet_buf[i] = (exported_pdu_info->src_port & 0x00ff0000) >> 16;
i++;
packet_buf[i] = (exported_pdu_info->src_port & 0x0000ff00) >> 8;
i++;
packet_buf[i] = (exported_pdu_info->src_port & 0x000000ff);
i++;
}
/*
* @brief
*/
static void ParseBrush(entity_t *mapent) {
map_brush_t *b;
int32_t i, j, k;
side_t *side, *s2;
int32_t plane_num;
map_brush_texture_t td;
vec3_t planepts[3];
if (num_map_brushes == MAX_BSP_BRUSHES)
Com_Error(ERR_FATAL, "MAX_BSP_BRUSHES\n");
b = &map_brushes[num_map_brushes];
b->original_sides = &map_brush_sides[num_map_brush_sides];
b->entity_num = num_entities - 1;
b->brush_num = num_map_brushes - mapent->first_brush;
do {
if (!GetToken(true))
break;
if (!g_strcmp0(token, "}"))
break;
if (num_map_brush_sides == MAX_BSP_BRUSH_SIDES)
Com_Error(ERR_FATAL, "MAX_BSP_BRUSH_SIDES\n");
side = &map_brush_sides[num_map_brush_sides];
// read the three point plane definition
for (i = 0; i < 3; i++) {
if (i != 0)
GetToken(true);
if (g_strcmp0(token, "("))
Com_Error(ERR_FATAL, "Parsing brush\n");
for (j = 0; j < 3; j++) {
GetToken(false);
planepts[i][j] = atof(token);
}
GetToken(false);
if (g_strcmp0(token, ")"))
Com_Error(ERR_FATAL, "Parsing brush\n");
}
memset(&td, 0, sizeof(td));
// read the texturedef
GetToken(false);
if (strlen(token) > sizeof(td.name) - 1)
Com_Error(ERR_FATAL, "Texture name \"%s\" is too long.\n", token);
g_strlcpy(td.name, token, sizeof(td.name));
GetToken(false);
td.shift[0] = atoi(token);
GetToken(false);
td.shift[1] = atoi(token);
GetToken(false);
td.rotate = atoi(token);
GetToken(false);
td.scale[0] = atof(token);
GetToken(false);
td.scale[1] = atof(token);
if (TokenAvailable()) {
GetToken(false);
side->contents = atoi(token);
GetToken(false);
side->surf = td.flags = atoi(token);
GetToken(false);
td.value = atoi(token);
} else {
side->contents = CONTENTS_SOLID;
side->surf = td.flags = 0;
td.value = 0;
}
// resolve implicit surface and contents flags
SetImpliedFlags(side, td.name);
// translucent objects are automatically classified as detail
if (side->surf & (SURF_ALPHA_TEST | SURF_BLEND_33 | SURF_BLEND_66))
side->contents |= CONTENTS_DETAIL;
if (side->contents & (CONTENTS_PLAYER_CLIP | CONTENTS_MONSTER_CLIP))
side->contents |= CONTENTS_DETAIL;
if (fulldetail)
side->contents &= ~CONTENTS_DETAIL;
if (!(side->contents & ((LAST_VISIBLE_CONTENTS - 1) | CONTENTS_PLAYER_CLIP
| CONTENTS_MONSTER_CLIP | CONTENTS_MIST)))
side->contents |= CONTENTS_SOLID;
// hints and skips are never detail, and have no content
if (side->surf & (SURF_HINT | SURF_SKIP)) {
side->contents = 0;
side->surf &= ~CONTENTS_DETAIL;
}
// find the plane number
plane_num = PlaneFromPoints(planepts[0], planepts[1], planepts[2]);
if (plane_num == -1) {
Com_Verbose("Entity %i, Brush %i: plane with no normal\n", b->entity_num, b->brush_num);
continue;
}
// see if the plane has been used already
for (k = 0; k < b->num_sides; k++) {
s2 = b->original_sides + k;
if (s2->plane_num == plane_num) {
Com_Verbose("Entity %i, Brush %i: duplicate plane\n", b->entity_num, b->brush_num);
break;
}
if (s2->plane_num == (plane_num ^ 1)) {
Com_Verbose("Entity %i, Brush %i: mirrored plane\n", b->entity_num, b->brush_num);
break;
}
}
if (k != b->num_sides)
continue; // duplicated
// keep this side
side = b->original_sides + b->num_sides;
side->plane_num = plane_num;
side->texinfo = TexinfoForBrushTexture(&map_planes[plane_num], &td, vec3_origin);
// save the td off in case there is an origin brush and we
// have to recalculate the texinfo
map_brush_textures[num_map_brush_sides] = td;
num_map_brush_sides++;
b->num_sides++;
} while (true);
// get the content for the entire brush
b->contents = BrushContents(b);
// allow detail brushes to be removed
if (nodetail && (b->contents & CONTENTS_DETAIL)) {
b->num_sides = 0;
return;
}
// allow water brushes to be removed
if (nowater && (b->contents & MASK_LIQUID)) {
b->num_sides = 0;
return;
}
// create windings for sides and bounds for brush
MakeBrushWindings(b);
// brushes that will not be visible at all will never be
// used as bsp splitters
if (b->contents & (CONTENTS_PLAYER_CLIP | CONTENTS_MONSTER_CLIP)) {
c_clip_brushes++;
for (i = 0; i < b->num_sides; i++)
b->original_sides[i].texinfo = TEXINFO_NODE;
}
// origin brushes are removed, but they set
// the rotation origin for the rest of the brushes
// in the entity. After the entire entity is parsed,
// the plane_nums and texinfos will be adjusted for
// the origin brush
if (b->contents & CONTENTS_ORIGIN) {
char string[32];
vec3_t origin;
if (num_entities == 1) {
Com_Error(ERR_FATAL,
"Entity %i, Brush %i: origin brushes not allowed in world\n",
b->entity_num, b->brush_num);
return;
}
VectorAdd(b->mins, b->maxs, origin);
VectorScale(origin, 0.5, origin);
sprintf(string, "%i %i %i", (int32_t)origin[0], (int32_t)origin[1],
(int32_t)origin[2]);
SetKeyValue(&entities[b->entity_num], "origin", string);
VectorCopy(origin, entities[b->entity_num].origin);
// don't keep this brush
b->num_sides = 0;
return;
}
AddBrushBevels(b);
num_map_brushes++;
mapent->num_brushes++;
}
static void
publisher_policy_start (gpointer user_data,
const gchar *element_name,
const gchar **attribute_names,
const gchar **attribute_values)
{
ParserUserData *pud;
MonoAssemblyBindingInfo *info;
int n;
pud = user_data;
info = pud->info;
if (!strcmp (element_name, "dependentAssembly")) {
info->name = NULL;
info->culture = NULL;
info->has_old_version_bottom = FALSE;
info->has_old_version_top = FALSE;
info->has_new_version = FALSE;
info->is_valid = FALSE;
memset (&info->old_version_bottom, 0, sizeof (info->old_version_bottom));
memset (&info->old_version_top, 0, sizeof (info->old_version_top));
memset (&info->new_version, 0, sizeof (info->new_version));
} if (!strcmp (element_name, "assemblyIdentity")) {
for (n = 0; attribute_names [n]; n++) {
const gchar *attribute_name = attribute_names [n];
if (!strcmp (attribute_name, "name"))
info->name = g_strdup (attribute_values [n]);
else if (!strcmp (attribute_name, "publicKeyToken")) {
if (strlen (attribute_values [n]) == MONO_PUBLIC_KEY_TOKEN_LENGTH - 1)
g_strlcpy ((char *) info->public_key_token, attribute_values [n], MONO_PUBLIC_KEY_TOKEN_LENGTH);
} else if (!strcmp (attribute_name, "culture")) {
if (!strcmp (attribute_values [n], "neutral"))
info->culture = g_strdup ("");
else
info->culture = g_strdup (attribute_values [n]);
}
}
} else if (!strcmp (element_name, "bindingRedirect")) {
for (n = 0; attribute_names [n]; n++) {
const gchar *attribute_name = attribute_names [n];
if (!strcmp (attribute_name, "oldVersion")) {
gchar **numbers, **version, **versions;
gint major, minor, build, revision;
/* Invalid value */
if (!strcmp (attribute_values [n], ""))
return;
versions = g_strsplit (attribute_values [n], "-", 2);
version = g_strsplit (*versions, ".", 4);
/* We assign the values to gint vars to do the checks */
numbers = version;
major = *numbers ? atoi (*numbers++) : -1;
minor = *numbers ? atoi (*numbers++) : -1;
build = *numbers ? atoi (*numbers++) : -1;
revision = *numbers ? atoi (*numbers) : -1;
g_strfreev (version);
if (major < 0 || minor < 0 || build < 0 || revision < 0) {
g_strfreev (versions);
return;
}
info->old_version_bottom.major = major;
info->old_version_bottom.minor = minor;
info->old_version_bottom.build = build;
info->old_version_bottom.revision = revision;
info->has_old_version_bottom = TRUE;
if (!*(versions + 1)) {
g_strfreev (versions);
continue;
}
numbers = version = g_strsplit (*(versions + 1), ".", 4);
major = *numbers ? atoi (*numbers++) : -1;
minor = *numbers ? atoi (*numbers++) : -1;
build = *numbers ? atoi (*numbers++) : -1;
revision = *numbers ? atoi (*numbers) : 1;
g_strfreev (version);
if (major < 0 || minor < 0 || build < 0 || revision < 0) {
g_strfreev (versions);
return;
}
info->old_version_top.major = major;
info->old_version_top.minor = minor;
info->old_version_top.build = build;
info->old_version_top.revision = revision;
info->has_old_version_top = TRUE;
g_strfreev (versions);
} else if (!strcmp (attribute_name, "newVersion")) {
gchar **numbers, **version;
/* Invalid value */
if (!strcmp (attribute_values [n], ""))
return;
numbers = version = g_strsplit (attribute_values [n], ".", 4);
info->new_version.major = *numbers ? atoi (*numbers++) : -1;
info->new_version.minor = *numbers ? atoi (*numbers++) : -1;
info->new_version.build = *numbers ? atoi (*numbers++) : -1;
info->new_version.revision = *numbers ? atoi (*numbers) : -1;
info->has_new_version = TRUE;
g_strfreev (version);
}
}
}
}
/**
* Check the service still exists and start a worker that will
* just perform a TCP-connect test.
*/
static int
_check_tcp_service_task(gpointer udata, GError **error)
{
struct service_info_s *si;
struct namespace_data_s *ns_data;
struct taskdata_checksrv_s *task_data;
TRACE_POSITION();
task_data = udata;
ns_data = g_hash_table_lookup(namespaces, task_data->ns_name);
if (!ns_data) {
task_done(task_data->task_name);
GSETERROR(error, "Namespace unavailable");
return 0;
}
/* if the service does not exists, the task itself is de-scheduled */
if (!(si=g_hash_table_lookup(ns_data->local_services, task_data->srv_key))
&& !(si=g_hash_table_lookup(ns_data->down_services, task_data->srv_key))) {
task_done(task_data->task_name);
task_stop(task_data->task_name);
INFO("Service [%s] does not exist, stopping task [%s]", task_data->srv_key, task_data->task_name);
return 1;
}
/* Now start a worker for this service. The worker has its own session_data,
* without hard reference to the task_t or the namespace_data_t */
do {
int fd = addrinfo_connect_nopoll(&(si->addr), 1000, error);
if (0 > fd) {
GSETERROR(error, "Connection to gridd server failed : (%d) %s",
errno, strerror(errno));
return 0;
}
sock_set_linger(fd, 1, 0);
struct workerdata_checksrv_s *wdata = g_try_malloc0(sizeof(*wdata));
g_strlcpy(wdata->task_name, task_data->task_name, sizeof(wdata->task_name)-1);
g_strlcpy(wdata->ns_name, task_data->ns_name, sizeof(wdata->ns_name)-1);
g_strlcpy(wdata->srv_key, task_data->srv_key, sizeof(wdata->srv_key)-1);
worker_t *worker = g_try_malloc0(sizeof(worker_t));
worker->func = _check_tcp_service_worker_func;
worker->clean = _check_tcp_service_worker_cleaner;
worker->timeout = 1000;
worker->data.sock_timeout = 1000;
worker->data.fd = fd;
worker->data.session = wdata;
if (!add_fd_to_io_scheduler(worker, EPOLLOUT, error)) {
_mark_service_state(task_data->ns_name, wdata->srv_key, FALSE);
task_done(task_data->task_name);
g_free(worker);
g_free(wdata);
GSETERROR(error, "Failed to add socket fd=%d to io_scheduler : %s", fd, strerror(errno));
return 0;
}
TRACE("TCP-connect tried to [%s] for [%s] (fd=%d)", task_data->srv_key, task_data->task_name, fd);
} while (0);
TRACE_POSITION();
return 1;
}
int main(int argc, char *argv[])
{
CtSgwSetDbusEnv();
#if 0//UCI_TEST
CtSgwUCIOptVal_t value1 = {0};
CtSgwUCIOptVal_t value2 = {0};
CtSgwUCIOptVal_t value4 = {0};
uint32_t size = 0, i = 0;
CtSgwUCIOpt_t *opts = NULL;
g_print("------test CtSgwUCIReadOption-------\n");
CtSgwUCIReadOption("demoapp", "global", "hi", value1);
g_print("[%s]\n", value1);
CtSgwUCIReadOption("demoapp", "global", "hello", value2);
g_print("[%s]\n", value2);
g_print("------test CtSgwUCIWriteOption-------\n");
CtSgwUCIWriteOption("demoapp", "global", "shit", "flys");
CtSgwUCIReadOption("demoapp", "global", "shit", value4);
g_print("[%s]\n", value4);
g_print("------test CtSgwUCIReadSection 1-------\n");
CtSgwUCIReadSection("demoapp", NULL, "global", &opts, &size);
g_print("[name size %d]\n", size);
for (i = 0; i < size && opts; i++, opts++) {
g_print("[%d] %s = %s\n", i, opts->name, opts->value);
}
//free(opts);
g_print("------test CtSgwUCIReadSection 2-------\n");
size = 0;
CtSgwUCIReadSection("demoapp", "section", NULL, &opts, &size);
g_print("[section size %d]\n", size);
for (i = 0; i < size && opts; i++, opts++) {
g_print("[%d] %s = %s\n", i, opts->name, opts->value);
}
//free(opts);
#endif
#if APP_TEST
if (argc == 2) {
g_print("test app c-api [%s]\n", argv[1]);
if (g_strcmp0(argv[1], "state") == 0)
{
CtSgwAppStatus_t status;
g_strlcpy(status.name, "demoapp", BUFLEN_32);
CtSgwGetAppStatus(&status);
g_print("name %s, state %s\n", status.name, status.state);
}
if (g_strcmp0(argv[1], "stop") == 0)
CtSgwStopApp("demoapp");
if (g_strcmp0(argv[1], "reload") == 0)
CtSgwReloadApp("demoapp");
if (g_strcmp0(argv[1], "start") == 0)
CtSgwStartApp("demoapp");
if (g_strcmp0(argv[1], "uninstall") == 0)
CtSgwUninstallApp("demoapp");
if (g_strcmp0(argv[1], "install") == 0)
CtSgwInstallApp("/bin/demoapp_1_x86.ipk");
if (g_strcmp0(argv[1], "upgrade") == 0)
CtSgwUpgradeApp("/bin/demoapp_1_x86.ipk");
}
#endif
g_print("all done\n");
return 0;
}
int dt_film_import(const char *dirname)
{
int rc;
sqlite3_stmt *stmt;
/* initialize a film object*/
dt_film_t *film = (dt_film_t *)malloc(sizeof(dt_film_t));
dt_film_init(film);
film->id = -1;
/* lookup if film exists and reuse id */
DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db),
"select id from film_rolls where folder = ?1", -1, &stmt, NULL);
DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 1, dirname, strlen(dirname),
SQLITE_STATIC);
if(sqlite3_step(stmt) == SQLITE_ROW)
film->id = sqlite3_column_int(stmt, 0);
sqlite3_finalize(stmt);
/* if we didn't find a id, lets instansiate a new filmroll */
if(film->id <= 0)
{
char datetime[20];
dt_gettime(datetime);
/* insert a new film roll into database */
DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db),
"insert into film_rolls (id, datetime_accessed, folder) values "
"(null, ?1, ?2)", -1, &stmt, NULL);
DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 1, datetime, strlen(datetime),
SQLITE_STATIC);
DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 2, dirname, strlen(dirname),
SQLITE_STATIC);
rc = sqlite3_step(stmt);
if(rc != SQLITE_DONE)
fprintf(stderr, "[film_import] failed to insert film roll! %s\n",
sqlite3_errmsg(dt_database_get(darktable.db)));
sqlite3_finalize(stmt);
/* requery for filmroll and fetch new id */
DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db),
"select id from film_rolls where folder=?1", -1, &stmt, NULL);
DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 1, dirname, strlen(dirname),
SQLITE_STATIC);
if(sqlite3_step(stmt) == SQLITE_ROW)
film->id = sqlite3_column_int(stmt, 0);
sqlite3_finalize(stmt);
}
/* bail out if we got troubles */
if(film->id <= 0)
{
// if the film is empty => remove it again.
if(dt_film_is_empty(film->id))
{
dt_film_remove(film->id);
}
dt_film_cleanup(film);
free(film);
return 0;
}
/* at last put import film job on queue */
dt_job_t j;
film->last_loaded = 0;
g_strlcpy(film->dirname, dirname, sizeof(film->dirname));
film->dir = g_dir_open(film->dirname, 0, NULL);
dt_film_import1_init(&j, film);
dt_control_add_job(darktable.control, &j);
return film->id;
}
void
display_calendar (guint year, GUI *appGUI)
{
static MESSAGE selected_date[MAX_MONTHS * FULL_YEAR_COLS];
GDate *cdate;
gint calendar_table[MAX_MONTHS * FULL_YEAR_COLS];
guint current_day, current_month, current_year;
guint month;
gint i, idx, day, first_day, days;
gchar tmpbuf[BUFFER_SIZE], tmpbuf2[BUFFER_SIZE];
for (i = 0; i < MAX_MONTHS * FULL_YEAR_COLS; i++) {
calendar_table[i] = -1;
}
cdate = g_date_new ();
g_return_if_fail (cdate != NULL);
for (month = G_DATE_JANUARY; month <= G_DATE_DECEMBER; month++) {
g_date_set_dmy (cdate, 1, month, year);
first_day = g_date_get_weekday (cdate);
days = g_date_get_days_in_month (month, year);
for (i = 1; i <= days; i++) {
calendar_table[(month - 1) * FULL_YEAR_COLS + first_day + i - 2] = i;
}
}
g_date_set_time_t (cdate, time (NULL));
current_day = g_date_get_day (cdate);
current_month = g_date_get_month (cdate);
current_year = g_date_get_year (cdate);
for (month = G_DATE_JANUARY; month <= G_DATE_DECEMBER; month++) {
for (i = 0; i < FULL_YEAR_COLS; i++) {
idx = (month - 1) * FULL_YEAR_COLS + i;
g_signal_handlers_disconnect_by_func (G_OBJECT (appGUI->cal->calendar_buttons[idx]),
G_CALLBACK (select_date_day_cb), &selected_date[idx]);
day = calendar_table[idx];
if (day > 0) {
if (day == current_day && month == current_month && year == current_year) {
g_snprintf (tmpbuf2, BUFFER_SIZE, "<b><u>%2d</u></b>", day);
} else {
g_snprintf (tmpbuf2, BUFFER_SIZE, "%2d", day);
}
if (i % 7 + 1 == G_DATE_SATURDAY || i % 7 + 1 == G_DATE_SUNDAY) {
g_snprintf (tmpbuf, BUFFER_SIZE, "<span foreground='firebrick'>%s</span>", tmpbuf2);
} else if (month % 2 == 0) {
g_snprintf (tmpbuf, BUFFER_SIZE, "<span foreground='medium blue'>%s</span>", tmpbuf2);
} else {
g_strlcpy (tmpbuf, tmpbuf2, BUFFER_SIZE);
}
g_date_set_dmy (cdate, (GDateDay) day, month,
(GDateYear) gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (appGUI->cal->fy_spinbutton)));
selected_date[idx].data = (gpointer) g_date_get_julian (cdate);
selected_date[idx].appGUI = appGUI;
g_signal_connect (G_OBJECT (appGUI->cal->calendar_buttons[idx]), "clicked",
G_CALLBACK (select_date_day_cb), &selected_date[idx]);
gtk_button_set_label (GTK_BUTTON (appGUI->cal->calendar_buttons[idx]), "");
gtk_label_set_markup (GTK_LABEL (GTK_BIN (appGUI->cal->calendar_buttons[idx])->child), tmpbuf);
gtk_widget_show (appGUI->cal->calendar_buttons[idx]);
} else {
gtk_button_set_label (GTK_BUTTON (appGUI->cal->calendar_buttons[idx]), "");
gtk_widget_hide (GTK_WIDGET (appGUI->cal->calendar_buttons[idx]));
}
}
}
g_date_free (cdate);
}
static void
expert_set_info_vformat(packet_info *pinfo, proto_item *pi, int group, int severity, int hf_index, gboolean use_vaformat,
const char *format, va_list ap)
{
char formatted[ITEM_LABEL_LENGTH];
int tap;
expert_info_t *ei;
proto_tree *tree;
proto_item *ti;
if (pinfo == NULL && pi && pi->tree_data) {
pinfo = PTREE_DATA(pi)->pinfo;
}
/* if this packet isn't loaded because of a read filter, don't output anything */
if (pinfo == NULL || pinfo->num == 0) {
return;
}
if (severity > highest_severity) {
highest_severity = severity;
}
/* XXX: can we get rid of these checks and make them programming errors instead now? */
if (pi != NULL && PITEM_FINFO(pi) != NULL) {
expert_set_item_flags(pi, group, severity);
}
if ((pi == NULL) || (PITEM_FINFO(pi) == NULL) ||
((guint)severity >= FI_GET_FLAG(PITEM_FINFO(pi), PI_SEVERITY_MASK))) {
col_add_str(pinfo->cinfo, COL_EXPERT, val_to_str(severity, expert_severity_vals, "Unknown (%u)"));
}
if (use_vaformat) {
g_vsnprintf(formatted, ITEM_LABEL_LENGTH, format, ap);
} else {
g_strlcpy(formatted, format, ITEM_LABEL_LENGTH);
}
tree = expert_create_tree(pi, group, severity, formatted);
if (hf_index == -1) {
/* If no filterable expert info, just add the message */
ti = proto_tree_add_string(tree, hf_expert_msg, NULL, 0, 0, formatted);
PROTO_ITEM_SET_GENERATED(ti);
} else {
/* If filterable expert info, hide the "generic" form of the message,
and generate the formatted filterable expert info */
ti = proto_tree_add_none_format(tree, hf_index, NULL, 0, 0, "%s", formatted);
PROTO_ITEM_SET_GENERATED(ti);
ti = proto_tree_add_string(tree, hf_expert_msg, NULL, 0, 0, formatted);
PROTO_ITEM_SET_HIDDEN(ti);
}
ti = proto_tree_add_uint_format_value(tree, hf_expert_severity, NULL, 0, 0, severity,
"%s", val_to_str_const(severity, expert_severity_vals, "Unknown"));
PROTO_ITEM_SET_GENERATED(ti);
ti = proto_tree_add_uint_format_value(tree, hf_expert_group, NULL, 0, 0, group,
"%s", val_to_str_const(group, expert_group_vals, "Unknown"));
PROTO_ITEM_SET_GENERATED(ti);
tap = have_tap_listener(expert_tap);
if (!tap)
return;
ei = wmem_new(wmem_packet_scope(), expert_info_t);
ei->packet_num = pinfo->num;
ei->group = group;
ei->severity = severity;
ei->hf_index = hf_index;
ei->protocol = pinfo->current_proto;
ei->summary = wmem_strdup(wmem_packet_scope(), formatted);
/* if we have a proto_item (not a faked item), set expert attributes to it */
if (pi != NULL && PITEM_FINFO(pi) != NULL) {
ei->pitem = pi;
}
/* XXX: remove this because we don't have an internal-only function now? */
else {
ei->pitem = NULL;
}
tap_queue_packet(expert_tap, pinfo, ei);
}
// open a raw file, libraw path:
dt_imageio_retval_t
dt_imageio_open_raw(
dt_image_t *img,
const char *filename,
dt_mipmap_cache_allocator_t a)
{
if(!_blacklisted_ext(filename)) fprintf(stderr,"[imageio] '%s' blacklisted extension passed to libraw\n", filename);
if(!img->exif_inited)
(void) dt_exif_read(img, filename);
if(_blacklisted_raw(img->exif_maker, img->exif_model)) return DT_IMAGEIO_FILE_CORRUPTED;
int ret;
libraw_data_t *raw = libraw_init(0);
libraw_processed_image_t *image = NULL;
raw->params.half_size = 0; /* dcraw -h */
raw->params.use_camera_wb = 0;
raw->params.use_auto_wb = 0;
raw->params.med_passes = 0;//img->raw_params.med_passes;
raw->params.no_auto_bright = 1;
// raw->params.filtering_mode |= LIBRAW_FILTERING_NOBLACKS;
// raw->params.document_mode = 2; // no color scaling, no black, no max, no wb..?
raw->params.document_mode = 2; // color scaling (clip,wb,max) and black point, but no demosaic
raw->params.output_color = 0;
raw->params.output_bps = 16;
raw->params.user_flip = -1; // -1 means: use orientation from raw
raw->params.gamm[0] = 1.0;
raw->params.gamm[1] = 1.0;
// raw->params.user_qual = img->raw_params.demosaic_method; // 3: AHD, 2: PPG, 1: VNG
raw->params.user_qual = 0;
// raw->params.four_color_rgb = img->raw_params.four_color_rgb;
raw->params.four_color_rgb = 0;
raw->params.use_camera_matrix = 0;
raw->params.green_matching = 0;
raw->params.highlight = 1;
raw->params.threshold = 0;
// raw->params.auto_bright_thr = img->raw_auto_bright_threshold;
// raw->params.amaze_ca_refine = 0;
raw->params.fbdd_noiserd = 0;
ret = libraw_open_file(raw, filename);
HANDLE_ERRORS(ret, 0);
raw->params.user_qual = 0;
raw->params.half_size = 0;
ret = libraw_unpack(raw);
img->raw_black_level = raw->color.black;
img->raw_white_point = raw->color.maximum;
HANDLE_ERRORS(ret, 1);
ret = libraw_dcraw_process(raw);
// ret = libraw_dcraw_document_mode_processing(raw);
HANDLE_ERRORS(ret, 1);
image = libraw_dcraw_make_mem_image(raw, &ret);
HANDLE_ERRORS(ret, 1);
// fallback for broken exif read in case of phase one H25
if(!strncmp(img->exif_maker, "Phase One", 9))
img->orientation = raw->sizes.flip;
// filters seem only ever to take a useful value after unpack/process
img->filters = raw->idata.filters;
img->bpp = img->filters ? sizeof(uint16_t) : 4*sizeof(float);
img->width = (img->orientation & 4) ? raw->sizes.height : raw->sizes.width;
img->height = (img->orientation & 4) ? raw->sizes.width : raw->sizes.height;
#if 0 // disabled libraw exif data. it's inconsistent with exiv2, we don't want that.
img->exif_iso = raw->other.iso_speed;
img->exif_exposure = raw->other.shutter;
img->exif_aperture = raw->other.aperture;
img->exif_focal_length = raw->other.focal_len;
g_strlcpy(img->exif_maker, raw->idata.make, sizeof(img->exif_maker));
img->exif_maker[sizeof(img->exif_maker) - 1] = 0x0;
g_strlcpy(img->exif_model, raw->idata.model, sizeof(img->exif_model));
img->exif_model[sizeof(img->exif_model) - 1] = 0x0;
dt_gettime_t(img->exif_datetime_taken, raw->other.timestamp);
#endif
void *buf = dt_mipmap_cache_alloc(img, DT_MIPMAP_FULL, a);
if(!buf)
{
libraw_recycle(raw);
libraw_close(raw);
free(image);
return DT_IMAGEIO_CACHE_FULL;
}
if(img->filters)
{
#ifdef _OPENMP
#pragma omp parallel for schedule(static) default(none) shared(img, image, raw, buf)
#endif
for(size_t k=0; k<(size_t)img->width*img->height; k++)
((uint16_t *)buf)[k] = CLAMPS((((uint16_t *)image->data)[k] - raw->color.black)*65535.0f/(float)(raw->color.maximum - raw->color.black), 0, 0xffff);
}
// clean up raw stuff.
libraw_recycle(raw);
libraw_close(raw);
free(image);
raw = NULL;
image = NULL;
if(img->filters)
{
img->flags &= ~DT_IMAGE_LDR;
img->flags &= ~DT_IMAGE_HDR;
img->flags |= DT_IMAGE_RAW;
}
else
{
// ldr dng. it exists :(
img->flags &= ~DT_IMAGE_RAW;
img->flags &= ~DT_IMAGE_HDR;
img->flags |= DT_IMAGE_LDR;
}
return DT_IMAGEIO_OK;
}
int
store (dt_imageio_module_data_t *sdata, const int imgid, dt_imageio_module_format_t *format, dt_imageio_module_data_t *fdata, const int num, const int total)
{
dt_imageio_gallery_t *d = (dt_imageio_gallery_t *)sdata;
char filename[1024]= {0};
char dirname[1024]= {0};
dt_image_full_path(imgid, dirname, 1024);
// we're potentially called in parallel. have sequence number synchronized:
dt_pthread_mutex_lock(&darktable.plugin_threadsafe);
{
char tmp_dir[1024];
dt_variables_expand(d->vp, d->filename, TRUE);
g_strlcpy(tmp_dir, dt_variables_get_result(d->vp), 1024);
// if filenamepattern is a directory just let att ${FILE_NAME} as default..
if ( g_file_test(tmp_dir, G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR) || ((d->filename+strlen(d->filename)-1)[0]=='/' || (d->filename+strlen(d->filename)-1)[0]=='\\') )
snprintf (d->filename+strlen(d->filename), 1024-strlen(d->filename), "/$(FILE_NAME)");
// avoid braindead export which is bound to overwrite at random:
if(total > 1 && !g_strrstr(d->filename, "$"))
{
snprintf(d->filename+strlen(d->filename), 1024-strlen(d->filename), "_$(SEQUENCE)");
}
gchar* fixed_path = dt_util_fix_path(d->filename);
g_strlcpy(d->filename, fixed_path, 1024);
g_free(fixed_path);
d->vp->filename = dirname;
d->vp->jobcode = "export";
d->vp->imgid = imgid;
d->vp->sequence = num;
dt_variables_expand(d->vp, d->filename, TRUE);
g_strlcpy(filename, dt_variables_get_result(d->vp), 1024);
g_strlcpy(dirname, filename, 1024);
const char *ext = format->extension(fdata);
char *c = dirname + strlen(dirname);
for(; c>dirname && *c != '/'; c--);
if(*c == '/') *c = '\0';
if(g_mkdir_with_parents(dirname, 0755))
{
fprintf(stderr, "[imageio_storage_gallery] could not create directory: `%s'!\n", dirname);
dt_control_log(_("could not create directory `%s'!"), dirname);
dt_pthread_mutex_unlock(&darktable.plugin_threadsafe);
return 1;
}
// store away dir.
snprintf(d->cached_dirname, 1024, "%s", dirname);
c = filename + strlen(filename);
for(; c>filename && *c != '.' && *c != '/' ; c--);
if(c <= filename || *c=='/') c = filename + strlen(filename);
sprintf(c,".%s",ext);
// save image to list, in order:
pair_t *pair = malloc(sizeof(pair_t));
char *title = NULL, *description = NULL, *tags = NULL;
GList *res;
res = dt_metadata_get(imgid, "Xmp.dc.title", NULL);
if(res)
{
title = res->data;
g_list_free(res);
}
res = dt_metadata_get(imgid, "Xmp.dc.description", NULL);
if(res)
{
description = res->data;
g_list_free(res);
}
unsigned int count = 0;
res = dt_metadata_get(imgid, "Xmp.dc.subject", &count);
if(res)
{
// don't show the internal tags (darktable|...)
res = g_list_first(res);
GList *iter = res;
while(iter)
{
GList *next = g_list_next(iter);
if(g_str_has_prefix(iter->data, "darktable|"))
{
g_free(iter->data);
res = g_list_delete_link(res, iter);
count--;
}
iter = next;
}
tags = dt_util_glist_to_str(", ", res, count);
}
char relfilename[256], relthumbfilename[256];
c = filename + strlen(filename);
for(; c>filename && *c != '/' ; c--);
if(*c == '/') c++;
if(c <= filename) c = filename;
snprintf(relfilename, 256, "%s", c);
snprintf(relthumbfilename, 256, "%s", relfilename);
c = relthumbfilename + strlen(relthumbfilename);
for(; c>relthumbfilename && *c != '.'; c--);
if(c <= relthumbfilename) c = relthumbfilename + strlen(relthumbfilename);
sprintf(c, "-thumb.%s", ext);
char subfilename[1024], relsubfilename[256];
snprintf(subfilename, 1024, "%s", d->cached_dirname);
char* sc = subfilename + strlen(subfilename);
sprintf(sc, "/img_%d.html", num);
sprintf(relsubfilename, "img_%d.html", num);
snprintf(pair->line, 4096,
"\n"
" <div><a class=\"dia\" rel=\"lightbox[viewer]\" title=\"%s - %s\" href=\"%s\"><span></span><img src=\"%s\" alt=\"img%d\" class=\"img\"/></a>\n"
" <h1>%s</h1>\n"
" %s<br/><span class=\"tags\">%s</span></div>\n", title?title:relfilename, description?description:" ", relfilename, relthumbfilename, num, title?title:" ", description?description:" ", tags?tags:" ");
char next[256];
sprintf(next, "img_%d.html", (num)%total+1);
char prev[256];
sprintf(prev, "img_%d.html", (num==1)?total:num-1);
/* Becomes unecessary with the Lightbox image viewer overlay
FILE* subfile = fopen(subfilename, "wb");
fprintf(subfile,
"<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n"
"<html xmlns=\"http://www.w3.org/1999/xhtml\">\n"
" <head>\n"
" <meta http-equiv=\"Content-type\" content=\"text/html;charset=UTF-8\" />\n"
" <link rel=\"shortcut icon\" href=\"style/favicon.ico\" />\n"
" <link rel=\"stylesheet\" href=\"style/style.css\" type=\"text/css\" />\n"
" <title>%s</title>\n"
" </head>\n"
" <body>\n"
" <div class=\"title\"><a href=\"index.html\">%s</a></div>\n"
" <div class=\"page\">\n"
" <div style=\"width: 692px; max-width: 692px; height: 10px;\">\n"
" <a style=\"float: left;\" href=\"%s\"><h1>prev</h1></a>\n"
" <a style=\"float: right;\"href=\"%s\"><h1>next</h1></a>\n"
" </div>\n"
" <a href=\"%s\"><img src=\"%s\" width=\"692\" class=\"img\"/></a>\n"
" %s<br/><span class=\"tags\">%s</span></div>\n"
" <p style=\"clear:both;\"></p>\n"
" </div>\n"
" <div class=\"footer\">\n"
" created with darktable "PACKAGE_VERSION"\n"
" </div>\n"
" </body>\n"
"</html>\n",
relfilename, title?title:relfilename, prev, next, relfilename, relfilename, description?description:" ", tags?tags:" ");
fclose(subfile);
*/
pair->pos = num;
g_free(title);
g_free(description);
g_free(tags);
d->l = g_list_insert_sorted(d->l, pair, (GCompareFunc)sort_pos);
} // end of critical block
dt_pthread_mutex_unlock(&darktable.plugin_threadsafe);
/* export image to file */
if(dt_imageio_export(imgid, filename, format, fdata) != 0)
{
fprintf(stderr, "[imageio_storage_gallery] could not export to file: `%s'!\n", filename);
dt_control_log(_("could not export to file `%s'!"), filename);
return 1;
}
/* also export thumbnail: */
// write with reduced resolution:
const int max_width = fdata->max_width;
const int max_height = fdata->max_height;
fdata->max_width = 200;
fdata->max_height = 200;
// alter filename with -thumb:
char *c = filename + strlen(filename);
for(; c>filename && *c != '.' && *c != '/' ; c--);
if(c <= filename || *c=='/') c = filename + strlen(filename);
const char *ext = format->extension(fdata);
sprintf(c,"-thumb.%s",ext);
if(dt_imageio_export(imgid, filename, format, fdata) != 0)
{
fprintf(stderr, "[imageio_storage_gallery] could not export to file: `%s'!\n", filename);
dt_control_log(_("could not export to file `%s'!"), filename);
return 1;
}
// restore for next image:
fdata->max_width = max_width;
fdata->max_height = max_height;
printf("[export_job] exported to `%s'\n", filename);
char *trunc = filename + strlen(filename) - 32;
if(trunc < filename) trunc = filename;
dt_control_log(_("%d/%d exported to `%s%s'"), num, total, trunc != filename ? ".." : "", trunc);
return 0;
}
static void sctp_graph_draw(struct sctp_udata *u_data)
{
int length, lwidth;
guint32 distance=5, i, e, sec, w, start, a, j, b;
gint label_width, label_height;
char label_string[15];
gfloat dis;
gboolean write_label = FALSE;
PangoLayout *layout;
GtkAllocation widget_alloc;
cairo_t *cr;
if (u_data->io->x1_tmp_sec == 0 && u_data->io->x1_tmp_usec == 0)
u_data->io->offset = 0;
else
u_data->io->offset = 5;
if (u_data->io->x2_tmp_sec - u_data->io->x1_tmp_sec > 1500)
{
u_data->io->min_x=u_data->io->x1_tmp_sec;
u_data->io->max_x=u_data->io->x2_tmp_sec;
u_data->io->uoff = TRUE;
}
else
{
u_data->io->min_x=((guint32) (u_data->io->x1_tmp_sec*1000000.0))+u_data->io->x1_tmp_usec;
u_data->io->max_x=((guint32) (u_data->io->x2_tmp_sec*1000000.0))+u_data->io->x2_tmp_usec;
u_data->io->uoff = FALSE;
}
u_data->io->tmp_width = u_data->io->max_x - u_data->io->min_x;
if (u_data->dir == 1)
{
if (u_data->io->tmp == FALSE)
{
if (u_data->assoc->sort_tsn1 != NULL)
u_data->io->max_y = u_data->io->tmp_max_tsn1 - u_data->io->tmp_min_tsn1;
else
u_data->io->max_y = 0;
u_data->io->min_y = 0;
}
else
{
u_data->io->max_y = u_data->io->tmp_max_tsn1;
u_data->io->min_y = u_data->io->tmp_min_tsn1;
}
}
else if (u_data->dir == 2)
{
if (u_data->io->tmp == FALSE)
{
if (u_data->assoc->tsn2 != NULL)
u_data->io->max_y = u_data->io->tmp_max_tsn2 - u_data->io->tmp_min_tsn2;
else
u_data->io->max_y = 0;
u_data->io->min_y = 0;
}
else
{
u_data->io->max_y = u_data->io->tmp_max_tsn2;
u_data->io->min_y = u_data->io->tmp_min_tsn2;
}
}
#if GTK_CHECK_VERSION(2,22,0)
cr = cairo_create (u_data->io->surface);
#else
cr = gdk_cairo_create (u_data->io->pixmap);
#endif
cairo_set_source_rgb (cr, 1, 1, 1);
gtk_widget_get_allocation(u_data->io->draw_area, &widget_alloc);
cairo_rectangle (cr,
0,
0,
widget_alloc.width,
widget_alloc.height);
cairo_fill (cr);
cairo_destroy (cr);
/* x_axis */
#if GTK_CHECK_VERSION(2,22,0)
cr = cairo_create (u_data->io->surface);
#else
cr = gdk_cairo_create (u_data->io->pixmap);
#endif
cairo_set_line_width (cr, 1.0);
cairo_move_to(cr, LEFT_BORDER+u_data->io->offset+0.5, u_data->io->surface_height - BOTTOM_BORDER+0.5);
cairo_line_to(cr, u_data->io->surface_width - RIGHT_BORDER + u_data->io->offset+0.5, u_data->io->surface_height - BOTTOM_BORDER+0.5);
cairo_move_to(cr, u_data->io->surface_width - RIGHT_BORDER + u_data->io->offset+0.5, u_data->io->surface_height - BOTTOM_BORDER+0.5);
cairo_line_to(cr, u_data->io->surface_width - RIGHT_BORDER + u_data->io->offset - 5+0.5, u_data->io->surface_height - BOTTOM_BORDER - 5+0.5);
cairo_move_to(cr, u_data->io->surface_width - RIGHT_BORDER + u_data->io->offset + 0.5, u_data->io->surface_height - BOTTOM_BORDER + 0.5);
cairo_line_to(cr, u_data->io->surface_width - RIGHT_BORDER + u_data->io->offset - 5.5, u_data->io->surface_height - BOTTOM_BORDER + 5.5);
cairo_stroke(cr);
cairo_destroy(cr);
u_data->io->axis_width = u_data->io->surface_width - LEFT_BORDER - RIGHT_BORDER - u_data->io->offset;
if(u_data->io->tmp_width>0){
u_data->io->x_interval = (float)((u_data->io->axis_width*1.0)/u_data->io->tmp_width); /*distance in pixels between 2 data points*/
} else {
u_data->io->x_interval = (float)(u_data->io->axis_width);
}
e=0;
if (u_data->io->x_interval < 1)
{
dis = 1 / u_data->io->x_interval;
while (dis >1)
{
dis /= 10;
e++;
}
distance = 1;
for (i=0; i<=e+1; i++)
distance *= 10;
}
else
distance = 5;
g_snprintf(label_string, sizeof(label_string), "%d", 0);
memcpy(label_string,(gchar *)g_locale_to_utf8(label_string, -1 , NULL, NULL, NULL), 15);
layout = gtk_widget_create_pango_layout(u_data->io->draw_area, label_string);
pango_layout_get_pixel_size(layout, &label_width, &label_height);
if (u_data->io->x1_tmp_usec == 0)
sec = u_data->io->x1_tmp_sec;
else
sec = u_data->io->x1_tmp_sec+1;
if (u_data->io->offset != 0)
{
g_snprintf(label_string, sizeof(label_string), "%u", u_data->io->x1_tmp_sec);
memcpy(label_string,(gchar *)g_locale_to_utf8(label_string, -1 , NULL, NULL, NULL), sizeof(label_string));
pango_layout_set_text(layout, label_string, -1);
pango_layout_get_pixel_size(layout, &lwidth, NULL);
#if GTK_CHECK_VERSION(2,22,0)
cr = cairo_create (u_data->io->surface);
#else
cr = gdk_cairo_create (u_data->io->pixmap);
#endif
cairo_move_to (cr, LEFT_BORDER - 25, u_data->io->surface_height - BOTTOM_BORDER + 20);
pango_cairo_show_layout (cr, layout);
cairo_destroy (cr);
cr = NULL;
}
w = (guint32)(500 / (guint32)(distance * u_data->io->x_interval));
if (w == 0)
w = 1;
if (w == 4 || w==3 || w==2)
{
w = 5;
a = distance / 10;
b = (guint32)((u_data->io->min_x/100000))%10; /* start for labels*/
}
else
{
a = distance / 5;
b = 0;
}
if (!u_data->io->uoff)
{
if (a>=1000000)
{
start=u_data->io->min_x/1000000*1000000;
if (a==1000000)
b = 0;
}
else
{
start=u_data->io->min_x/100000;
if (start%2!=0)
start--;
start*=100000;
b = (guint32)((start/100000))%10;
}
}
else
{
start = u_data->io->min_x;
if (start%2!=0)
start--;
b = 0;
}
for (i=start, j=b; i<=u_data->io->max_x; i+=a, j++)
{
if (!u_data->io->uoff)
if (i >= u_data->io->min_x && i % 1000000 != 0)
{
length = 5;
g_snprintf(label_string, sizeof(label_string), "%d", i%1000000);
if (j % w == 0)
{
length = 10;
memcpy(label_string,(gchar *)g_locale_to_utf8(label_string, -1 , NULL, NULL, NULL), sizeof(label_string));
pango_layout_set_text(layout, label_string, -1);
pango_layout_get_pixel_size(layout, &lwidth, NULL);
#if GTK_CHECK_VERSION(2,22,0)
cr = cairo_create (u_data->io->surface);
#else
cr = gdk_cairo_create (u_data->io->pixmap);
#endif
cairo_move_to (cr,
LEFT_BORDER + u_data->io->offset + (i - u_data->io->min_x) * u_data->io->x_interval - lwidth / 2,
u_data->io->surface_height - BOTTOM_BORDER + 10);
pango_cairo_show_layout (cr, layout);
cairo_destroy (cr);
cr = NULL;
}
#if GTK_CHECK_VERSION(2,22,0)
cr = cairo_create (u_data->io->surface);
#else
cr = gdk_cairo_create (u_data->io->pixmap);
#endif
cairo_set_line_width (cr, 1.0);
cairo_move_to(cr,
LEFT_BORDER + u_data->io->offset + (i - u_data->io->min_x) * u_data->io->x_interval + 0.5,
u_data->io->surface_height - BOTTOM_BORDER + 0.5);
cairo_line_to(cr,
LEFT_BORDER + u_data->io->offset + (i - u_data->io->min_x) * u_data->io->x_interval + 0.5,
u_data->io->surface_height - BOTTOM_BORDER + length + 0.5);
cairo_stroke(cr);
cairo_destroy(cr);
}
if (!u_data->io->uoff)
{
if (i%1000000==0 && j%w==0)
{
sec=i/1000000;
write_label = TRUE;
}
}
else
{
if (j%w == 0)
{
sec = i;
write_label = TRUE;
}
}
if (write_label)
{
#if GTK_CHECK_VERSION(2,22,0)
cr = cairo_create (u_data->io->surface);
#else
cr = gdk_cairo_create (u_data->io->pixmap);
#endif
cairo_set_line_width (cr, 1.0);
cairo_move_to(cr,
LEFT_BORDER + u_data->io->offset + (i - u_data->io->min_x) * u_data->io->x_interval + 0.5,
u_data->io->surface_height - BOTTOM_BORDER + 0.5);
cairo_line_to(cr,
LEFT_BORDER + u_data->io->offset + (i - u_data->io->min_x) * u_data->io->x_interval + 0.5,
u_data->io->surface_height - BOTTOM_BORDER + 10 + 0.5);
cairo_stroke(cr);
cairo_destroy(cr);
g_snprintf(label_string, sizeof(label_string), "%d", sec);
memcpy(label_string,(gchar *)g_locale_to_utf8(label_string, -1 , NULL, NULL, NULL), sizeof(label_string));
pango_layout_set_text(layout, label_string, -1);
pango_layout_get_pixel_size(layout, &lwidth, NULL);
#if GTK_CHECK_VERSION(2,22,0)
cr = cairo_create (u_data->io->surface);
#else
cr = gdk_cairo_create (u_data->io->pixmap);
#endif
cairo_move_to (cr,
(LEFT_BORDER + u_data->io->offset + (i - u_data->io->min_x) * u_data->io->x_interval-10),
u_data->io->surface_height - BOTTOM_BORDER + 20);
pango_cairo_show_layout (cr, layout);
cairo_destroy (cr);
cr = NULL;
write_label = FALSE;
}
}
g_strlcpy(label_string, "sec", sizeof(label_string));
memcpy(label_string,(gchar *)g_locale_to_utf8(label_string, -1 , NULL, NULL, NULL), sizeof(label_string));
pango_layout_set_text(layout, label_string, -1);
pango_layout_get_pixel_size(layout, &lwidth, NULL);
#if GTK_CHECK_VERSION(2,22,0)
cr = cairo_create (u_data->io->surface);
#else
cr = gdk_cairo_create (u_data->io->pixmap);
#endif
cairo_move_to (cr,
u_data->io->surface_width - RIGHT_BORDER - 10,
u_data->io->surface_height - BOTTOM_BORDER + 30);
pango_cairo_show_layout (cr, layout);
cairo_destroy (cr);
cr = NULL;
distance = 5;
/* y-axis */
#if GTK_CHECK_VERSION(2,22,0)
cr = cairo_create (u_data->io->surface);
#else
cr = gdk_cairo_create (u_data->io->pixmap);
#endif
cairo_set_line_width (cr, 1.0);
cairo_move_to(cr, LEFT_BORDER + 0.5, TOP_BORDER - u_data->io->offset + 0.5);
cairo_line_to(cr, LEFT_BORDER + 0.5, u_data->io->surface_height - BOTTOM_BORDER - u_data->io->offset + 0.5);
cairo_move_to(cr, LEFT_BORDER + 0.5, TOP_BORDER - u_data->io->offset + 0.5);
cairo_line_to(cr, LEFT_BORDER - 5 + 0.5, TOP_BORDER - u_data->io->offset + 5 + 0.5);
cairo_move_to(cr, LEFT_BORDER + 0.5, TOP_BORDER - u_data->io->offset + 0.5);
cairo_line_to(cr, LEFT_BORDER +5 + 0.5, TOP_BORDER - u_data->io->offset + 5 + 0.5);
cairo_stroke(cr);
cairo_destroy(cr);
u_data->io->y_interval = (float)(((u_data->io->surface_height - TOP_BORDER - BOTTOM_BORDER) * 1.0)/(u_data->io->max_y - u_data->io->min_y));
e = 0;
if (u_data->io->y_interval < 1)
{
dis = 1 / u_data->io->y_interval;
while (dis > 1)
{
dis /= 10;
e++;
}
distance = 1;
for (i=0; i<=e; i++)
distance = distance * 10;
}
else if (u_data->io->y_interval<2)
distance = 10;
if (u_data->io->max_y > 0)
{
for (i=u_data->io->min_y/distance*distance; i<=u_data->io->max_y; i+=distance/5)
{
if (i >= u_data->io->min_y)
{
length = 5;
g_snprintf(label_string, sizeof(label_string), "%d", i);
if (i%distance == 0 || (distance <= 5 && u_data->io->y_interval > 10))
{
length = 10;
memcpy(label_string,(gchar *)g_locale_to_utf8(label_string, -1 , NULL, NULL, NULL), sizeof(label_string));
pango_layout_set_text(layout, label_string, -1);
pango_layout_get_pixel_size(layout, &lwidth, NULL);
#if GTK_CHECK_VERSION(2,22,0)
cr = cairo_create (u_data->io->surface);
#else
cr = gdk_cairo_create (u_data->io->pixmap);
#endif
cairo_move_to (cr,
LEFT_BORDER - length - lwidth - 5,
u_data->io->surface_height - BOTTOM_BORDER - u_data->io->offset - (i - u_data->io->min_y) * u_data->io->y_interval - 3);
pango_cairo_show_layout (cr, layout);
cairo_destroy (cr);
cr = NULL;
}
#if GTK_CHECK_VERSION(2,22,0)
cr = cairo_create (u_data->io->surface);
#else
cr = gdk_cairo_create (u_data->io->pixmap);
#endif
cairo_set_line_width (cr, 1.0);
cairo_move_to(cr,
LEFT_BORDER - length + 0.5,
u_data->io->surface_height - BOTTOM_BORDER - u_data->io->offset - (i - u_data->io->min_y) * u_data->io->y_interval + 0.5);
cairo_line_to(cr,
LEFT_BORDER + 0.5,
u_data->io->surface_height - BOTTOM_BORDER - u_data->io->offset - (i - u_data->io->min_y) * u_data->io->y_interval + 0.5);
cairo_stroke(cr);
cairo_destroy(cr);
}
}
}
else
simple_dialog(ESD_TYPE_INFO, ESD_BTN_OK, "No Data Chunks sent");
g_object_unref(G_OBJECT(layout));
}
int searpc_named_pipe_server_start(SearpcNamedPipeServer *server)
{
#if !defined(WIN32)
int pipe_fd = socket (AF_UNIX, SOCK_STREAM, 0);
const char *un_path = server->path;
if (pipe_fd < 0) {
g_warning ("Failed to create unix socket fd : %s\n",
strerror(errno));
return -1;
}
struct sockaddr_un saddr;
saddr.sun_family = AF_UNIX;
if (strlen(server->path) > sizeof(saddr.sun_path)-1) {
g_warning ("Unix socket path %s is too long."
"Please set or modify UNIX_SOCKET option in ccnet.conf.\n",
un_path);
goto failed;
}
if (g_file_test (un_path, G_FILE_TEST_EXISTS)) {
g_debug ("socket file exists, delete it anyway\n");
if (g_unlink (un_path) < 0) {
g_warning ("delete socket file failed : %s\n", strerror(errno));
goto failed;
}
}
g_strlcpy (saddr.sun_path, un_path, sizeof(saddr.sun_path));
if (bind(pipe_fd, (struct sockaddr *)&saddr, sizeof(saddr)) < 0) {
g_warning ("failed to bind unix socket fd to %s : %s\n",
un_path, strerror(errno));
goto failed;
}
if (listen(pipe_fd, 10) < 0) {
g_warning ("failed to listen to unix socket: %s\n", strerror(errno));
goto failed;
}
if (chmod(un_path, 0700) < 0) {
g_warning ("failed to set permisson for unix socket %s: %s\n",
un_path, strerror(errno));
goto failed;
}
server->pipe_fd = pipe_fd;
#endif // !defined(WIN32)
/* TODO: use glib thread pool */
pthread_create(&server->listener_thread, NULL, named_pipe_listen, server);
return 0;
#if !defined(WIN32)
failed:
close(pipe_fd);
return -1;
#endif
}
int dt_init(int argc, char *argv[], const int init_gui)
{
// make everything go a lot faster.
_MM_SET_FLUSH_ZERO_MODE(_MM_FLUSH_ZERO_ON);
#ifndef __APPLE__
_dt_sigsegv_old_handler = signal(SIGSEGV,&_dt_sigsegv_handler);
#endif
#ifndef __SSE2__
fprintf(stderr, "[dt_init] unfortunately we depend on SSE2 instructions at this time.\n");
fprintf(stderr, "[dt_init] please contribute a backport patch (or buy a newer processor).\n");
return 1;
#endif
#ifdef M_MMAP_THRESHOLD
mallopt(M_MMAP_THRESHOLD,128*1024) ; /* use mmap() for large allocations */
#endif
bindtextdomain (GETTEXT_PACKAGE, DARKTABLE_LOCALEDIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
// init all pointers to 0:
memset(&darktable, 0, sizeof(darktable_t));
darktable.progname = argv[0];
// database
gchar *dbfilename_from_command = NULL;
char *datadir_from_command = NULL;
char *moduledir_from_command = NULL;
char *tmpdir_from_command = NULL;
char *configdir_from_command = NULL;
char *cachedir_from_command = NULL;
darktable.num_openmp_threads = 1;
#ifdef _OPENMP
darktable.num_openmp_threads = omp_get_num_procs();
#endif
darktable.unmuted = 0;
GSList *images_to_load = NULL;
for(int k=1; k<argc; k++)
{
if(argv[k][0] == '-')
{
if(!strcmp(argv[k], "--help"))
{
return usage(argv[0]);
}
if(!strcmp(argv[k], "-h"))
{
return usage(argv[0]);
}
else if(!strcmp(argv[k], "--version"))
{
printf("this is "PACKAGE_STRING"\ncopyright (c) 2009-2013 johannes hanika\n"PACKAGE_BUGREPORT"\n");
return 1;
}
else if(!strcmp(argv[k], "--library"))
{
dbfilename_from_command = argv[++k];
}
else if(!strcmp(argv[k], "--datadir"))
{
datadir_from_command = argv[++k];
}
else if(!strcmp(argv[k], "--moduledir"))
{
moduledir_from_command = argv[++k];
}
else if(!strcmp(argv[k], "--tmpdir"))
{
tmpdir_from_command = argv[++k];
}
else if(!strcmp(argv[k], "--configdir"))
{
configdir_from_command = argv[++k];
}
else if(!strcmp(argv[k], "--cachedir"))
{
cachedir_from_command = argv[++k];
}
else if(!strcmp(argv[k], "--localedir"))
{
bindtextdomain (GETTEXT_PACKAGE, argv[++k]);
}
else if(argv[k][1] == 'd' && argc > k+1)
{
if(!strcmp(argv[k+1], "all")) darktable.unmuted = 0xffffffff; // enable all debug information
else if(!strcmp(argv[k+1], "cache")) darktable.unmuted |= DT_DEBUG_CACHE; // enable debugging for lib/film/cache module
else if(!strcmp(argv[k+1], "control")) darktable.unmuted |= DT_DEBUG_CONTROL; // enable debugging for scheduler module
else if(!strcmp(argv[k+1], "dev")) darktable.unmuted |= DT_DEBUG_DEV; // develop module
else if(!strcmp(argv[k+1], "fswatch")) darktable.unmuted |= DT_DEBUG_FSWATCH; // fswatch module
else if(!strcmp(argv[k+1], "camctl")) darktable.unmuted |= DT_DEBUG_CAMCTL; // camera control module
else if(!strcmp(argv[k+1], "perf")) darktable.unmuted |= DT_DEBUG_PERF; // performance measurements
else if(!strcmp(argv[k+1], "pwstorage")) darktable.unmuted |= DT_DEBUG_PWSTORAGE; // pwstorage module
else if(!strcmp(argv[k+1], "opencl")) darktable.unmuted |= DT_DEBUG_OPENCL; // gpu accel via opencl
else if(!strcmp(argv[k+1], "sql")) darktable.unmuted |= DT_DEBUG_SQL; // SQLite3 queries
else if(!strcmp(argv[k+1], "memory")) darktable.unmuted |= DT_DEBUG_MEMORY; // some stats on mem usage now and then.
else if(!strcmp(argv[k+1], "lighttable")) darktable.unmuted |= DT_DEBUG_LIGHTTABLE; // lighttable related stuff.
else if(!strcmp(argv[k+1], "nan")) darktable.unmuted |= DT_DEBUG_NAN; // check for NANs when processing the pipe.
else return usage(argv[0]);
k ++;
}
else if(argv[k][1] == 't' && argc > k+1)
{
darktable.num_openmp_threads = CLAMP(atol(argv[k+1]), 1, 100);
printf("[dt_init] using %d threads for openmp parallel sections\n", darktable.num_openmp_threads);
k ++;
}
}
#ifndef MAC_INTEGRATION
else
{
images_to_load = g_slist_append(images_to_load, argv[k]);
}
#endif
}
if(darktable.unmuted & DT_DEBUG_MEMORY)
{
fprintf(stderr, "[memory] at startup\n");
dt_print_mem_usage();
}
#ifdef _OPENMP
omp_set_num_threads(darktable.num_openmp_threads);
#endif
dt_loc_init_datadir(datadir_from_command);
dt_loc_init_plugindir(moduledir_from_command);
if(dt_loc_init_tmp_dir(tmpdir_from_command))
{
printf(_("ERROR : invalid temporary directory : %s\n"),darktable.tmpdir);
return usage(argv[0]);
}
dt_loc_init_user_config_dir(configdir_from_command);
dt_loc_init_user_cache_dir(cachedir_from_command);
#if !GLIB_CHECK_VERSION(2, 35, 0)
g_type_init();
#endif
// does not work, as gtk is not inited yet.
// even if it were, it's a super bad idea to invoke gtk stuff from
// a signal handler.
/* check cput caps */
// dt_check_cpu(argc,argv);
#ifdef HAVE_GEGL
char geglpath[DT_MAX_PATH_LEN];
char datadir[DT_MAX_PATH_LEN];
dt_loc_get_datadir(datadir, DT_MAX_PATH_LEN);
snprintf(geglpath, DT_MAX_PATH_LEN, "%s/gegl:/usr/lib/gegl-0.0", datadir);
(void)setenv("GEGL_PATH", geglpath, 1);
gegl_init(&argc, &argv);
#endif
// thread-safe init:
dt_exif_init();
char datadir[DT_MAX_PATH_LEN];
dt_loc_get_user_config_dir (datadir,DT_MAX_PATH_LEN);
char filename[DT_MAX_PATH_LEN];
snprintf(filename, DT_MAX_PATH_LEN, "%s/darktablerc", datadir);
// intialize the config backend. this needs to be done first...
darktable.conf = (dt_conf_t *)malloc(sizeof(dt_conf_t));
memset(darktable.conf, 0, sizeof(dt_conf_t));
dt_conf_init(darktable.conf, filename);
// set the interface language
const gchar* lang = dt_conf_get_string("ui_last/gui_language");
if(lang != NULL && lang[0] != '\0')
{
if(setlocale(LC_ALL, lang) != NULL)
gtk_disable_setlocale();
}
// initialize the database
darktable.db = dt_database_init(dbfilename_from_command);
if(darktable.db == NULL)
{
printf("ERROR : cannot open database\n");
return 1;
}
else if(dt_database_get_already_locked(darktable.db))
{
// send the images to the other instance via dbus
if(images_to_load)
{
GSList *p = images_to_load;
// get a connection!
GDBusConnection *connection = g_bus_get_sync(G_BUS_TYPE_SESSION,NULL, NULL);
while (p != NULL)
{
// make the filename absolute ...
gchar *filename = dt_make_path_absolute((gchar*)p->data);
if(filename == NULL) continue;
// ... and send it to the running instance of darktable
g_dbus_connection_call_sync(connection,
"org.darktable.service",
"/darktable",
"org.darktable.service.Remote",
"Open",
g_variant_new ("(s)", filename),
NULL,
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
NULL);
p = g_slist_next(p);
g_free(filename);
}
g_slist_free(images_to_load);
g_object_unref(connection);
}
return 1;
}
// Initialize the signal system
darktable.signals = dt_control_signal_init();
// Initialize the filesystem watcher
darktable.fswatch=dt_fswatch_new();
#ifdef HAVE_GPHOTO2
// Initialize the camera control
darktable.camctl=dt_camctl_new();
#endif
// get max lighttable thumbnail size:
darktable.thumbnail_width = CLAMPS(dt_conf_get_int("plugins/lighttable/thumbnail_width"), 200, 3000);
darktable.thumbnail_height = CLAMPS(dt_conf_get_int("plugins/lighttable/thumbnail_height"), 200, 3000);
// and make sure it can be mip-mapped all the way from mip4 to mip0
darktable.thumbnail_width /= 16;
darktable.thumbnail_width *= 16;
darktable.thumbnail_height /= 16;
darktable.thumbnail_height *= 16;
// Initialize the password storage engine
darktable.pwstorage=dt_pwstorage_new();
// FIXME: move there into dt_database_t
dt_pthread_mutex_init(&(darktable.db_insert), NULL);
dt_pthread_mutex_init(&(darktable.plugin_threadsafe), NULL);
dt_pthread_mutex_init(&(darktable.capabilities_threadsafe), NULL);
darktable.control = (dt_control_t *)malloc(sizeof(dt_control_t));
memset(darktable.control, 0, sizeof(dt_control_t));
if(init_gui)
{
dt_control_init(darktable.control);
}
else
{
// this is in memory, so schema can't exist yet.
if(dbfilename_from_command && !strcmp(dbfilename_from_command, ":memory:"))
{
dt_control_create_database_schema();
dt_gui_presets_init(); // also init preset db schema.
}
darktable.control->running = 0;
darktable.control->accelerators = NULL;
dt_pthread_mutex_init(&darktable.control->run_mutex, NULL);
}
// initialize collection query
darktable.collection_listeners = NULL;
darktable.collection = dt_collection_new(NULL);
/* initialize sellection */
darktable.selection = dt_selection_new();
/* capabilities set to NULL */
darktable.capabilities = NULL;
#ifdef HAVE_GRAPHICSMAGICK
/* GraphicsMagick init */
InitializeMagick(darktable.progname);
#endif
darktable.opencl = (dt_opencl_t *)malloc(sizeof(dt_opencl_t));
memset(darktable.opencl, 0, sizeof(dt_opencl_t));
dt_opencl_init(darktable.opencl, argc, argv);
darktable.blendop = (dt_blendop_t *)malloc(sizeof(dt_blendop_t));
memset(darktable.blendop, 0, sizeof(dt_blendop_t));
dt_develop_blend_init(darktable.blendop);
darktable.points = (dt_points_t *)malloc(sizeof(dt_points_t));
memset(darktable.points, 0, sizeof(dt_points_t));
dt_points_init(darktable.points, dt_get_num_threads());
// must come before mipmap_cache, because that one will need to access
// image dimensions stored in here:
darktable.image_cache = (dt_image_cache_t *)malloc(sizeof(dt_image_cache_t));
memset(darktable.image_cache, 0, sizeof(dt_image_cache_t));
dt_image_cache_init(darktable.image_cache);
darktable.mipmap_cache = (dt_mipmap_cache_t *)malloc(sizeof(dt_mipmap_cache_t));
memset(darktable.mipmap_cache, 0, sizeof(dt_mipmap_cache_t));
dt_mipmap_cache_init(darktable.mipmap_cache);
// The GUI must be initialized before the views, because the init()
// functions of the views depend on darktable.control->accels_* to register
// their keyboard accelerators
if(init_gui)
{
darktable.gui = (dt_gui_gtk_t *)malloc(sizeof(dt_gui_gtk_t));
memset(darktable.gui,0,sizeof(dt_gui_gtk_t));
if(dt_gui_gtk_init(darktable.gui, argc, argv)) return 1;
dt_bauhaus_init();
}
else darktable.gui = NULL;
darktable.view_manager = (dt_view_manager_t *)malloc(sizeof(dt_view_manager_t));
memset(darktable.view_manager, 0, sizeof(dt_view_manager_t));
dt_view_manager_init(darktable.view_manager);
// load the darkroom mode plugins once:
dt_iop_load_modules_so();
if(init_gui)
{
darktable.lib = (dt_lib_t *)malloc(sizeof(dt_lib_t));
memset(darktable.lib, 0, sizeof(dt_lib_t));
dt_lib_init(darktable.lib);
dt_control_load_config(darktable.control);
g_strlcpy(darktable.control->global_settings.dbname, filename, 512); // overwrite if relocated.
}
darktable.imageio = (dt_imageio_t *)malloc(sizeof(dt_imageio_t));
memset(darktable.imageio, 0, sizeof(dt_imageio_t));
dt_imageio_init(darktable.imageio);
if(init_gui)
{
// Loading the keybindings
char keyfile[DT_MAX_PATH_LEN];
// First dump the default keymapping
snprintf(keyfile, DT_MAX_PATH_LEN, "%s/keyboardrc_default", datadir);
gtk_accel_map_save(keyfile);
// Removing extraneous semi-colons from the default keymap
strip_semicolons_from_keymap(keyfile);
// Then load any modified keys if available
snprintf(keyfile, DT_MAX_PATH_LEN, "%s/keyboardrc", datadir);
if(g_file_test(keyfile, G_FILE_TEST_EXISTS))
gtk_accel_map_load(keyfile);
else
gtk_accel_map_save(keyfile); // Save the default keymap if none is present
// I doubt that connecting to dbus for darktable-cli makes sense
darktable.dbus = dt_dbus_init();
// initialize undo struct
darktable.undo = dt_undo_init();
// load image(s) specified on cmdline
int id = 0;
if(images_to_load)
{
// If only one image is listed, attempt to load it in darkroom
gboolean load_in_dr = (g_slist_next(images_to_load) == NULL);
GSList *p = images_to_load;
while (p != NULL)
{
// don't put these function calls into MAX(), the macro will evaluate
// it twice (and happily deadlock, in this particular case)
int newid = dt_load_from_string((gchar*)p->data, load_in_dr);
id = MAX(id, newid);
p = g_slist_next(p);
}
if (!load_in_dr || id == 0)
dt_ctl_switch_mode_to(DT_LIBRARY);
g_slist_free(images_to_load);
}
else
dt_ctl_switch_mode_to(DT_LIBRARY);
}
/* start the indexer background job */
dt_control_start_indexer();
if(darktable.unmuted & DT_DEBUG_MEMORY)
{
fprintf(stderr, "[memory] after successful startup\n");
dt_print_mem_usage();
}
return 0;
}
void dt_image_cache_allocate(void *data, dt_cache_entry_t *entry)
{
entry->cost = sizeof(dt_image_t);
dt_image_t *img = (dt_image_t *)g_malloc(sizeof(dt_image_t));
dt_image_init(img);
entry->data = img;
// load stuff from db and store in cache:
char *str;
sqlite3_stmt *stmt;
DT_DEBUG_SQLITE3_PREPARE_V2(
dt_database_get(darktable.db),
"SELECT id, group_id, film_id, width, height, filename, maker, model, lens, exposure, "
"aperture, iso, focal_length, datetime_taken, flags, crop, orientation, focus_distance, "
"raw_parameters, longitude, latitude, altitude, color_matrix, colorspace, version, raw_black, "
"raw_maximum FROM main.images WHERE id = ?1",
-1, &stmt, NULL);
DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, entry->key);
if(sqlite3_step(stmt) == SQLITE_ROW)
{
img->id = sqlite3_column_int(stmt, 0);
img->group_id = sqlite3_column_int(stmt, 1);
img->film_id = sqlite3_column_int(stmt, 2);
img->width = sqlite3_column_int(stmt, 3);
img->height = sqlite3_column_int(stmt, 4);
img->crop_x = img->crop_y = img->crop_width = img->crop_height = 0;
img->filename[0] = img->exif_maker[0] = img->exif_model[0] = img->exif_lens[0]
= img->exif_datetime_taken[0] = '\0';
str = (char *)sqlite3_column_text(stmt, 5);
if(str) g_strlcpy(img->filename, str, sizeof(img->filename));
str = (char *)sqlite3_column_text(stmt, 6);
if(str) g_strlcpy(img->exif_maker, str, sizeof(img->exif_maker));
str = (char *)sqlite3_column_text(stmt, 7);
if(str) g_strlcpy(img->exif_model, str, sizeof(img->exif_model));
str = (char *)sqlite3_column_text(stmt, 8);
if(str) g_strlcpy(img->exif_lens, str, sizeof(img->exif_lens));
img->exif_exposure = sqlite3_column_double(stmt, 9);
img->exif_aperture = sqlite3_column_double(stmt, 10);
img->exif_iso = sqlite3_column_double(stmt, 11);
img->exif_focal_length = sqlite3_column_double(stmt, 12);
str = (char *)sqlite3_column_text(stmt, 13);
if(str) g_strlcpy(img->exif_datetime_taken, str, sizeof(img->exif_datetime_taken));
img->flags = sqlite3_column_int(stmt, 14);
img->loader = LOADER_UNKNOWN;
img->exif_crop = sqlite3_column_double(stmt, 15);
img->orientation = sqlite3_column_int(stmt, 16);
img->exif_focus_distance = sqlite3_column_double(stmt, 17);
if(img->exif_focus_distance >= 0 && img->orientation >= 0) img->exif_inited = 1;
uint32_t tmp = sqlite3_column_int(stmt, 18);
memcpy(&img->legacy_flip, &tmp, sizeof(dt_image_raw_parameters_t));
if(sqlite3_column_type(stmt, 19) == SQLITE_FLOAT)
img->longitude = sqlite3_column_double(stmt, 19);
else
img->longitude = NAN;
if(sqlite3_column_type(stmt, 20) == SQLITE_FLOAT)
img->latitude = sqlite3_column_double(stmt, 20);
else
img->latitude = NAN;
if(sqlite3_column_type(stmt, 21) == SQLITE_FLOAT)
img->elevation = sqlite3_column_double(stmt, 21);
else
img->elevation = NAN;
const void *color_matrix = sqlite3_column_blob(stmt, 22);
if(color_matrix)
memcpy(img->d65_color_matrix, color_matrix, sizeof(img->d65_color_matrix));
else
img->d65_color_matrix[0] = NAN;
g_free(img->profile);
img->profile = NULL;
img->profile_size = 0;
img->colorspace = sqlite3_column_int(stmt, 23);
img->version = sqlite3_column_int(stmt, 24);
img->raw_black_level = sqlite3_column_int(stmt, 25);
for(uint8_t i = 0; i < 4; i++) img->raw_black_level_separate[i] = 0;
img->raw_white_point = sqlite3_column_int(stmt, 26);
// buffer size?
if(img->flags & DT_IMAGE_LDR)
{
img->buf_dsc.channels = 4;
img->buf_dsc.datatype = TYPE_FLOAT;
}
else if(img->flags & DT_IMAGE_HDR)
{
if(img->flags & DT_IMAGE_RAW)
{
img->buf_dsc.channels = 1;
img->buf_dsc.datatype = TYPE_FLOAT;
}
else
{
img->buf_dsc.channels = 4;
img->buf_dsc.datatype = TYPE_FLOAT;
}
}
else
{
// raw
img->buf_dsc.channels = 1;
img->buf_dsc.datatype = TYPE_UINT16;
}
}
else
{
img->id = -1;
fprintf(stderr, "[image_cache_allocate] failed to open image %d from database: %s\n", entry->key,
sqlite3_errmsg(dt_database_get(darktable.db)));
}
sqlite3_finalize(stmt);
img->cache_entry = entry; // init backref
// could downgrade lock write->read on entry->lock if we were using concurrencykit..
dt_image_refresh_makermodel(img);
}
static int store_wrapper(struct dt_imageio_module_storage_t *self, struct dt_imageio_module_data_t *self_data,
const int imgid, dt_imageio_module_format_t *format, dt_imageio_module_data_t *fdata,
const int num, const int total, const gboolean high_quality, const gboolean upscale)
{
/* construct a temporary file name */
char tmpdir[PATH_MAX] = { 0 };
gboolean from_cache = FALSE;
dt_loc_get_tmp_dir(tmpdir, sizeof(tmpdir));
char dirname[PATH_MAX] = { 0 };
dt_image_full_path(imgid, dirname, sizeof(dirname), &from_cache);
dt_image_path_append_version(imgid, dirname, sizeof(dirname));
gchar *filename = g_path_get_basename(dirname);
gchar *end = g_strrstr(filename, ".") + 1;
g_strlcpy(end, format->extension(fdata), sizeof(dirname) - (end - dirname));
gchar *complete_name = g_build_filename(tmpdir, filename, (char *)NULL);
if(dt_imageio_export(imgid, complete_name, format, fdata, high_quality, upscale, FALSE, self, self_data, num, total) != 0)
{
fprintf(stderr, "[%s] could not export to file: `%s'!\n", self->name(self), complete_name);
g_free(complete_name);
g_free(filename);
return 1;
}
lua_storage_t *d = (lua_storage_t *)self_data;
dt_lua_lock();
lua_State *L = darktable.lua_state.state;
push_lua_data(L,d);
dt_lua_goto_subtable(L,"files");
luaA_push(L, dt_lua_image_t, &(imgid));
lua_pushstring(L, complete_name);
lua_settable(L, -3);
lua_pop(L,1);
lua_getfield(L, LUA_REGISTRYINDEX, "dt_lua_storages");
lua_getfield(L, -1, self->plugin_name);
lua_getfield(L, -1, "store");
if(lua_isnil(L, -1))
{
lua_pop(L, 3);
dt_lua_unlock();
g_free(filename);
return 0;
}
luaA_push_type(L, self->parameter_lua_type, self_data);
luaA_push(L, dt_lua_image_t, &imgid);
luaA_push_type(L, format->parameter_lua_type, fdata);
lua_pushstring(L, complete_name);
lua_pushnumber(L, num);
lua_pushnumber(L, total);
lua_pushboolean(L, high_quality);
push_lua_data(L,d);
dt_lua_goto_subtable(L,"extra");
dt_lua_treated_pcall(L,8,0);
lua_pop(L, 2);
dt_lua_unlock();
g_free(filename);
return false;
}
int32_t
dt_image_cache_allocate(void *data, const uint32_t key, int32_t *cost, void **buf)
{
dt_image_cache_t *c = (dt_image_cache_t *)data;
const uint32_t hash = key; // == image id
const uint32_t slot = hash & c->cache.bucket_mask;
*cost = sizeof(dt_image_t);
dt_image_t *img = c->images + slot;
// load stuff from db and store in cache:
char *str;
sqlite3_stmt *stmt;
DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db), "select id, group_id, film_id, width, height, filename, maker, model, lens, exposure, aperture, iso, focal_length, datetime_taken, flags, crop, orientation, focus_distance, raw_parameters, longitude, latitude, color_matrix from images where id = ?1", -1, &stmt, NULL);
DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, key);
if(sqlite3_step(stmt) == SQLITE_ROW)
{
img->id = sqlite3_column_int(stmt, 0);
img->group_id = sqlite3_column_int(stmt, 1);
img->film_id = sqlite3_column_int(stmt, 2);
img->width = sqlite3_column_int(stmt, 3);
img->height = sqlite3_column_int(stmt, 4);
img->filename[0] = img->exif_maker[0] = img->exif_model[0] = img->exif_lens[0] =
img->exif_datetime_taken[0] = '\0';
str = (char *)sqlite3_column_text(stmt, 5);
if(str) g_strlcpy(img->filename, str, 512);
str = (char *)sqlite3_column_text(stmt, 6);
if(str) g_strlcpy(img->exif_maker, str, 32);
str = (char *)sqlite3_column_text(stmt, 7);
if(str) g_strlcpy(img->exif_model, str, 32);
str = (char *)sqlite3_column_text(stmt, 8);
if(str) g_strlcpy(img->exif_lens, str, 52);
img->exif_exposure = sqlite3_column_double(stmt, 9);
img->exif_aperture = sqlite3_column_double(stmt, 10);
img->exif_iso = sqlite3_column_double(stmt, 11);
img->exif_focal_length = sqlite3_column_double(stmt, 12);
str = (char *)sqlite3_column_text(stmt, 13);
if(str) g_strlcpy(img->exif_datetime_taken, str, 20);
img->flags = sqlite3_column_int(stmt, 14);
img->exif_crop = sqlite3_column_double(stmt, 15);
img->orientation = sqlite3_column_int(stmt, 16);
img->exif_focus_distance = sqlite3_column_double(stmt,17);
if(img->exif_focus_distance >= 0 && img->orientation >= 0) img->exif_inited = 1;
uint32_t tmp = sqlite3_column_int(stmt, 18);
memcpy(&img->legacy_flip, &tmp, sizeof(dt_image_raw_parameters_t));
if(sqlite3_column_type(stmt, 19) == SQLITE_FLOAT)
img->longitude = sqlite3_column_double(stmt, 19);
else
img->longitude = NAN;
if(sqlite3_column_type(stmt, 20) == SQLITE_FLOAT)
img->latitude = sqlite3_column_double(stmt, 20);
else
img->latitude = NAN;
const void *color_matrix = sqlite3_column_blob(stmt, 21);
if(color_matrix)
memcpy(img->d65_color_matrix, color_matrix, sizeof(img->d65_color_matrix));
else
img->d65_color_matrix[0] = NAN;
// buffer size?
if(img->flags & DT_IMAGE_LDR)
img->bpp = 4*sizeof(float);
else if(img->flags & DT_IMAGE_HDR)
{
if(img->flags & DT_IMAGE_RAW)
img->bpp = sizeof(float);
else
img->bpp = 4*sizeof(float);
}
else // raw
img->bpp = sizeof(uint16_t);
}
else fprintf(stderr, "[image_cache_allocate] failed to open image from database: %s\n", sqlite3_errmsg(dt_database_get(darktable.db)));
sqlite3_finalize(stmt);
*buf = c->images + slot;
return 0; // no write lock required, we inited it all right here.
}
int
store (dt_imageio_module_storage_t *self, dt_imageio_module_data_t *sdata, const int imgid, dt_imageio_module_format_t *format, dt_imageio_module_data_t *fdata,
const int num, const int total, const gboolean high_quality)
{
disk_t *g = (disk_t *)self->gui_data;
dt_imageio_disk_t *d = (dt_imageio_disk_t *)sdata;
// since we're potentially called in parallel, we should uncheck button as early as possible
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->overwrite_btn), FALSE);
char filename[DT_MAX_PATH_LEN]= {0};
char dirname[DT_MAX_PATH_LEN]= {0};
gboolean from_cache = FALSE;
dt_image_full_path(imgid, dirname, DT_MAX_PATH_LEN, &from_cache);
int fail = 0;
// we're potentially called in parallel. have sequence number synchronized:
dt_pthread_mutex_lock(&darktable.plugin_threadsafe);
{
// if filenamepattern is a directory just let att ${FILE_NAME} as default..
if ( g_file_test(d->filename, G_FILE_TEST_IS_DIR) || ((d->filename+strlen(d->filename))[0]=='/' || (d->filename+strlen(d->filename))[0]=='\\') )
snprintf (d->filename+strlen(d->filename), DT_MAX_PATH_LEN-strlen(d->filename), "$(FILE_NAME)");
// avoid braindead export which is bound to overwrite at random:
if(total > 1 && !g_strrstr(d->filename, "$"))
{
snprintf(d->filename+strlen(d->filename), DT_MAX_PATH_LEN-strlen(d->filename), "_$(SEQUENCE)");
}
gchar* fixed_path = dt_util_fix_path(d->filename);
g_strlcpy(d->filename, fixed_path, DT_MAX_PATH_LEN);
g_free(fixed_path);
d->vp->filename = dirname;
d->vp->jobcode = "export";
d->vp->imgid = imgid;
d->vp->sequence = num;
dt_variables_expand(d->vp, d->filename, TRUE);
g_strlcpy(filename, dt_variables_get_result(d->vp), DT_MAX_PATH_LEN);
g_strlcpy(dirname, filename, DT_MAX_PATH_LEN);
const char *ext = format->extension(fdata);
char *c = dirname + strlen(dirname);
for(; c>dirname && *c != '/'; c--);
if(*c == '/')
{
if(c > dirname) // /.../.../foo
c[0] = '\0';
else // /foo
c[1] = '\0';
}
else if(c == dirname) // foo
{
c[0] = '.';
c[1] = '\0';
}
if(g_mkdir_with_parents(dirname, 0755))
{
fprintf(stderr, "[imageio_storage_disk] could not create directory: `%s'!\n", dirname);
dt_control_log(_("could not create directory `%s'!"), dirname);
fail = 1;
goto failed;
}
if(g_access(dirname, W_OK) != 0)
{
fprintf(stderr, "[imageio_storage_disk] could not write to directory: `%s'!\n", dirname);
dt_control_log(_("could not write to directory `%s'!"), dirname);
fail = 1;
goto failed;
}
c = filename + strlen(filename);
// remove everything after the last '.'. this destroys any file name with dots in it since $(FILE_NAME) already comes without the original extension.
// for(; c>filename && *c != '.' && *c != '/' ; c--);
// if(c <= filename || *c=='/') c = filename + strlen(filename);
sprintf(c,".%s",ext);
/* prevent overwrite of files */
failed:
if (!d->overwrite) {
int seq=1;
if (!fail && g_file_test (filename,G_FILE_TEST_EXISTS))
{
do
{
sprintf(c,"_%.2d.%s",seq,ext);
seq++;
}
while (g_file_test (filename,G_FILE_TEST_EXISTS));
}
}
} // end of critical block
dt_pthread_mutex_unlock(&darktable.plugin_threadsafe);
if(fail) return 1;
/* export image to file */
if(dt_imageio_export(imgid, filename, format, fdata, high_quality) != 0)
{
fprintf(stderr, "[imageio_storage_disk] could not export to file: `%s'!\n", filename);
dt_control_log(_("could not export to file `%s'!"), filename);
return 1;
}
/* now write xmp into that container, if possible */
if((format->flags(fdata) & FORMAT_FLAGS_SUPPORT_XMP) && dt_exif_xmp_attach(imgid, filename) != 0)
{
fprintf(stderr, "[imageio_storage_disk] could not attach xmp data to file: `%s'!\n", filename);
// don't report that one to gui, as some formats (pfm, ppm, exr) just don't support
// writing xmp via exiv2, so it might not be to worry.
return 1;
}
printf("[export_job] exported to `%s'\n", filename);
char *trunc = filename + strlen(filename) - 32;
if(trunc < filename) trunc = filename;
dt_control_log(_("%d/%d exported to `%s%s'"), num, total, trunc != filename ? ".." : "", trunc);
return 0;
}
NiceCandidate * _owr_candidate_to_nice_candidate(OwrCandidate *candidate)
{
OwrCandidatePrivate *priv;
NiceCandidate *nice_candidate;
NiceCandidateType candidate_type;
NiceComponentType component_type;
NiceCandidateTransport transport;
g_return_val_if_fail(candidate, NULL);
priv = candidate->priv;
switch (priv->type) {
case OWR_CANDIDATE_TYPE_HOST:
candidate_type = NICE_CANDIDATE_TYPE_HOST;
break;
case OWR_CANDIDATE_TYPE_SERVER_REFLEXIVE:
candidate_type = NICE_CANDIDATE_TYPE_SERVER_REFLEXIVE;
break;
case OWR_CANDIDATE_TYPE_PEER_REFLEXIVE:
candidate_type = NICE_CANDIDATE_TYPE_PEER_REFLEXIVE;
break;
case OWR_CANDIDATE_TYPE_RELAY:
candidate_type = NICE_CANDIDATE_TYPE_RELAYED;
break;
default:
g_return_val_if_reached(NULL);
}
switch (priv->component_type) {
case OWR_COMPONENT_TYPE_RTP:
component_type = NICE_COMPONENT_TYPE_RTP;
break;
case OWR_COMPONENT_TYPE_RTCP:
component_type = NICE_COMPONENT_TYPE_RTCP;
break;
default:
g_return_val_if_reached(NULL);
}
switch (priv->transport_type) {
case OWR_TRANSPORT_TYPE_UDP:
transport = NICE_CANDIDATE_TRANSPORT_UDP;
break;
case OWR_TRANSPORT_TYPE_TCP_ACTIVE:
transport = NICE_CANDIDATE_TRANSPORT_TCP_ACTIVE;
break;
case OWR_TRANSPORT_TYPE_TCP_PASSIVE:
transport = NICE_CANDIDATE_TRANSPORT_TCP_PASSIVE;
break;
case OWR_TRANSPORT_TYPE_TCP_SO:
transport = NICE_CANDIDATE_TRANSPORT_TCP_SO;
break;
default:
g_return_val_if_reached(NULL);
}
g_return_val_if_fail(priv->address && strlen(priv->address) > 0, NULL);
g_return_val_if_fail(priv->port || transport == NICE_CANDIDATE_TRANSPORT_TCP_ACTIVE, NULL);
nice_candidate = nice_candidate_new(candidate_type);
nice_candidate->transport = NICE_CANDIDATE_TRANSPORT_UDP;
nice_candidate->component_id = component_type;
nice_candidate->transport = transport;
nice_address_set_from_string(&nice_candidate->addr, priv->address);
nice_address_set_port(&nice_candidate->addr, priv->port);
if (priv->base_address && strlen(priv->base_address) > 0)
nice_address_set_from_string(&nice_candidate->base_addr, priv->base_address);
if (priv->base_port)
nice_address_set_port(&nice_candidate->base_addr, priv->base_port);
if (priv->foundation && strlen(priv->foundation) > 0) {
g_strlcpy((gchar *)&nice_candidate->foundation, priv->foundation,
MIN(NICE_CANDIDATE_MAX_FOUNDATION, 1 + strlen(priv->foundation)));
}
nice_candidate->priority = candidate->priv->priority;
if (priv->ufrag && strlen(priv->ufrag) > 0)
nice_candidate->username = g_strdup(priv->ufrag);
if (priv->password && strlen(priv->password) > 0)
nice_candidate->password = g_strdup(priv->password);
return nice_candidate;
}