int
MotionCells::initDataFile (char *p_datafile, gint64 starttime) //p_date is increased with difference between current and previous buffer ts
{
MotionCellData mcd;
if (strncmp (p_datafile, " ", 1)) {
mc_savefile = fopen (p_datafile, "w");
if (mc_savefile == NULL) {
//fprintf(stderr, "%s %d:initDataFile:fopen:%d (%s)\n", __FILE__, __LINE__, errno,
//strerror(errno));
strncpy (m_initdatafilefailed, strerror (errno), BUSMSGLEN - 1);
m_initerrorcode = errno;
return 1;
} else {
m_saveInDatafile = true;
}
} else
mc_savefile = NULL;
//it needs these bytes
m_header.itemsize =
GINT32_TO_BE ((int) ceil (ceil (m_gridx * m_gridy / 8.0) / 4.0) * 4 +
sizeof (mcd.timestamp));
m_header.gridx = GINT32_TO_BE (m_gridx);
m_header.gridy = GINT32_TO_BE (m_gridy);
m_header.starttime = GINT64_TO_BE (starttime);
snprintf (m_header.name, sizeof (m_header.name), "%s %dx%d", MC_VERSIONTEXT,
GINT32_FROM_BE (m_header.gridx), GINT32_FROM_BE (m_header.gridy));
m_changed_datafile = false;
return 0;
}
static GBuffer *
zone_for_constant_offset (const gchar *name)
{
const gchar fake_zoneinfo_headers[] =
"TZif" "2..." "...." "...." "...."
"\0\0\0\0" "\0\0\0\0" "\0\0\0\0" "\0\0\0\0" "\0\0\0\0" "\0\0\0\0"
"TZif" "2..." "...." "...." "...."
"\0\0\0\0" "\0\0\0\0" "\0\0\0\0" "\0\0\0\0" "\0\0\0\1" "\0\0\0\7";
struct {
struct tzhead headers[2];
struct ttinfo info;
gchar abbr[8];
} *fake;
gint32 offset;
if (name == NULL || !parse_constant_offset (name, &offset))
return NULL;
offset = GINT32_TO_BE (offset);
fake = g_malloc (sizeof *fake);
memcpy (fake, fake_zoneinfo_headers, sizeof fake_zoneinfo_headers);
memcpy (&fake->info.tt_gmtoff, &offset, sizeof offset);
fake->info.tt_isdst = FALSE;
fake->info.tt_abbrind = 0;
strcpy (fake->abbr, name);
return g_buffer_new_take_data (fake, sizeof *fake);
}
guint64
prop_copy_int32 (gint32 prop, guint8 ** buffer, guint64 * size,
guint64 * offset)
{
prop = GINT32_TO_BE (prop);
return copy_func (&prop, sizeof (guint32), buffer, size, offset);
}
void
lx_print_int32(RxBuffer *buf, gint32 value, GError **error)
{
g_assert(buf != NULL); g_assert(buf->array != NULL);
g_assert(error != NULL);
gint32 network_value = GINT32_TO_BE(value);
g_byte_array_append(buf->array, (guint8*)&network_value, sizeof(network_value));
}
MotionCells::MotionCells ()
{
m_framecnt = 0;
m_motioncells_idx_count = 0;
m_motioncellsidxcstr = NULL;
m_saveInDatafile = false;
mc_savefile = NULL;
m_pcurFrame = NULL;
m_pprevFrame = NULL;
transparencyimg = NULL;
m_pdifferenceImage = NULL;
m_pbwImage = NULL;
m_initdatafilefailed = new char[BUSMSGLEN];
m_savedatafilefailed = new char[BUSMSGLEN];
m_initerrorcode = 0;
m_saveerrorcode = 0;
m_alpha = 0.5;
m_beta = 0.5;
m_useAlpha = false;
m_isVisible = false;
m_pCells = NULL;
m_gridx = 0;
m_gridy = 0;
m_cellwidth = 0;
m_cellheight = 0;
m_sensitivity = 0;
m_changed_datafile = false;
memset (&m_header, 0, sizeof (MotionCellHeader));
m_header.headersize = GINT32_TO_BE (MC_HEADER);
m_header.type = GINT32_TO_BE (MC_TYPE);
m_header.version = GINT32_TO_BE (MC_VERSION);
m_header.itemsize = 0;
m_header.gridx = 0;
m_header.gridy = 0;
m_header.starttime = 0;
}
/**
* qmi_utils_write_gint32_to_buffer:
* @buffer: a buffer.
* @buffer_size: size of @buffer.
* @endian: endianness of firmware value; swapped from host byte order if necessary
* @in: location of the variable to be written.
*
* Writes a signed 32-bit integer into the buffer. The number to be written
* is expected to be given in host endianness, and this method takes care of
* converting the value written to the byte order specified by @endian.
*
* The user needs to make sure that the buffer is at least 4 bytes long.
*
* Also note that both @buffer and @buffer_size get updated after the 4 bytes
* write.
*/
void
qmi_utils_write_gint32_to_buffer (guint8 **buffer,
guint16 *buffer_size,
QmiEndian endian,
gint32 *in)
{
gint32 tmp;
g_assert (in != NULL);
g_assert (buffer != NULL);
g_assert (buffer_size != NULL);
g_assert (*buffer_size >= 4);
if (endian == QMI_ENDIAN_BIG)
tmp = GINT32_TO_BE (*in);
else
tmp = GINT32_TO_LE (*in);
memcpy (&(*buffer)[0], &tmp, sizeof (tmp));
*buffer = &((*buffer)[4]);
*buffer_size = (*buffer_size) - 4;
}
static void
gst_file_index_add_association (GstIndex * index, GstIndexEntry * entry)
{
GstFileIndex *fileindex = GST_FILE_INDEX (index);
GstFileIndexId *id_index;
gint mx;
GstIndexAssociation sample;
gboolean exact;
id_index = g_hash_table_lookup (fileindex->id_index, &entry->id);
if (!id_index)
return;
if (!id_index->nformats) {
gint fx;
id_index->nformats = GST_INDEX_NASSOCS (entry);
GST_LOG_OBJECT (fileindex, "creating %d formats for %d",
id_index->nformats, entry->id);
id_index->format = g_new (GstFormat, id_index->nformats);
for (fx = 0; fx < id_index->nformats; fx++)
id_index->format[fx] = GST_INDEX_ASSOC_FORMAT (entry, fx);
_fc_alloc_array (id_index);
} else {
/* only sanity checking */
if (id_index->nformats != GST_INDEX_NASSOCS (entry))
GST_WARNING_OBJECT (fileindex, "arity change %d -> %d",
id_index->nformats, GST_INDEX_NASSOCS (entry));
else {
gint fx;
for (fx = 0; fx < id_index->nformats; fx++)
if (id_index->format[fx] != GST_INDEX_ASSOC_FORMAT (entry, fx))
GST_WARNING_OBJECT (fileindex, "format[%d] changed %d -> %d",
fx, id_index->format[fx], GST_INDEX_ASSOC_FORMAT (entry, fx));
}
}
/* this is a hack, we should use a private structure instead */
sample.format = 0;
sample.value = GST_INDEX_ASSOC_VALUE (entry, 0);
exact =
_fc_bsearch (id_index->array, ARRAY_ROW_SIZE (id_index),
&mx, file_index_compare, &sample, id_index);
if (exact) {
/* maybe overwrite instead? */
GST_DEBUG_OBJECT (index,
"Ignoring duplicate index association at %" G_GINT64_FORMAT,
GST_INDEX_ASSOC_VALUE (entry, 0));
return;
}
{
gchar *row_data = (gchar *) g_malloc (ARRAY_ROW_SIZE (id_index));
gint fx;
gint32 flags_host = GST_INDEX_ASSOC_FLAGS (entry);
ARRAY_ROW_FLAGS (row_data) = GINT32_TO_BE (flags_host);
for (fx = 0; fx < id_index->nformats; fx++) {
gint64 val_host = GST_INDEX_ASSOC_VALUE (entry, fx);
ARRAY_ROW_VALUE (row_data, fx) = GINT64_TO_BE (val_host);
}
g_array_insert_vals (id_index->array, mx, row_data, 1);
g_free (row_data);
}
}
int
MotionCells::saveMotionCells (gint64 timestamp_millisec)
{
MotionCellData mc_data;
mc_data.timestamp = GINT32_TO_BE (timestamp_millisec);
mc_data.data = NULL;
//There is no datafile
if (mc_savefile == NULL)
return 0;
if (ftello (mc_savefile) == 0) {
//cerr << "Writing out file header"<< m_header.headersize <<":" << sizeof(MotionCellHeader) << " itemsize:"
//<< m_header.itemsize << endl;
if (fwrite (&m_header, sizeof (MotionCellHeader), 1, mc_savefile) != 1) {
//fprintf(stderr, "%s %d:saveMotionCells:fwrite:%d (%s)\n", __FILE__, __LINE__, errno,
//strerror(errno));
strncpy (m_savedatafilefailed, strerror (errno), BUSMSGLEN - 1);
m_saveerrorcode = errno;
return -1;
}
}
mc_data.data =
(char *) calloc (1,
GINT32_FROM_BE (m_header.itemsize) - sizeof (mc_data.timestamp));
if (mc_data.data == NULL) {
//fprintf(stderr, "%s %d:saveMotionCells:calloc:%d (%s)\n", __FILE__, __LINE__, errno,
//strerror(errno));
strncpy (m_savedatafilefailed, strerror (errno), BUSMSGLEN - 1);
m_saveerrorcode = errno;
return -1;
}
for (unsigned int i = 0; i < m_MotionCells.size (); i++) {
int bitnum =
m_MotionCells.at (i).lineidx * GINT32_FROM_BE (m_header.gridx) +
m_MotionCells.at (i).colidx;
int bytenum = (int) floor (bitnum / 8.0);
int shift = bitnum - bytenum * 8;
mc_data.data[bytenum] = mc_data.data[bytenum] | (1 << shift);
//cerr << "Motion Detected " << "line:" << m_MotionCells.at(i).lineidx << " col:" << m_MotionCells.at(i).colidx;
//cerr << " bitnum " << bitnum << " bytenum " << bytenum << " shift " << shift << " value " << (int)mc_data.data[bytenum] << endl;
}
if (fwrite (&mc_data.timestamp, sizeof (mc_data.timestamp), 1,
mc_savefile) != 1) {
//fprintf(stderr, "%s %d:saveMotionCells:fwrite:%d (%s)\n", __FILE__, __LINE__, errno,
//strerror(errno));
strncpy (m_savedatafilefailed, strerror (errno), BUSMSGLEN - 1);
m_saveerrorcode = errno;
return -1;
}
if (fwrite (mc_data.data,
GINT32_FROM_BE (m_header.itemsize) - sizeof (mc_data.timestamp), 1,
mc_savefile) != 1) {
//fprintf(stderr, "%s %d:saveMotionCells:fwrite:%d (%s)\n", __FILE__, __LINE__, errno,
//strerror(errno));
strncpy (m_savedatafilefailed, strerror (errno), BUSMSGLEN - 1);
m_saveerrorcode = errno;
return -1;
}
free (mc_data.data);
return 0;
}
gboolean
separate_psd_export (gchar *filename,
gint32 imageID,
gconstpointer profile_data,
gsize profile_length,
gconstpointer path_data,
gsize path_length,
gboolean compression)
{
int fd;
PSDHeader header;
PSDResResource res;
PSDIccResource icc;
fd = g_open (filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 00644);
if (fd != -1)
{
gint32 length;
gint32 width, height;
gdouble xres, yres;
width = gimp_image_width (imageID);
height = gimp_image_height (imageID);
/* header */
header.signature = GUINT32_TO_BE (0x38425053);
header.version = GUINT16_TO_BE (1);
memset (header.reserved, 0, sizeof (header.reserved));
header.channels = GINT16_TO_BE (4); /* C, M, Y, K, and no alpha channels */
header.height = GINT32_TO_BE (height);
header.width = GINT32_TO_BE (width);
header.depth = GINT16_TO_BE (8); /* 8bit per channels */
header.mode = GINT16_TO_BE (4); /* CMYK Mode */
write (fd, &header, sizeof (header));
/***** color mode data *****/
length = 0;
write (fd, &length, sizeof (gint32));
/***** image resources *****/
length = 0;
/* resolution info */
gimp_image_get_resolution (imageID, &xres, &yres);
res.type = GUINT32_TO_BE (0x3842494d);
res.id = GUINT16_TO_BE (0x03ed);
memset (res.name, 0, 2);
res.size = GINT32_TO_BE (16);
res.hres = GINT32_TO_BE (xres * 65536.0);
res.hres_unit = GINT16_TO_BE (1);
res.width_unit = GINT16_TO_BE (1);
res.vres = GINT32_TO_BE (yres * 65536.0);
res.vres_unit = GINT16_TO_BE (1);
res.height_unit = GINT16_TO_BE (1);
length += sizeof (PSDResResource);
/* ICC profile */
if (profile_data)
{
icc.type = res.type;
icc.id = GUINT16_TO_BE (0x040f);
memset (icc.name, 0, 2);
icc.size = GINT32_TO_BE (profile_length);
length += sizeof (PSDIccResource) + profile_length;
}
/* path */
if (path_data)
length += path_length;
/* write data... */
length = GINT32_TO_BE (length);
write (fd, &length, sizeof (gint32));
write (fd, &res, sizeof (PSDResResource));
if (profile_data)
{
write (fd, &icc, sizeof (PSDIccResource));
write (fd, profile_data, profile_length);
}
if (path_data)
write (fd, path_data, path_length);
/***** layer and mask info *****/
length = 0;
write (fd, &length, sizeof (gint32));
/***** image data *****/
if (compression)
psd_write_image_data_packbits (fd, imageID, width, height);
else
psd_write_image_data_raw (fd, imageID, width, height);
close (fd);
return TRUE;
}
return FALSE;
}
/*!
\brief ECU specifc that gets called to send a value to the ECU.
\param canID is the can Identifier
\param locID is the Location ID to where this value belongs
\param offset is the offset from the beginning of the page that this data
refers to.
\param size is an enumeration corresponding to how big this variable is
\param value is the value that should be sent to the ECU At page/offset
\param queue_update if true queues a gui update, used to prevent
a horrible stall when doing an ECU restore or batch load...
*/
G_MODULE_EXPORT void libreems_send_to_ecu(gint canID, gint locID, gint offset, DataSize size, gint value, gboolean queue_update)
{
static Firmware_Details *firmware = NULL;
OutputData *output = NULL;
guint8 *data = NULL;
guint16 u16 = 0;
gint16 s16 = 0;
guint32 u32 = 0;
gint32 s32 = 0;
ENTER();
if (!firmware)
firmware = (Firmware_Details *)DATA_GET(global_data,"firmware");
g_return_if_fail(firmware);
g_return_if_fail(offset >= 0);
MTXDBG(SERIAL_WR,_("Sending locID %i, offset %i, value %i \n"),locID,offset,value);
switch (size)
{
case MTX_CHAR:
case MTX_S08:
case MTX_U08:
/*printf("8 bit var %i at offset %i\n",value,offset);*/
break;
case MTX_S16:
case MTX_U16:
/*printf("16 bit var %i at offset %i\n",value,offset);*/
break;
case MTX_S32:
case MTX_U32:
/*printf("32 bit var %i at offset %i\n",value,offset);*/
break;
default:
printf(_("libreems_send_to_ecu() ERROR!!! Size undefined for variable at canID %i, offset %i\n"),locID,offset);
}
output = initialize_outputdata_f();
DATA_SET(output->data,"location_id", GINT_TO_POINTER(locID));
DATA_SET(output->data,"payload_id", GINT_TO_POINTER(REQUEST_UPDATE_BLOCK_IN_RAM));
DATA_SET(output->data,"offset", GINT_TO_POINTER(offset));
DATA_SET(output->data,"size", GINT_TO_POINTER(size));
DATA_SET(output->data,"value", GINT_TO_POINTER(value));
DATA_SET(output->data,"length", GINT_TO_POINTER(get_multiplier_f(size)));
DATA_SET(output->data,"mode", GINT_TO_POINTER(MTX_SIMPLE_WRITE));
/* Get memory */
data = g_new0(guint8,get_multiplier_f(size));
switch (size)
{
case MTX_CHAR:
case MTX_U08:
data[0] = (guint8)value;
break;
case MTX_S08:
data[0] = (gint8)value;
break;
case MTX_U16:
if (firmware->bigendian)
u16 = GUINT16_TO_BE((guint16)value);
else
u16 = GUINT16_TO_LE((guint16)value);
data[0] = (guint8)u16;
data[1] = (guint8)((guint16)u16 >> 8);
break;
case MTX_S16:
if (firmware->bigendian)
s16 = GINT16_TO_BE((gint16)value);
else
s16 = GINT16_TO_LE((gint16)value);
data[0] = (guint8)s16;
data[1] = (guint8)((gint16)s16 >> 8);
break;
case MTX_S32:
if (firmware->bigendian)
s32 = GINT32_TO_BE((gint32)value);
else
s32 = GINT32_TO_LE((gint32)value);
data[0] = (guint8)s32;
data[1] = (guint8)((gint32)s32 >> 8);
data[2] = (guint8)((gint32)s32 >> 16);
data[3] = (guint8)((gint32)s32 >> 24);
break;
case MTX_U32:
if (firmware->bigendian)
u32 = GUINT32_TO_BE((guint32)value);
else
u32 = GUINT32_TO_LE((guint32)value);
data[0] = (guint8)u32;
data[1] = (guint8)((guint32)u32 >> 8);
data[2] = (guint8)((guint32)u32 >> 16);
data[3] = (guint8)((guint32)u32 >> 24);
break;
default:
break;
}
DATA_SET_FULL(output->data,"data",(gpointer)data, g_free);
/* Set it here otherwise there's a risk of a missed burn due to
* a potential race condition in the burn checker
*/
libreems_set_ecu_data(canID,locID,offset,size,value);
/* IF the packet fails, update_write_status will rollback properly */
output->queue_update = queue_update;
io_cmd_f(firmware->write_command,output);
EXIT();
return;
}
gint32
fwrite_unicode_string (const gchar *src,
const guint16 mod_len,
FILE *f,
GError **error)
{
/*
* Converts utf-8 string to utf-16 and writes 4 byte length
* then string padding to multiple of mod_len.
*/
gunichar2 *utf16_str;
gchar null_str = 0x0;
gint32 utf16_len = 0;
gint32 bytes_written = 0;
gint i;
glong len;
if (src == NULL)
{
/* Write null string as four byte 0 int32 */
if (fwrite (&utf16_len, 4, 1, f) < 1)
{
psd_set_error (feof (f), errno, error);
return -1;
}
bytes_written += 4;
}
else
{
utf16_str = g_utf8_to_utf16 (src, -1, NULL, &len, NULL);
/* Byte swap as required */
utf16_len = len;
for (i = 0; i < utf16_len; ++i)
utf16_str[i] = GINT16_TO_BE (utf16_str[i]);
utf16_len = GINT32_TO_BE (utf16_len);
if (fwrite (&utf16_len, 4, 1, f) < 1
|| fwrite (utf16_str, 2, utf16_len + 1, f) < utf16_len + 1)
{
psd_set_error (feof (f), errno, error);
return -1;
}
bytes_written += (4 + 2 * utf16_len + 2);
IFDBG(2) g_debug ("Unicode string: %s, bytes_written: %d",
src, bytes_written);
}
/* Pad with nulls */
if (mod_len > 0)
{
while (bytes_written % mod_len != 0)
{
if (fwrite (&null_str, 1, 1, f) < 1)
{
psd_set_error (feof (f), errno, error);
return -1;
}
bytes_written++;
}
}
return bytes_written;
}
/*
* Calculate the current NTP time, store it in the buffer.
*/
static void
fill_int(unsigned char *buffer, uint32_t value)
{
uint32_t be = GINT32_TO_BE(value);
memcpy(buffer, &be, sizeof(be));
}