static int convert_stereo_to_mono_s16be(struct xmms_convert_buffers* buf, void **data, int length)
{
gint16 *output = *data, *input = *data;
int i;
for (i = 0; i < length / 4; i++)
{
gint32 tmp;
gint16 stmp;
tmp = GINT16_FROM_BE(*input);
input++;
tmp += GINT16_FROM_BE(*input);
input++;
stmp = tmp / 2;
*output++ = GINT16_TO_BE(stmp);
}
return length / 2;
}
/**
* qmi_utils_write_gint16_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 16-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 2 bytes long.
*
* Also note that both @buffer and @buffer_size get updated after the 2 bytes
* write.
*/
void
qmi_utils_write_gint16_to_buffer (guint8 **buffer,
guint16 *buffer_size,
QmiEndian endian,
gint16 *in)
{
gint16 tmp;
g_assert (in != NULL);
g_assert (buffer != NULL);
g_assert (buffer_size != NULL);
g_assert (*buffer_size >= 2);
if (endian == QMI_ENDIAN_BIG)
tmp = GINT16_TO_BE (*in);
else
tmp = GINT16_TO_LE (*in);
memcpy (&(*buffer)[0], &tmp, sizeof (tmp));
*buffer = &((*buffer)[2]);
*buffer_size = (*buffer_size) - 2;
}
static int convert_stereo_to_mono(void **data, int length, int fmt)
{
int i;
switch (fmt)
{
case AFMT_U8:
{
guint8 *output = *data, *input = *data;
for (i = 0; i < length / 2; i++)
{
guint16 tmp;
tmp = *input++;
tmp += *input++;
*output++ = tmp / 2;
}
}
break;
case AFMT_S8:
{
gint8 *output = *data, *input = *data;
for (i = 0; i < length / 2; i++)
{
gint16 tmp;
tmp = *input++;
tmp += *input++;
*output++ = tmp / 2;
}
}
break;
case AFMT_U16_LE:
{
guint16 *output = *data, *input = *data;
for (i = 0; i < length / 4; i++)
{
guint32 tmp;
guint16 stmp;
tmp = GUINT16_FROM_LE(*input);
input++;
tmp += GUINT16_FROM_LE(*input);
input++;
stmp = tmp / 2;
*output++ = GUINT16_TO_LE(stmp);
}
}
break;
case AFMT_U16_BE:
{
guint16 *output = *data, *input = *data;
for (i = 0; i < length / 4; i++)
{
guint32 tmp;
guint16 stmp;
tmp = GUINT16_FROM_BE(*input);
input++;
tmp += GUINT16_FROM_BE(*input);
input++;
stmp = tmp / 2;
*output++ = GUINT16_TO_BE(stmp);
}
}
break;
case AFMT_S16_LE:
{
gint16 *output = *data, *input = *data;
for (i = 0; i < length / 4; i++)
{
gint32 tmp;
gint16 stmp;
tmp = GINT16_FROM_LE(*input);
input++;
tmp += GINT16_FROM_LE(*input);
input++;
stmp = tmp / 2;
*output++ = GINT16_TO_LE(stmp);
}
}
break;
case AFMT_S16_BE:
{
gint16 *output = *data, *input = *data;
for (i = 0; i < length / 4; i++)
{
gint32 tmp;
gint16 stmp;
tmp = GINT16_FROM_BE(*input);
input++;
tmp += GINT16_FROM_BE(*input);
input++;
stmp = tmp / 2;
*output++ = GINT16_TO_BE(stmp);
}
}
break;
default:
g_error("unknown format");
}
return length / 2;
}
static void
psd_write_image_data_packbits (int fd,
gint32 imageID,
gint32 width,
gint32 height)
{
gint i, x, y, col;
gint32 current, total;
gint16 compression;
GimpDrawable *drw[4];
GimpPixelRgn region;
gchar *src_buf, *dst_buf;
guint16 line_bytes[MAX_PIXELS];
gint buf_width, buf_height;
off_t data_head, data_end;
gchar channel_name[4][2] = { "C", "M", "Y", "K" };
drw[0] = separate_find_channel (imageID,sep_C);
drw[1] = separate_find_channel (imageID,sep_M);
drw[2] = separate_find_channel (imageID,sep_Y);
drw[3] = separate_find_channel (imageID,sep_K);
gimp_progress_init ("");
current = 0;
total = height * 4;
buf_width = ceil (width * 1.334);
buf_height = MIN (MAX_BUFFER_SIZE / buf_width, height);
if (!(src_buf = g_try_malloc (buf_width * buf_height)))
return;
if (!(dst_buf = g_try_malloc (buf_width * buf_height)))
{
g_free (src_buf);
return;
}
compression = GINT16_TO_BE (1);
write (fd, &compression, sizeof (gint16));
data_head = lseek (fd, 0, SEEK_CUR);
data_end = data_head + height * 4 * 2;
for (i = 0; i < 4; i++)
{
gint n_lines;
gint result;
gimp_progress_set_text_printf (_("Exporting Photoshop PSD (%s channel)..."),
channel_name[i]);
if (drw[i])
{
gimp_pixel_rgn_init (®ion, drw[i], 0, 0, width, height, FALSE, FALSE);
for (y = 0; y < height; y += buf_height, current += buf_height)
{
gint read_bytes, write_bytes;
gimp_progress_update ((gdouble)current / (gdouble)total);
n_lines = MIN (height - y, buf_height);
gimp_pixel_rgn_get_rect (®ion, src_buf, 0, y, width, n_lines);
read_bytes = 0;
write_bytes = 0;
for (col = 0; col < n_lines; col++)
{
gint _write_bytes = write_bytes;
gchar *count = dst_buf + write_bytes++;
*count = 0;
dst_buf[write_bytes++] = 0xff - src_buf[read_bytes++];
for (x = 1; x < width; x++)
{
gchar tmp = 0xff - src_buf[read_bytes++];
if (dst_buf[write_bytes - 1] == tmp) /* 連続 */
{
if (*count == -127)
{
/* 128バイトを超えた場合 */
count = dst_buf + write_bytes++;
*count = 0;
dst_buf[write_bytes++] = tmp;
}
else if (*count <= 0)
{
/* 通常のカウント */
(*count)--;
}
else
{
/* 非連続からの切り替え */
(*count)--; /* 非連続としてカウントされた1バイト目の分を減らす */
count = dst_buf + write_bytes - 1;
*count = -1;
dst_buf[write_bytes++] = tmp;
}
}
else /* 非連続 */
{
if (*count >= 0 && *count != 127)
{
(*count)++;
dst_buf[write_bytes++] = tmp;
}
else
{
count = dst_buf + write_bytes++;
*count = 0;
dst_buf[write_bytes++] = tmp;
}
}
}
line_bytes[y + col] = GINT16_TO_BE (write_bytes - _write_bytes);
}
/* seek to end of pixel data */
lseek (fd, data_end, SEEK_SET);
result = write (fd, dst_buf, write_bytes);
data_end += write_bytes;
}
/* seek to bytes per line data */
lseek (fd, data_head + height * i * 2, SEEK_SET);
result = write (fd, line_bytes, height * 2);
}
else
{
gint n_repeat = width / 128;
gint bytes = 0;
for (x = 0; x < n_repeat; x++)
{
dst_buf[bytes++] = -127;
dst_buf[bytes++] = 0xff;
}
if (width % 128)
{
dst_buf[bytes++] = ((width % 128) - 1) * -1;
dst_buf[bytes++] = 0xff;
}
for (col = 1; col < buf_height; col++)
memcpy (dst_buf + bytes * col, dst_buf, bytes);
/* seek to end of pixel data */
lseek (fd, data_end, SEEK_SET);
for (y = 0; y < height; y += buf_height, current += buf_height)
{
gimp_progress_update ((gdouble)current / (gdouble)total);
n_lines = MIN (height - y, buf_height);
result = write (fd, dst_buf, bytes * n_lines);
for (col = 0; col < n_lines; col++)
line_bytes[y + col] = GINT16_TO_BE (bytes);
}
data_end += bytes * height;
/* seek to bytes per line data */
lseek (fd, data_head + height * i * 2, SEEK_SET);
result = write (fd, line_bytes, height * 2);
}
}
gimp_progress_update (1.0);
g_free (src_buf);
g_free (dst_buf);
}
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;
}
/*!
\brief feed_import_data_to_ecu() Forwards the data in the VEX file to the
ECU. NOTE this may have problems with firmware using multiple tables in
a page, as the VEX format 1.0 does NOT handle that condition.
\param vex (Vex_Import *) pointer to the Vex_Impot datastructure.
*/
G_MODULE_EXPORT void feed_import_data_to_ecu(Vex_Import *vex)
{
gint i = 0;
gchar *tmpbuf = NULL;
guint8 **ecu_data = NULL;
guint8 **ecu_data_backup = NULL;
void *data = NULL;
gchar * msgbuf = NULL;
guchar *ptr = NULL;
guint16 *ptr16 = NULL;
guint32 *ptr32 = NULL;
gint total = 0;
gint canID = 0;
gint page = -1;
gint base = 0;
DataSize size = 0;
gint mult = 0;
gint table = -1;
Firmware_Details *firmware = NULL;
firmware = DATA_GET(global_data,"firmware");
ecu_data = firmware->ecu_data;
ecu_data_backup = firmware->ecu_data_backup;
/* Since we assume the page is where the table is this can cause
* major problems with some firmwares that use two tables inside
* of one page....
*/
page = vex->page;
table = vex->table;
if ((table < 0) || (table >= firmware->total_tables))
{
dbg_func_f(CRITICAL,g_strdup_printf(__FILE__": feed_import_data_to_ecu()\n\ttable passed (%i) is out of range(%i)\n",table,firmware->total_tables));
return;
}
/* If dimensions do NOT match, ABORT!!! */
if (firmware->table_params[table]->x_bincount != vex->total_x_bins)
{
msgbuf = g_strdup_printf(_("VEX Import: number of RPM bins inside VEXfile and FIRMWARE DO NOT MATCH (%i!=%i), aborting!!!\n"),firmware->table_params[table]->x_bincount,vex->total_x_bins);
update_logbar_f("tools_view","warning",msgbuf,FALSE,FALSE,FALSE);
dbg_func_f(CRITICAL,g_strdup(msgbuf));
g_free(msgbuf);
return;
}
if (firmware->table_params[table]->y_bincount != vex->total_y_bins)
{
msgbuf = g_strdup_printf(_("VEX Import: number of LOAD bins inside VEXfile and FIRMWARE DO NOT MATCH (%i!=%i), aborting!!!\n"),firmware->table_params[table]->y_bincount,vex->total_y_bins);
update_logbar_f("tools_view","warning",msgbuf,FALSE,FALSE,FALSE);
dbg_func_f(CRITICAL,g_strdup(msgbuf));
g_free(msgbuf);
return;
}
/* Backup the ALL pages of data first... */
for (i=0;i<firmware->total_pages;i++)
{
if (!firmware->page_params[i]->dl_by_default)
continue;
memset((void *)ecu_data_backup[i], 0, firmware->page_params[i]->length);
memcpy(ecu_data_backup[i], ecu_data[i],firmware->page_params[i]->length);
}
canID = firmware->canID;
page = firmware->table_params[table]->x_page;
base = firmware->table_params[table]->x_base;
size = firmware->table_params[table]->x_size;
mult = get_multiplier_f(size);
if (firmware->chunk_support)
{
total = vex->total_x_bins;
data = g_malloc0(mult*total);;
if (mult == 1)
{
ptr = (guchar *)data;
for (i=0;i<total;i++)
ptr[i]=vex->x_bins[i];
}
if (mult == 2)
{
ptr16 = (guint16 *)data;
for (i=0;i<total;i++)
{
if (firmware->bigendian)
ptr16[i]=GINT16_TO_BE(vex->x_bins[i]);
else
ptr16[i]=GINT16_TO_LE(vex->x_bins[i]);
}
}
if (mult == 4)
{
ptr32 = (guint32 *)data;
for (i=0;i<total;i++)
{
if (firmware->bigendian)
ptr32[i]=GINT_TO_BE(vex->x_bins[i]);
else
ptr32[i]=GINT_TO_LE(vex->x_bins[i]);
}
}
ms_chunk_write(canID,page,base,(total*mult),data);
}
else
{
for (i=0;i<vex->total_x_bins;i++)
{
if (vex->x_bins[i] != ms_get_ecu_data_last(canID,page,base+(i*mult),size))
ms_send_to_ecu(canID,page,base+i,size, vex->x_bins[i], TRUE);
}
}
canID = firmware->canID;
page = firmware->table_params[table]->y_page;
base = firmware->table_params[table]->y_base;
size = firmware->table_params[table]->y_size;
mult = get_multiplier_f(size);
if (firmware->chunk_support)
{
total = vex->total_y_bins;
data = g_malloc0(mult*total);
if (mult == 1)
{
ptr = (guchar *)data;
for (i=0;i<total;i++)
ptr[i]=vex->y_bins[i];
}
if (mult == 2)
{
ptr16 = (guint16 *)data;
for (i=0;i<total;i++)
{
if (firmware->bigendian)
ptr16[i]=GINT16_TO_BE(vex->y_bins[i]);
else
ptr16[i]=GINT16_TO_LE(vex->y_bins[i]);
}
}
if (mult == 4)
{
ptr32 = (guint32 *)data;
for (i=0;i<total;i++)
{
if (firmware->bigendian)
ptr32[i]=GINT_TO_BE(vex->y_bins[i]);
else
ptr32[i]=GINT_TO_LE(vex->y_bins[i]);
}
}
ms_chunk_write(canID,page,base,(total*mult),data);
}
else
{
for (i=0;i<vex->total_y_bins;i++)
{
if (vex->y_bins[i] != ms_get_ecu_data_last(canID,page,base+i,size))
ms_send_to_ecu(canID,page,base+(i*mult),size,vex->y_bins[i], TRUE);
}
}
canID = firmware->canID;
page = firmware->table_params[table]->z_page;
base = firmware->table_params[table]->z_base;
size = firmware->table_params[table]->z_size;
mult = get_multiplier_f(size);
if (firmware->chunk_support)
{
total = (vex->total_y_bins)*(vex->total_x_bins);
data = g_malloc0(mult*total);
if (mult == 1)
{
ptr = (guchar *)data;
for (i=0;i<total;i++)
ptr[i]=vex->tbl_bins[i];
}
if (mult == 2)
{
ptr16 = (guint16 *)data;
for (i=0;i<total;i++)
{
if (firmware->bigendian)
ptr16[i]=GINT16_TO_BE(vex->tbl_bins[i]);
else
ptr16[i]=GINT16_TO_LE(vex->tbl_bins[i]);
}
}
if (mult == 4)
{
ptr32 = (guint32 *)data;
for (i=0;i<total;i++)
{
if (firmware->bigendian)
ptr32[i]=GINT_TO_BE(vex->tbl_bins[i]);
else
ptr32[i]=GINT_TO_LE(vex->tbl_bins[i]);
}
}
ms_chunk_write(canID,page,base,(total*mult),data);
}
else
{
for (i=0;i<((vex->total_y_bins)*(vex->total_x_bins));i++)
{
if (vex->tbl_bins[i] != ms_get_ecu_data_last(canID,page,base+i,size))
ms_send_to_ecu(canID,page,base+(i*mult),size,vex->tbl_bins[i], TRUE);
}
}
io_cmd_f(firmware->burn_all_command,NULL);
tmpbuf = g_strdup_printf(_("VEX Import: VEtable on page %i updated with data from the VEX file\n"),vex->page);
update_logbar_f("tools_view",NULL,tmpbuf,FALSE,FALSE,FALSE);
g_free(tmpbuf);
}
