SCM image_convert(SCM scm_ptr, SCM scm_source_type, SCM scm_dest_ptr, SCM scm_dest_type)
{
enum AVPixelFormat format;
int width, height;
void *ptr = scm_to_pointer(scm_ptr);
uint8_t *source_data[8];
int32_t source_pitches[8];
memset(source_pitches, 0, sizeof(source_pitches));
image_setup(scm_source_type, &format, &width, &height, source_data, source_pitches, ptr);
enum AVPixelFormat dest_format;
int dest_width, dest_height;
void *dest_ptr = scm_to_pointer(scm_dest_ptr);
uint8_t *dest_data[8];
int32_t dest_pitches[8];
memset(dest_pitches, 0, sizeof(dest_pitches));
image_setup(scm_dest_type, &dest_format, &dest_width, &dest_height, dest_data, dest_pitches, dest_ptr);
struct SwsContext *sws_context = sws_getContext(width, height, format,
dest_width, dest_height, dest_format,
SWS_FAST_BILINEAR, 0, 0, 0);
sws_scale(sws_context, (const uint8_t * const *)source_data, source_pitches, 0, height,
dest_data, dest_pitches);
sws_freeContext(sws_context);
return SCM_UNSPECIFIED;
}
static void
run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
static GimpParam values[1];
GimpDrawable *drawable;
GimpRunMode run_mode;
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
gint i;
run_mode = param[0].data.d_int32;
INIT_I18N ();
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
*nreturn_vals = 1;
*return_vals = values;
/* Set default values */
/* ================== */
set_default_settings ();
/* Get the specified drawable */
/* ========================== */
image_id = param[1].data.d_int32;
drawable = gimp_drawable_get (param[2].data.d_drawable);
switch (run_mode)
{
case GIMP_RUN_INTERACTIVE:
/* Possibly retrieve data */
/* ====================== */
gimp_get_data (PLUG_IN_PROC, &mapvals);
check_drawables (drawable);
if (main_dialog (drawable))
{
compute_image ();
gimp_set_data (PLUG_IN_PROC, &mapvals, sizeof (MapObjectValues));
}
break;
case GIMP_RUN_WITH_LAST_VALS:
gimp_get_data (PLUG_IN_PROC, &mapvals);
check_drawables (drawable);
image_setup (drawable, FALSE);
compute_image ();
break;
case GIMP_RUN_NONINTERACTIVE:
if (nparams != 49)
{
status = GIMP_PDB_CALLING_ERROR;
}
else
{
mapvals.maptype = (MapType) param[3].data.d_int32;
mapvals.viewpoint.x = param[4].data.d_float;
mapvals.viewpoint.y = param[5].data.d_float;
mapvals.viewpoint.z = param[6].data.d_float;
mapvals.position.x = param[7].data.d_float;
mapvals.position.y = param[8].data.d_float;
mapvals.position.z = param[9].data.d_float;
mapvals.firstaxis.x = param[10].data.d_float;
mapvals.firstaxis.y = param[11].data.d_float;
mapvals.firstaxis.z = param[12].data.d_float;
mapvals.secondaxis.x = param[13].data.d_float;
mapvals.secondaxis.y = param[14].data.d_float;
mapvals.secondaxis.z = param[15].data.d_float;
mapvals.alpha = param[16].data.d_float;
mapvals.beta = param[17].data.d_float;
mapvals.gamma = param[18].data.d_float;
mapvals.lightsource.type = (LightType) param[19].data.d_int32;
mapvals.lightsource.color = param[20].data.d_color;
mapvals.lightsource.position.x = param[21].data.d_float;
mapvals.lightsource.position.y = param[22].data.d_float;
mapvals.lightsource.position.z = param[23].data.d_float;
mapvals.lightsource.direction.x = param[24].data.d_float;
mapvals.lightsource.direction.y = param[25].data.d_float;
mapvals.lightsource.direction.z = param[26].data.d_float;
mapvals.material.ambient_int = param[27].data.d_float;
mapvals.material.diffuse_int = param[28].data.d_float;
mapvals.material.diffuse_ref = param[29].data.d_float;
mapvals.material.specular_ref = param[30].data.d_float;
mapvals.material.highlight = param[31].data.d_float;
mapvals.antialiasing = (gint) param[32].data.d_int32;
mapvals.tiled = (gint) param[33].data.d_int32;
mapvals.create_new_image = (gint) param[34].data.d_int32;
mapvals.transparent_background = (gint) param[35].data.d_int32;
mapvals.radius = param[36].data.d_float;
mapvals.cylinder_radius = param[36].data.d_float;
mapvals.scale.x = param[37].data.d_float;
mapvals.scale.y = param[38].data.d_float;
mapvals.scale.z = param[39].data.d_float;
mapvals.cylinder_length = param[40].data.d_float;
for (i = 0; i < 6; i++)
mapvals.boxmap_id[i] = param[41+i].data.d_drawable;
for (i = 0; i < 2; i++)
mapvals.cylindermap_id[i] = param[47+i].data.d_drawable;
check_drawables (drawable);
image_setup (drawable, FALSE);
compute_image ();
}
break;
}
values[0].data.d_status = status;
if (run_mode != GIMP_RUN_NONINTERACTIVE)
gimp_displays_flush ();
gimp_drawable_detach (drawable);
}
static void
run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
static GimpParam values[1];
GimpDrawable *drawable;
GimpRunMode run_mode;
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
run_mode = param[0].data.d_int32;
INIT_I18N ();
*nreturn_vals = 1;
*return_vals = values;
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
/* Set default values */
/* ================== */
set_default_settings ();
/* Possibly retrieve data */
/* ====================== */
gimp_get_data (PLUG_IN_PROC, &mapvals);
/* Get the specified drawable */
/* ========================== */
drawable = gimp_drawable_get (param[2].data.d_drawable);
mapvals.drawable_id = drawable->drawable_id;
check_drawables ();
if (status == GIMP_PDB_SUCCESS)
{
/* Make sure that the drawable is RGBA or RGB color */
/* ================================================ */
if (gimp_drawable_is_rgb (drawable->drawable_id))
{
/* Set the tile cache size */
/* ======================= */
gimp_tile_cache_ntiles (TILE_CACHE_SIZE);
switch (run_mode)
{
case GIMP_RUN_INTERACTIVE:
if (main_dialog (drawable))
{
compute_image ();
gimp_set_data (PLUG_IN_PROC,
&mapvals, sizeof (LightingValues));
gimp_displays_flush ();
}
break;
case GIMP_RUN_WITH_LAST_VALS:
if (image_setup (drawable, FALSE))
compute_image ();
gimp_displays_flush ();
break;
case GIMP_RUN_NONINTERACTIVE:
if (nparams != 24)
{
status = GIMP_PDB_CALLING_ERROR;
}
else
{
mapvals.bumpmap_id = param[3].data.d_drawable;
mapvals.envmap_id = param[4].data.d_drawable;
mapvals.bump_mapped = (gint) param[5].data.d_int32;
mapvals.env_mapped = (gint) param[6].data.d_int32;
mapvals.bumpmaptype = (gint) param[7].data.d_int32;
mapvals.lightsource[0].type = (LightType) param[8].data.d_int32;
mapvals.lightsource[0].color = param[9].data.d_color;
mapvals.lightsource[0].position.x = param[10].data.d_float;
mapvals.lightsource[0].position.y = param[11].data.d_float;
mapvals.lightsource[0].position.z = param[12].data.d_float;
mapvals.lightsource[0].direction.x = param[13].data.d_float;
mapvals.lightsource[0].direction.y = param[14].data.d_float;
mapvals.lightsource[0].direction.z = param[15].data.d_float;
mapvals.material.ambient_int = param[16].data.d_float;
mapvals.material.diffuse_int = param[17].data.d_float;
mapvals.material.diffuse_ref = param[18].data.d_float;
mapvals.material.specular_ref = param[19].data.d_float;
mapvals.material.highlight = param[20].data.d_float;
mapvals.antialiasing = (gint) param[21].data.d_int32;
mapvals.create_new_image = (gint) param[22].data.d_int32;
mapvals.transparent_background = (gint) param[23].data.d_int32;
check_drawables ();
if (image_setup (drawable, FALSE))
compute_image ();
}
default:
break;
}
}
else
status = GIMP_PDB_EXECUTION_ERROR;
}
values[0].data.d_status = status;
gimp_drawable_detach (drawable);
g_free (xpostab);
g_free (ypostab);
}
int main(void)
{
unsigned image;
init_omap3530beagle();
ser_putstr((char *)"\n\nQNX Neutrino Initial Program Loader for Texas Instruments OMAP3530 Beagle Board\n");
while (1) {
image = QNX_LOAD_ADDRESS;
ser_putstr((char *)"Commands:\n\n");
ser_putstr((char *)"Press 'D' for serial download, using the 'sendnto' utility\n");
ser_putstr((char *)"Press 'F' to boot an OS image from NAND flash\n");
ser_putstr((char *)"Press 'U' to Copy an OS image to NAND flash\n");
ser_putstr((char *)"Press 'I' to Update the IPL\n");
switch (ser_getchar()) {
case 'D': case 'd':
ser_putstr((char *)"Send image now...\n");
if (image_download_ser(image)) {
ser_putstr((char *)"Download failed...\n");
continue;
}
else
ser_putstr((char *)"Download OK...\n");
image = image_scan(image, image + 0x200);
break;
case 'F': case 'f':
ser_putstr((char *)"reading from NAND flash ........\n");
if (read_image_from_nand(NAND_RESERVED_BLOCK_START, NAND_RESERVED_BLOCK_END, (unsigned)image) !=0 ) {
ser_putstr((char *)"Read from NAND flash failed...\n");
continue;
}
image = image_scan(image, image+0x200);
break;
case 'U': case 'u':
ser_putstr((char *)"send the ifs now...\n");
if (image_download_ser(image)) {
ser_putstr((char *)"download failed...\n");
continue;
}else{
ser_putstr((char *)"download OK...\n");
//read all left bytes
while(ser_poll()){
ser_getchar();
}
ser_putstr((char *)"Writing IFS image to NAND flash from block 4 ......\n");
if (upgrade_nand_flash(NAND_RESERVED_BLOCK_START, NAND_RESERVED_BLOCK_END, (unsigned)image) != 0 ) {
ser_putstr((char *)"IFS image upgrading failed...\n");
} else {
ser_putstr((char *)"Upgrade IFS OK...\n");
}
continue;
}
break;
case 'I': case 'i':
ser_putstr((char *)"Send the IPL image, using the 'sendnto' utility...\n");
if (image_download_ser(image)) {
ser_putstr((char *)"Download failed...\n");
continue;
} else {
ser_putstr((char *)"Download OK...\n");
ser_putstr((char *)"Writing IPL to NAND flash @ blk0 ......\n");
if (upgrade_IPL((unsigned)image) != 0 ) {
ser_putstr((char *)"IPL upgrading failed...\n");
}
else {
ser_putstr((char *)"Update IPL OK\n");
}
//read all left bytes
while (ser_poll()) {
ser_getchar();
}
continue;
}
break;
default:
continue;
}
if (image != 0xffffffff) {
//before we go, we need to unlock the top 128MB NAND
// this will automatically lock all other blocks
nand_unlock_blocks(1024, 2047);
ser_putstr((char *)"Found image @ 0x");
ser_puthex(image);
ser_putstr((char *)"\n");
image_setup(image);
ser_putstr((char *)"Jumping to startup @ 0x");
ser_puthex(startup_hdr.startup_vaddr);
ser_putstr((char *)"\n\n");
image_start(image);
/* Never reach here */
return 0;
}else{
ser_putstr((char *)"image_scan failed...\n");
}
}
return 0;
}
