int do_jpgd(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
int ret;
#if 0
if (argc < 4)
{
printf("Insufficient parameter!\n");
printf ("Usage:\n%s\n", cmdtp->usage);
return -1;
}
#else
#ifdef CONFIG_SYS_LONGHELP
printf ("you should first set:\n%s\n", cmdtp->help);
#endif
#endif
ret = load_jpeg();
if (0 != ret)
{
printf("load jpeg err. \n");
//todo return 0 or ret?
return 0;
}
jpeg_decode();
printf("decode jpeg!\n");
return 0;
}
//=================================================================================
// pkl_fdopen
//=================================================================================
PKLExport PKLImage pkl_fdopen(FILE *in)
{
PKLImage pkl;
int result;
pkl = malloc( sizeof(struct _PKLImage) );
if(!pkl) return(NULL);
memset(pkl, 0, sizeof(struct _PKLImage));
pkl->compress = -1;
format_type(pkl, in);
switch(pkl->format){
case PKL_FORMAT_JPEG:
result = load_jpeg(pkl, in);
break;
case PKL_FORMAT_PNG:
result = load_png(pkl, in);
break;
case PKL_FORMAT_BITMAP:
result = load_bitmap(pkl, in);
break;
default:
result = 1;
}
if(result){
free(pkl);
pkl=NULL;
}
return(pkl);
}
/**
* Load texture from file.
* @param vfs - virtual filesystem where we can load files from
* @param name - name of the file to be loaded
* @param width - return width of the file
* @param height - return height of the file
* @return smart array containing data of the file
*/
shared_array<byte> nrCTextureLoader::load(nrCFileSystem* vfs, const string& name,int &width,int &height) {
if(strstr(name.c_str(),".tga") || strstr(name.c_str(),".TGA")) return load_tga(vfs,name,width,height);
if(strstr(name.c_str(),".png") || strstr(name.c_str(),".PNG")) return load_png(vfs,name,width,height);
if(strstr(name.c_str(),".jpg") || strstr(name.c_str(),".JPG")) return load_jpeg(vfs,name,width,height);
if(strstr(name.c_str(),".dds") || strstr(name.c_str(),".DDS")) return load_dds(vfs,name,width,height);
nrLog.Log(NR_LOG_ENGINE, "nrCTextureLoader::load():unknown format of '%s' file",name.c_str());
return shared_array<byte>(NULL);
}
int main(int argc, char *argv[])
{
image_t *img;
img = load_jpeg(argv[1]);
save_as_bmp(img, argv[2]);
img_destroy(img);
return 0;
}
image::image(stk::surface::ptr onscreen_surface,const std::string& filename) : onscreen_surface(onscreen_surface)
{
INFO("image::image(" << filename << ")");
// switch on extension until we remove ppm support
if (filename.find(".ppm") != std::string::npos)
load_ppmx(filename);
else if (filename.find(".jpg") != std::string::npos || filename.find(".jpeg") != std::string::npos)
load_jpeg(filename);
else
load_png(filename);
}
static int detect_image(const char *filepath, LCUI_Graph *out)
/* 功能：检测图片格式，并解码图片 */
{
int result = 1;
if (result == 1) {
result = load_png(filepath, out);
}
if (result == 1) {
result = load_jpeg(filepath, out);
}
if (result == 1) {
result = load_bmp(filepath, out);
}
return result;
}
int main( int argc, char** argv )
{
BApplication* pcApp = new BApplication( "application/x-vnd.KHS-desktop_manager" );
#if 0
if( getuid() == 0 )
{
const char* pzLoginName = NULL;
if ( argc == 2 )
{
pzLoginName = argv[1];
}
authorize( pzLoginName );
}
#endif
const char* pzBaseDir = getenv( "COSMOE_SYS" );
if( pzBaseDir == NULL )
{
pzBaseDir = "/cosmoe";
}
char* pzPath = new char[ strlen(pzBaseDir) + 80 ];
strcpy( pzPath, pzBaseDir );
strcat( pzPath, "/backdrop.jpg" );
g_pcBackDrop = load_jpeg( pzPath );
delete[] pzPath;
BWindow* pcBitmapWindow = new BWindow( BRect( 0, 0, 1599, 1199 ), "",
B_NO_BORDER_WINDOW_LOOK,
B_NORMAL_WINDOW_FEEL,
WND_BACKMOST,
B_ALL_WORKSPACES );
pcBitmapWindow->AddChild( new BitmapView( BRect( 0, 0, 1599, 1199 ), g_pcBackDrop ) );
pcBitmapWindow->Show();
pcApp->Run();
return( 0 );
}
static FtkBitmap* ftk_image_jpeg_decoder_decode(FtkImageDecoder* thiz, const char* filename)
{
return_val_if_fail(ftk_image_jpeg_decoder_match(thiz, filename) == RET_OK, NULL);
return load_jpeg(filename);
}
/* init
*/
int init(void) {
int i,num_vertex,width,height;
float *vertex;
unsigned char *data;
float rmax;
vec3 min,max;
vec4 plane_s = { 1.0, 0.0, 0.0, 0.0 };
vec4 plane_t = { 0.0, 1.0, 0.0, 0.0 };
vec4 plane_r = { 0.0, 0.0, 1.0, 0.0 };
vec4 plane_q = { 0.0, 0.0, 0.0, 1.0 };
GLenum err;
err = glewInit();
if (GLEW_OK != err)
{
fprintf(stderr, "glewInit() error: %s\n", glewGetErrorString(err));
}
glClearDepth(1);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
glEnable(GL_LIGHT0);
glPointSize(4);
glTexGenfv(GL_S,GL_EYE_PLANE,plane_s);
glTexGenfv(GL_T,GL_EYE_PLANE,plane_t);
glTexGenfv(GL_R,GL_EYE_PLANE,plane_r);
glTexGenfv(GL_Q,GL_EYE_PLANE,plane_q);
glTexGeni(GL_S,GL_TEXTURE_GEN_MODE,GL_EYE_LINEAR);
glTexGeni(GL_T,GL_TEXTURE_GEN_MODE,GL_EYE_LINEAR);
glTexGeni(GL_R,GL_TEXTURE_GEN_MODE,GL_EYE_LINEAR);
glTexGeni(GL_Q,GL_TEXTURE_GEN_MODE,GL_EYE_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_CLAMP);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_CLAMP);
glTexImage2D(GL_TEXTURE_2D,0,GL_RGB,SIZE,SIZE,0,GL_RGB,
GL_UNSIGNED_BYTE,NULL);
glGenTextures(1,&texture_id);
glBindTexture(GL_TEXTURE_2D,texture_id);
if((data = load_jpeg("data/ground.jpg",&width,&height))) {
glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,
GL_LINEAR_MIPMAP_LINEAR);
glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,
GL_LINEAR_MIPMAP_LINEAR);
gluBuild2DMipmaps(GL_TEXTURE_2D,4,width,height,GL_RGBA,
GL_UNSIGNED_BYTE,data);
free(data);
}
vertex = load_3ds("data/mesh.3ds",&num_vertex);
if(!vertex) return -1;
v_set(999999,999999,999999,min);
v_set(-999999,-999999,-999999,max);
for(i = 0; i < num_vertex; i++) {
int j;
float *v = &vertex[i << 3];
for(j = 0; j < 3; j++) {
if(min[j] > v[j]) min[j] = v[j];
if(max[j] < v[j]) max[j] = v[j];
}
}
v_add(min,max,min);
v_scale(min,0.5,min);
for(i = 0; i < num_vertex; i++) {
v_sub(&vertex[i << 3],min,&vertex[i << 3]);
}
for(i = 0, rmax = 0; i < num_vertex; i++) {
float r = sqrt(v_dot(&vertex[i << 3],&vertex[i << 3]));
if(r > rmax) rmax = r;
}
rmax = 0.8 / rmax;
for(i = 0; i < num_vertex; i++) {
v_scale(&vertex[i << 3],rmax,&vertex[i << 3]);
}
mesh_id = glGenLists(1);
glNewList(mesh_id,GL_COMPILE);
glBegin(GL_TRIANGLES);
for(i = 0; i < num_vertex; i++) {
glNormal3fv((float*)&vertex[i << 3] + 3);
glVertex3fv((float*)&vertex[i << 3]);
}
glEnd();
glEndList();
vertex = load_3ds("data/ground.3ds",&num_vertex);
if(!vertex) return -1;
ground_id = glGenLists(1);
glNewList(ground_id,GL_COMPILE);
glBegin(GL_TRIANGLES);
for(i = 0; i < num_vertex; i++) {
glTexCoord2fv((float*)&vertex[i << 3] + 6);
glNormal3fv((float*)&vertex[i << 3] + 3);
glVertex3fv((float*)&vertex[i << 3]);
}
glEnd();
glEndList();
image = malloc(SIZE * SIZE * 4);
return 0;
}
static int scan_file(const char *path, const char *filename,
struct result_info *info)
{
int len = strlen(filename);
const char *ext;
clock_t start;
clock_t total_start;
int ret;
int i;
while (len >= 0 && filename[len] != '.')
len--;
ext = filename + len + 1;
if (!(toupper(ext[0] == 'j') && toupper(ext[1] == 'p') &&
(toupper(ext[2] == 'e') || toupper(ext[2] == 'g'))))
return 0;
total_start = start = clock();
ret = load_jpeg(decoder, path);
info->load_time = clock() - start;
if (ret < 0) {
fprintf(stderr, "%s: load_jpeg failed\n", filename);
return -1;
}
start = clock();
quirc_end(decoder);
info->identify_time = clock() - start;
info->id_count = quirc_count(decoder);
for (i = 0; i < info->id_count; i++) {
struct quirc_code code;
struct quirc_data data;
quirc_extract(decoder, i, &code);
if (!quirc_decode(&code, &data))
info->decode_count++;
}
info->total_time += clock() - total_start;
printf(" %-30s: %5ld %5ld %5ld %5d %5d\n", filename,
CLOCK_TO_MS(info->load_time),
CLOCK_TO_MS(info->identify_time),
CLOCK_TO_MS(info->total_time),
info->id_count, info->decode_count);
if (want_cell_dump || want_verbose) {
for (i = 0; i < info->id_count; i++) {
struct quirc_code code;
quirc_extract(decoder, i, &code);
if (want_cell_dump) {
dump_cells(&code);
printf("\n");
}
if (want_verbose) {
struct quirc_data data;
quirc_decode_error_t err =
quirc_decode(&code, &data);
if (err) {
printf(" ERROR: %s\n\n",
quirc_strerror(err));
} else {
printf(" Decode successful:\n");
dump_data(&data);
printf("\n");
}
}
}
}
info->file_count = 1;
return 1;
}
void Texture::create_texture()
{
unsigned char* data = load_jpeg(filename);
texture_id =load_texture(data, width, height, wrap);
free(data);
}
void BMMap::make_map( int num_loc, float spacing )
{
int i,j;
// init bitmaps
if (bmpMap) destroy_bitmap( bmpMap );
bmpMap = load_jpeg( "gamedata/map.jpg" );
BITMAP *blankMap = create_bitmap( 800, 600 );
blit( bmpMap, blankMap, 0,0, 0,0, 800, 600 );
nloc = num_loc;
if (allLocs.size()==0) {
init_map_locs( "gamedata/maplocs.xml" );
}
printf("allLocs size %d\n", allLocs.size() );
// fill in the map locs
int reject , count, ndx;
for (i=0; i < nloc; i++) {
reject = 1; count = 100;
while ((reject) && (count)) {
ndx = random( allLocs.size() );
count--;
reject = 0;
for (j=0; j < i; j++) {
if (allLocs[ndx].name==loc[j].name) {
reject = 1;
break;
}
}
}
loc[i] = allLocs[ndx];
loc[i].index = i;
loc[i].heroVisited = 0;
}
// locate the locs
for ( i=0; i < nloc; i++) {
int good = 0;
int x, y;
float d;
good = 0;
while (!good) {
x = random( 170, 678 );
y = random( 75, 450 );
good = 1;
for ( j=0; j < i; j++) {
float xx, yy;
xx = (float)(loc[j].xpos - x);
yy = (float)(loc[j].ypos - y);
d = sqrt( xx*xx + yy*yy ) ;
if (d < spacing ) {
good = 0;
break;
}
}
}
loc[i].xpos = x;
loc[i].ypos = y;
}
// make the edges
make_edges_delauney();
// remove some edges
std::vector<CanRemoveEdge> cre;
while (1) {
cre.erase( cre.begin(), cre.end() );
// which edges can we remove??
for (i=0; i < nloc; i++) {
for (j=0; j < i; j++) {
if (adj[i][j].pass) {
// can we remove i->j?
adj[i][j].pass = 0;
adj[j][i].pass = 0;
if (is_connected()) {
CanRemoveEdge foo;
foo.a = i; foo.b = j;
cre.push_back( foo );
}
// put the edge back (for now )
adj[i][j].pass = 1;
adj[j][i].pass = 1;
}
}
}
// no more edges to remove? (TODO: leave SOME loops)
//printf("Cre size %d\n", cre.size() );
if (cre.size() == 0 ) {
break;
}
// do remove the edge
int ndx = random( cre.size() );
i = cre[ndx].a;
j = cre[ndx].b;
adj[i][j].pass = 0;
adj[j][i].pass = 0;
// draw in the blockage
if (adj[i][j].de) {
DualEdge *de = adj[i][j].de;
draw_blockers( bmpMap, bmpMtns, de->x1, de->y1, de->x2, de->y2 );
//line( bmpMap, de->x1, de->y1, de->x2, de->y2, makecol( 255,0,0) );
}
}
// draw the edges
for ( i=0; i < nloc; i++) {
for ( j=0; j < i; j++) {
if (adj[i][j].pass) {
draw_road( bmpMap, blankMap,
loc[i].xpos, loc[i].ypos,
loc[j].xpos, loc[j].ypos );
//line( bmpMap,
// loc[i].xpos, loc[i].ypos,
// loc[j].xpos, loc[j].ypos,
// makecol( 0,255,0 ) );
}
}
}
// draw the icons on the map
for ( i=0; i < nloc; i++) {
BITMAP *ico = mapIcons[loc[i].bgType];
int f=0;
if (ico->w > 64) {
f = random( ico->w / 64 );
}
masked_blit( ico, bmpMap, f*64,0,
loc[i].xpos - 32, loc[i].ypos - 32,
64, 64 );
}
destroy_bitmap( blankMap );
}
