caddr_t
bif_im_CreateImageBlob (caddr_t * qst, caddr_t * err, state_slot_t ** args)
{
im_env_t env;
char * szMe = "IM CreateImageBlob";
caddr_t res;
long x_size = bif_long_arg (qst, args, 0, szMe);
long y_size = bif_long_arg (qst, args, 1, szMe);
caddr_t bg_color = (caddr_t)bif_string_arg (qst, args, 2, szMe);
caddr_t fmt = (caddr_t)bif_string_arg (qst, args, 3, szMe);
im_init (&env, qst, args, "IM CreateImageBlob");
if (x_size <= 0 || y_size <= 0)
im_leave_with_error (&env, "22023", "IM001", "Negative image size");
if (x_size*y_size > 3333279) /* 10M / 3 color - 54byte */
im_leave_with_error (&env, "22023", "IM001", "Too large image image size requested");
im_set_background (&env, bg_color);
env.ime_status = MagickNewImage (env.ime_magick_wand, x_size, y_size, env.ime_background);
if (env.ime_status == MagickFalse)
im_leave_with_error (&env, "22023", "IM001", "Cannot create image");
env.ime_status = MagickSetImageFormat (env.ime_magick_wand, fmt);
if (env.ime_status == MagickFalse)
im_leave_with_error (&env, "22023", "IM001", "Cannot set image format");
res = im_write (&env);
im_leave (&env);
return res;
}
void
im_env_set_input_blob (im_env_t *env, int in_arg_no)
{
env->ime_input_blob = bif_string_arg (env->ime_qst, env->ime_args, in_arg_no, env->ime_bifname);
env->ime_input_blob_len = bif_long_arg (env->ime_qst, env->ime_args, in_arg_no+1, env->ime_bifname);
im_dbg_printf (("IM %p: %s() set input to blob, %ld bytes declared, %ld bytes actual with dtp %u\n", env, env->ime_bifname, (long)(env->ime_input_blob_len), (long)(box_length (env->ime_input_blob)), (unsigned)(DV_TYPE_OF(env->ime_input_blob))));
}
static caddr_t
bif_mts_usleep(caddr_t* qst, caddr_t * err_ret, state_slot_t ** args)
{
long msec = bif_long_arg (qst, args, 0, "mts_usleep");
Sleep(msec);
return box_num(0);
};
caddr_t
bif_timestampadd (caddr_t * qst, caddr_t * err_ret, state_slot_t ** args)
{
caddr_t res;
ptrlong part = bif_long_arg (qst, args, 0, "timestampadd");
int n = (int) bif_long_arg (qst, args, 1, "timestampadd");
caddr_t dt = bif_date_arg (qst, args, 2, "timestampadd");
int saved_tz = DT_TZ (dt);
GMTIMESTAMP_STRUCT ts;
dt_to_GMTimestamp_struct (dt, &ts);
ts_add (&ts, n, interval_odbc_to_text (part, "timestampadd"));
res = dk_alloc_box (DT_LENGTH, DV_DATETIME);
GMTimestamp_struct_to_dt (&ts, res);
DT_SET_TZ (res, saved_tz);
return res;
}
caddr_t
bif_merge_nasa_tjd_to_datetime (caddr_t * qst, caddr_t * err_ret, state_slot_t ** args)
{
boxint num = bif_long_arg (qst, args, 0, "merge_nasa_tjd_to_datetime");
caddr_t res = dk_alloc_box_zero (DT_LENGTH, DV_DATETIME);
DT_SET_DAY (res, num + NASA_TJD_OFFSET);
if (1 < BOX_ELEMENTS (args))
{
double frac = bif_double_arg (qst, args, 1, "merge_nasa_tjd_to_datetime");
boxint frac_microsec = frac * (60*60*24*1000000.0);
if ((0 > frac_microsec) || (60*60*24*(boxint)(1000000) <= frac_microsec))
sqlr_new_error ("22023", "SR644", "Fraction of julian day should be nonnegative and less than 1");
DT_SET_FRACTION (res, (frac_microsec % 1000000) * 1000);
frac_microsec = frac_microsec / 1000000;
DT_SET_SECOND (res, (frac_microsec % 60));
frac_microsec = frac_microsec / 60;
DT_SET_MINUTE (res, (frac_microsec % 60));
frac_microsec = frac_microsec / 60;
DT_SET_HOUR (res, frac_microsec);
DT_SET_DT_TYPE (res, DT_TYPE_DATETIME);
}
else
DT_SET_DT_TYPE (res, DT_TYPE_DATE);
return res;
}
caddr_t
bif_dateadd (caddr_t * qst, caddr_t * err_ret, state_slot_t ** args)
{
caddr_t res;
caddr_t part = bif_string_arg (qst, args, 0, "dateadd");
boxint n = bif_long_arg (qst, args, 1, "dateadd");
caddr_t dt = bif_date_arg (qst, args, 2, "dateadd");
TIMESTAMP_STRUCT ts;
int dt_type = DT_DT_TYPE (dt);
int year_or_month_tz_tweak = (((!strcmp ("year", part)) || (!strcmp ("month", part))) ? DT_TZ (dt) : 0);
DT_AUDIT_FIELDS (dt);
dt_to_GMTimestamp_struct (dt, &ts);
if (year_or_month_tz_tweak)
ts_add (&ts, year_or_month_tz_tweak, "minute");
ts_add (&ts, n, part);
if (year_or_month_tz_tweak)
ts_add (&ts, -year_or_month_tz_tweak, "minute");
res = dk_alloc_box (DT_LENGTH, DV_DATETIME);
GMTimestamp_struct_to_dt (&ts, res);
DT_SET_TZ (res, DT_TZ (dt));
if (DT_TYPE_DATE == dt_type
&& (0 == stricmp (part, "year") || 0 == stricmp (part, "month") || 0 == stricmp (part, "day")))
DT_SET_DT_TYPE (res, dt_type);
DT_AUDIT_FIELDS (dt);
return res;
}
static caddr_t
bif_mts_set_timeout(caddr_t* qst, caddr_t * err_ret, state_slot_t ** args)
{
long param_timeout =
bif_long_arg (qst, args, 0, "mts_set_timeout");
mts_txn_timeout = param_timeout;
return box_num(0);
};
caddr_t bif_im_CropAndResizeImageBlob(caddr_t * qst, caddr_t * err, state_slot_t ** args)
{
im_env_t env;
caddr_t res;
unsigned long width = bif_long_arg (qst, args, 2, "IM CropAndResizeImageBlob");
unsigned long height = bif_long_arg (qst, args, 3, "IM CropAndResizeImageBlob");
long x = bif_long_arg (qst, args, 4, "IM CropAndResizeImageBlob");
long y = bif_long_arg (qst, args, 5, "IM CropAndResizeImageBlob");
long h_size = bif_long_arg (qst, args, 6, "IM ResizeImageBlob");
long v_size = bif_long_arg (qst, args, 7, "IM ResizeImageBlob");
double blur = bif_double_arg (qst, args, 8, "IM ResizeImageBlob");
long filter = bif_long_arg (qst, args, 9, "IM ResizeImageBlob");
if (filter < 0 || filter > 15)
filter = PointFilter;
im_init (&env, qst, args, "IM CropAndResizeImageBlob");
im_env_set_input_blob (&env, 0);
im_env_set_blob_ext (&env, 10, -1);
im_read (&env);
MagickResetIterator (env.ime_magick_wand);
while (MagickNextImage (env.ime_magick_wand) != MagickFalse)
{
MagickCropImage (env.ime_magick_wand, width, height, x, y);
MagickResizeImage (env.ime_magick_wand, h_size, v_size, filter, blur);
}
res = im_write (&env);
im_leave (&env);
return res;
}
caddr_t
bif_dt_set_tz (caddr_t * qst, caddr_t * err_ret, state_slot_t ** args)
{
caddr_t arg = bif_date_arg (qst, args, 0, "dt_set_tz");
long tz = (long) bif_long_arg (qst, args, 1, "dt_set_tz");
caddr_t res = box_copy (arg);
DT_SET_TZ (res, tz);
return res;
}
caddr_t bif_im_ThumbnailImageFile (caddr_t * qst, caddr_t * err, state_slot_t ** args)
{
im_env_t env;
long v_size = bif_long_arg (qst, args, 1, "IM ThumbnailImageFile");
long h_size = bif_long_arg (qst, args, 2, "IM ThumbnailImageFile");
long filter = bif_long_arg (qst, args, 3, "IM ThumbnailImageFile");
im_init (&env, qst, args, "IM ThumbnailImageFile");
im_env_set_filenames (&env, 0, 4);
im_read (&env);
MagickResetIterator (env.ime_magick_wand);
while (MagickNextImage (env.ime_magick_wand) != MagickFalse)
{
MagickResizeImage (env.ime_magick_wand,v_size, h_size,filter,1.0);
MagickProfileImage (env.ime_magick_wand, "*", NULL, 0);
}
im_write (&env);
im_leave (&env);
return(0);
}
caddr_t bif_im_CropImageFile (caddr_t * qst, caddr_t * err, state_slot_t ** args)
{
im_env_t env;
unsigned long width = (unsigned long) bif_long_arg (qst, args, 1, "IM CropImageFile");
unsigned long height = (unsigned long) bif_long_arg (qst, args, 2, "IM CropImageFile");
long x = bif_long_arg (qst, args, 3, "IM CropImageFile");
long y = bif_long_arg (qst, args, 4, "IM CropImageFile");
im_init (&env, qst, args, "IM CropImageFile");
im_env_set_filenames (&env, 0, 5);
im_read (&env);
MagickResetIterator (env.ime_magick_wand);
while (MagickNextImage (env.ime_magick_wand) != MagickFalse)
{
MagickCropImage (env.ime_magick_wand, width, height, x, y);
}
im_write (&env);
im_leave (&env);
return (0);
}
caddr_t
bif_curdatetime (caddr_t * qst, caddr_t * err_ret, state_slot_t ** args)
{
long fract = 0;
caddr_t res = dk_alloc_box (DT_LENGTH, DV_DATETIME);
dt_now (res);
if (args && BOX_ELEMENTS (args) > 0)
fract = (long) bif_long_arg (qst, args, 0, "curdatetime");
DT_SET_FRACTION (res, fract);
return res;
}
caddr_t
bif_im_AnnotateImageBlob (caddr_t * qst, caddr_t * err, state_slot_t ** args)
{
char * szMe = "IM AnnotateImageBlob";
caddr_t res;
caddr_t blob = (caddr_t)bif_arg (qst, args, 0, szMe);
long blob_size = box_length (blob) - 1;
long x_pos = bif_long_arg (qst, args, 1, szMe);
long y_pos = bif_long_arg (qst, args, 2, szMe);
caddr_t text = bif_string_arg (qst, args, 3, szMe);
int n_args = BOX_ELEMENTS(args);
long angle = n_args > 4 ? bif_long_arg (qst, args, 4, szMe) : 0;
long f_size = n_args > 5 ? bif_long_arg (qst, args, 5, szMe) : 12;
char *text_color = n_args > 6 ? bif_string_arg (qst, args, 6, szMe) : "black" ;
dtp_t dtp = DV_TYPE_OF (blob);
im_env_t env;
im_init (&env, qst, args, "IM AnnotateImageBlob");
if (IS_STRING_DTP (dtp))
blob_size = box_length (blob) - 1;
else if (dtp == DV_BIN)
blob_size = box_length (blob);
else
im_leave_with_error (&env, "22023", "IM001", "AnnotateImageBlob needs string or binary as 1-st argument");
im_env_set_blob_ext (&env, 7, -1);
env.ime_drawing_wand = NewDrawingWand ();
im_read (&env);
im_set_background (&env, text_color);
DrawSetFillColor (env.ime_drawing_wand, env.ime_background);
DrawSetFontSize (env.ime_drawing_wand, f_size);
MagickResetIterator (env.ime_magick_wand);
while (MagickNextImage (env.ime_magick_wand) != MagickFalse)
{
env.ime_status = MagickAnnotateImage (env.ime_magick_wand, env.ime_drawing_wand, x_pos, y_pos, angle, text);
if (env.ime_status == MagickFalse)
im_leave_with_error (&env, "22023", "IM001", "Cannot annotate image");
}
res = im_write (&env);
im_leave (&env);
return res;
}
static caddr_t
bif_mts_connect (caddr_t * qst, caddr_t * err_ret, state_slot_t ** args)
{
/* reconnect? */
long reconnect_fl = bif_long_arg (qst, args, 0, "mts_connect");
if (!mts_connect(reconnect_fl))
{
sqlr_error ("MX000", "connection to MS DTC failed");
}
return box_num(0);
};
caddr_t bif_im_ResizeImageFile (caddr_t * qst, caddr_t * err, state_slot_t ** args)
{
im_env_t env;
long v_size = bif_long_arg (qst, args, 1, "IM ResizeImageFile");
long h_size = bif_long_arg (qst, args, 2, "IM ResizeImageFile");
double blur = bif_double_arg (qst, args, 3, "IM ResizeImageFile");
long filter = bif_long_arg (qst, args, 4, "IM ResizeImageFile");
if (filter < 0 || filter > 15)
filter = PointFilter;
im_init (&env, qst, args, "IM ResiseImageFile");
im_env_set_filenames (&env, 0, 5);
im_read (&env);
MagickResetIterator (env.ime_magick_wand);
while (MagickNextImage (env.ime_magick_wand) != MagickFalse)
{
MagickResizeImage (env.ime_magick_wand,v_size, h_size,filter,blur);
}
im_write (&env);
im_leave (&env);
return(0);
}
caddr_t bif_im_CropImageBlob(caddr_t * qst, caddr_t * err, state_slot_t ** args)
{
im_env_t env;
caddr_t res;
unsigned long width = bif_long_arg (qst, args, 2, "IM CropImageBlob");
unsigned long height = bif_long_arg (qst, args, 3, "IM CropImageBlob");
long x = bif_long_arg (qst, args, 4, "IM CropImageBlob");
long y = bif_long_arg (qst, args, 5, "IM CropImageBlob");
im_init (&env, qst, args, "IM CropImageBlob");
im_env_set_input_blob (&env, 0);
im_env_set_blob_ext (&env, 6, -1);
im_read (&env);
MagickResetIterator (env.ime_magick_wand);
while (MagickNextImage (env.ime_magick_wand) != MagickFalse)
{
MagickCropImage (env.ime_magick_wand, width, height, x, y);
}
res = im_write (&env);
im_leave (&env);
return res;
}
caddr_t bif_im_ThumbnailImageBlob (caddr_t * qst, caddr_t * err, state_slot_t ** args)
{
im_env_t env;
caddr_t res;
long v_size = bif_long_arg (qst, args, 2, "IM ThumbnailImageBlob");
long h_size = bif_long_arg (qst, args, 3, "IM ThumbnailImageBlob");
long filter = bif_long_arg (qst, args, 4, "IM ThumbnailImageBlob");
if (filter < 0 || filter > 15)
filter = PointFilter;
im_init (&env, qst, args, "IM ThumbnailImageBlob");
im_env_set_input_blob (&env, 0);
im_env_set_blob_ext (&env, 5, -1);
im_read (&env);
MagickResetIterator (env.ime_magick_wand);
while (MagickNextImage (env.ime_magick_wand) != MagickFalse)
{
MagickResizeImage (env.ime_magick_wand,v_size, h_size,filter,1.0);
MagickProfileImage (env.ime_magick_wand, "*", NULL, 0);
}
res = im_write (&env);
im_leave (&env);
return res;
}
caddr_t bif_im_ResampleImageBlob (caddr_t * qst, caddr_t * err, state_slot_t ** args)
{
im_env_t env;
caddr_t res;
double v_size = bif_double_arg (qst, args, 2, "IM ResampleImageBlob");
double h_size = bif_double_arg (qst, args, 3, "IM ResampleImageBlob");
double blur = bif_double_arg (qst, args, 4, "IM ResampleImageBlob");
long filter = bif_long_arg (qst, args, 5, "IM ResampleImageBlob");
if (filter < 0 || filter > 15)
filter = PointFilter;
im_init (&env, qst, args, "IM ResampleImageBlob");
im_env_set_input_blob (&env, 0);
im_env_set_blob_ext (&env, 6, -1);
im_read (&env);
MagickResetIterator (env.ime_magick_wand);
while (MagickNextImage (env.ime_magick_wand) != MagickFalse)
{
MagickResampleImage (env.ime_magick_wand,v_size, h_size,filter,blur);
}
res = im_write (&env);
im_leave (&env);
return res;
}
caddr_t
bif_timestampdiff (caddr_t * qst, caddr_t * err_ret, state_slot_t ** args)
{
ptrlong long_unit = bif_long_arg (qst, args, 0, "timestampdiff");
caddr_t dt1 = bif_date_arg (qst, args, 1, "timestampdiff");
caddr_t dt2 = bif_date_arg (qst, args, 2, "timestampdiff");
GMTIMESTAMP_STRUCT ts1, ts2;
/* BELOW OVERFLOWS on 32 bit long. Numbers used for computing difference,
* hence this works when difference below 2**21 = 34 years */
boxint s1 = (boxint)DT_DAY (dt1) * 24 * 60 * 60 + DT_HOUR (dt1) * 60 * 60 + DT_MINUTE (dt1) * 60 + DT_SECOND (dt1);
boxint s2 = (boxint)DT_DAY (dt2) * 24 * 60 * 60 + DT_HOUR (dt2) * 60 * 60 + DT_MINUTE (dt2) * 60 + DT_SECOND (dt2);
char *unit = interval_odbc_to_text (long_unit, "timestampdiff");
if (0 == stricmp (unit, "day"))
return box_num ((boxint)DT_DAY (dt2) - (boxint)DT_DAY (dt1));
if (0 == stricmp (unit, "hour"))
return box_num ((s2 - s1) / (60 * 60));
if (0 == stricmp (unit, "minute"))
return box_num ((s2 - s1) / 60);
if (0 == stricmp (unit, "second"))
return box_num (s2 - s1);
dt_to_GMTimestamp_struct (dt2, &ts2);
dt_to_GMTimestamp_struct (dt1, &ts1);
if (0 == stricmp (unit, "month"))
return box_num ((boxint)(ts2.year * 12 + ts2.month) - (boxint)(ts1.year * 12 + ts1.month));
if (0 == stricmp (unit, "year"))
return box_num ((boxint)ts2.year - (boxint)ts1.year);
sqlr_new_error ("22015", "DT004", "Bad interval in timestampdiff: %s.", unit);
return NULL;
}
