예제 #1
0
/*--------------------------------------------------------------------------*/
void map_container::zoom_level_set(double factor)
{
	double zoom_delta = DBL_MAX;

	logstream_write("requested zoom, %f\n", factor);

	for (int i = 0; i < ZOOMS_SUPPORTED; i++)
	{
		double delta = zoom_table[i].zoom - factor;

		if ( delta < 0 )
			delta = -delta;

		if ( delta < zoom_delta)
		{
			logstream_write("selecting %f\n", zoom_table[i].zoom);

			zoom_current = i;
			zoom_delta = delta;
		}
	}
	
	
	map_info_update();
}
예제 #2
0
/*--------------------------------------------------------------------------*/
long map_container::map_width()
{
	double width = 0;
	
	width = image_ops.scale_dx(image, zoom_table[zoom_current].source);
	width *= zoom_table[zoom_current].factor;

	logstream_write("returning map width, %d\n",
					(long)mcround(width));
	
	return (long)mcround(width);
}
예제 #3
0
/*--------------------------------------------------------------------------*/
long map_container::map_height()
{
	double height = 0;
	
	height = image_ops.scale_dy(image, zoom_table[zoom_current].source);
	height *= zoom_table[zoom_current].factor;

	logstream_write("returning map height, %d\n",
					(long)mcround(height));
	
	return (long)mcround(height);
}
예제 #4
0
/*--------------------------------------------------------------------------*/
void map_container::zoom_in()
{
	if (zoom_current < ZOOMS_SUPPORTED - 1)
	{
		zoom_current++;
		
		logstream_write("requested zoom, %d\n",
				(long)(zoom_table[zoom_current].zoom * 100));
				
		map_info_update();
	}
}
예제 #5
0
/*--------------------------------------------------------------------------*/
void map_container::zoom_out()
{
	if (zoom_current)
	{
		zoom_current--;

		logstream_write("requested zoom, %d\n",
				(long)(zoom_table[zoom_current].zoom * 100));
		
		map_info_update();
	}
}
예제 #6
0
/*--------------------------------------------------------------------------*/
void map_container::ll_to_xy_onmap(double latitude, double longitude, long *x, long *y)
{
	double dbl_x, dbl_y;
	
	projection->ll_to_xy(&dbl_x, &dbl_y, longitude, latitude);

	*x = (long)mcround(dbl_x);
	*y = (long)mcround(dbl_y);

	logstream_write("converting ll to map xy, lat = %f, lon = %f, x = %d, y = %d\n",
					latitude, longitude, *x, *y);
}
예제 #7
0
/*--------------------------------------------------------------------------*/
long map_container::xy_onmap_to_ll(long x, long y, double* latitude, double* longitude)
{
	long r =
	projection->xy_to_ll(latitude, longitude,
						(double)x,
						(double)y);
			
	logstream_write("converting map xy to ll , x = %d, y = %d, lat = %f, lon = %f\n",
					x, y, *latitude, *longitude);
			
						
	return r;					
}
예제 #8
0
/*--------------------------------------------------------------------------*/
void map_container::ll_to_xy_on_tile(double latitude, double longitude, long *x, long *y)
{
	long map_x, map_y;
	long c, r;

	ll_to_xy_onmap(latitude, longitude, &map_x,	&map_y);
	
	ll_to_cr(latitude, longitude, &c, &r);

	*x = map_x - c * (64 * zoom_table[zoom_current].factor);
	*y = map_y - r * (64 * zoom_table[zoom_current].factor);
	
	logstream_write("converting ll to tile xy, lat = %f, lon = %f, x = %d, y = %d\n",
					latitude, longitude, *x, *y);
	
}
예제 #9
0
/*--------------------------------------------------------------------------*/
void map_container::ll_to_cr(double latitude, double longitude, long *c, long *r)
{
	long x, y;
	
	ll_to_xy_onmap(latitude, longitude, &x, &y);

	long tile_x = (abs)((long)mcround(x))/(64 * zoom_table[zoom_current].factor);
	long tile_y = (abs)((long)mcround(y))/(64 * zoom_table[zoom_current].factor);

	logstream_write("converting ll to cr, lat = %f, lon = %f, c = %d, r = %d\n",
					latitude, longitude, tile_x, tile_y);


	*c = tile_x;
	*r = tile_y;

}
예제 #10
0
/*--------------------------------------------------------------------------*/
ozf_stream* ozf_open(char* path)
{
	ozf_stream* s = NULL;
	
	FILE* f = fopen(path, "rb");
	
	logstream_write("ozf: opening %s\n", path);
	
	if (f)
	{
		logstream_write("ozf: %s opened\n", path);
	
		s = (ozf_stream*)malloc(sizeof(ozf_stream));
		memset(s, 0, sizeof(ozf_stream));
		
		s->file = f;
		s->type = OZF_STREAM_DEFAULT;
		fseek(f, 0, SEEK_END);
		s->size = ftell(f);
		
		logstream_write("ozf: stream size: %d bytes\n", s->size);
		
		// need to find more convenient way		
		if (strstr(path, ".ozfx3"))
		{
			logstream_write("ozf: %s is an encrypted stream\n", path);
		
			s->type = OZF_STREAM_ENCRYPTED;
			s->key	= ozf_calculate_key(s->file);
			
			logstream_write("ozf: stream key = %08x\n", s->key);

			ozf_init_encrypted_stream(s);			
		}
		else
		if (strstr(path, ".ozf2"))
		{
			logstream_write("ozf: %s is raw stream\n", path);
			ozf_init_raw_stream(s);			
		}
	}
	else
	{
		logstream_write("ozf: %s open fails\n", path);
	}
	
	return s;
}
예제 #11
0
/*----------------------------------------------------------------------------*/
void	wpt_container::load(const char* file)
{
	numpoints = 0;

	free(points);

	char *cur_locale=strdup(setlocale(LC_NUMERIC,NULL));
	setlocale(LC_NUMERIC,"C");

	points = (waypoint*)malloc(WAYPOINTS_MAX*sizeof(waypoint));
	memset(points, 0, WAYPOINTS_MAX*sizeof(waypoint));
	unsaved =  0;

	char szDatum[256];
	char szTemp[STRING_MAX];
	
	FILE *fp = fopen(file, "rt");
	
	if (!fp)
	{
		logstream_write("failed to open waypoint file\n");
		return;
	}

	fgets(szTemp, STRING_MAX, fp);
	szTemp[strlen(szTemp)-1] = 0;
	
	if ( !strncmp(szTemp, "OziExplorer Waypoint File", strlen("OziExplorer Waypoint File")) )
	{
		waypoint wpt;

		fgets(szTemp, STRING_MAX, fp);
		szTemp[strlen(szTemp)-1] = 0;

		strcpy(szDatum, szTemp);

		fgets(szTemp, STRING_MAX, fp);      // skipping
		fgets(szTemp, STRING_MAX, fp);      // skipping

		while ( 1 )
		{
			if(!fgets(szTemp, STRING_MAX, fp))
				break;

			memset(&wpt, 0, sizeof(waypoint));
			szTemp[strlen(szTemp)-1] = 0;

//			printf("i: %d\n", numpoints);

			char* pszThis;
			char* pszThat;

			// skipping number - for Lowrance/Eagles and Silva GPS receivers
			pszThis	= szTemp;
			pszThat	= strchr(pszThis, ',');

//			printf("1\n");

			// reading Name - the waypoint name
			pszThis	= pszThat + 1;
			pszThat = strchr(pszThis, ',');
			*pszThat = 0;
			strcpy(wpt.name, pszThis);
			
			int k = strlen(wpt.name)-1;
			
			while(wpt.name[k] == 0x20 && k)
			{
				wpt.name[k] = 0;
				k--;
			}
			
//			printf("wpt name: '%s'\n", wpt.name);

//			printf("2\n");

			// reading latitude
			pszThis	= pszThat + 1;
			pszThat = strchr(pszThis, ',');
			*pszThat = 0;

			wpt.lat = atof(pszThis);

//			printf("3\n");

			// reading longitude
			pszThis	= pszThat + 1;
			pszThat = strchr(pszThis, ',');
			*pszThat = 0;

			wpt.lon = atof(pszThis);

//			printf("4\n");

			// reading time
			pszThis	= pszThat + 1;
			pszThat = strchr(pszThis, ',');
			*pszThat = 0;

//			printf("5\n");


			double pascalDateTime = atof(pszThis);
        	time_t unixDateTime = (pascalDateTime - ((70*365L)+17 + 2)) * (24L*60*60);
			wpt.time = unixDateTime;

			// skipping 10 fields

//			printf("6\n");

#if 0
			pszThis	= pszThat + 1;
			for ( long i = 0; i < 9; i++ )
			{
				pszThat	= strchr(pszThis, ',');
				pszThis	= pszThat + 1;
			}

			pszThat = strchr(pszThis, ',');
			*pszThat = 0;

			wpt.alt = atol(pszThis);

			double height;
			
//			printf("wpt: %s: %f, %f\n", wpt.name, wpt.lat, wpt.lon);
#endif			
			if(numpoints >= WAYPOINTS_MAX - 1)
				break;

			memcpy(&points[numpoints], &wpt, sizeof(waypoint));
			points[numpoints].deleted = 0;
			points[numpoints].added = 0;
			
			numpoints++;

		}
	}
	setlocale(LC_NUMERIC,cur_locale);
	free(cur_locale);
	
	fclose(fp);
}
예제 #12
0
/*--------------------------------------------------------------------------*/
map_container::map_container(char* file)
{
	filename = (char*)malloc(strlen(file) + 1);
	strcpy(filename, file);
	
	zoom_current = 0;
	
	projection = NULL;
	calibration = maploader_openmap(filename);
	
	char imagefile[UL_NAME_MAX];

	logstream_write("map container: %s\n", calibration->image_path);
	logstream_write("map container: %s\n", calibration->image_file);
	
	strcpy(imagefile, calibration->image_path);
	strcat(imagefile, calibration->image_file);
	
	image_ops.open = img_open;
	image_ops.get_tile = img_get_tile;
	image_ops.num_scales = img_num_scales;
	image_ops.num_tiles_per_x = img_num_tiles_per_x;
	image_ops.num_tiles_per_y = img_num_tiles_per_y;
	image_ops.scale_dx = img_scale_dx;
	image_ops.scale_dy = img_scale_dy;
	image_ops.close = img_close;

	char* ext = imagefile + strlen(imagefile);
	
	do
	{
		ext--; 
		if (*ext == '.')
			break;
	} while (ext > imagefile);

	logstream_write("img: %s\n", imagefile);
	logstream_write("ext: %s\n", ext);

	if (!strcmp(ext, ".ozf") || !strcmp(ext, ".ozf2") ||
		!strcmp(ext, ".ozfx3"))
	{
		image_ops.open = ozf_open;
		image_ops.get_tile = ozf_get_tile;
		image_ops.num_scales = ozf_num_scales;
		image_ops.num_tiles_per_x = ozf_num_tiles_per_x;
		image_ops.num_tiles_per_y = ozf_num_tiles_per_y;
		image_ops.scale_dx = ozf_scale_dx;
		image_ops.scale_dy = ozf_scale_dy;
		image_ops.close = ozf_close;
	}
	
	
	image = image_ops.open(imagefile);
	
	build_zoom_table();

	zoom_level_set(1.0);

	map_info_update();
}
예제 #13
0
/*--------------------------------------------------------------------------*/
void map_container::build_zoom_table()
{
	zoom_table = (map_scale*)malloc(ZOOMS_SUPPORTED * sizeof(map_scale));
	memset(zoom_table, 0, ZOOMS_SUPPORTED * sizeof(map_scale));

	int scales = image_ops.num_scales(image);

	logstream_write("mapinfo: %d %d\n", calibration->width, calibration->height);
	logstream_write("building scales table\n");
	
	for (int i = 0; i < ZOOMS_SUPPORTED; i++)
	{
		int k = 0;
		double delta = DBL_MAX;
		double ozf_zoom;
		
		for (int j = 0; j < scales; j++)
		{
			int dx, dy;
		
			dx = image_ops.scale_dx(image, j);
			dy = image_ops.scale_dy(image, j);
		
			double a = dy;
			double b = calibration->height;
		
			double percents = (a / b) * 100;
			
			//percents = mcround(percents);
			
			double zoom = percents / 100;

			// if current zoom is < 100% - we need to select 
			// nearest upper native zoom
			// otherwize we need to select
			// any nearest zoom

			if (zoom_levels_supported[i] < 1.0)
				if (zoom_levels_supported[i] > zoom)
					continue;
			
			double d = zoom - zoom_levels_supported[i];
			
			d = d < 0 ? -d : d;
			
			if (d < delta)
			{
				delta = d;
				k = j;
				ozf_zoom = zoom;
			}
		}		
		

		zoom_table[i].zoom		= zoom_levels_supported[i];
		zoom_table[i].source	= k;
		zoom_table[i].factor	= zoom_levels_supported[i] / ozf_zoom;

		logstream_write("scale: %f, selected source scale: %f (%d), factor: %f\n", 
				zoom_table[i].zoom, ozf_zoom, k, zoom_table[i].zoom/ozf_zoom);
	}

}
예제 #14
0
/*--------------------------------------------------------------------------*/
void ozf_get_tile(ozf_stream* stream, int scale, int x, int y, unsigned char* data)
{
	ozf_stream* s = stream;

	long j;
	
	if (scale > s->scales - 1)
		return;
	
	if (x > s->images[scale].header.xtiles - 1)
		return;

	if (y > s->images[scale].header.ytiles - 1)
		return;
		
	if (x < 0)
		return;

	if (y < 0)
		return;
		
	
	long i = y * s->images[scale].header.xtiles + x;
		
	unsigned long tilesize =	s->images[scale].tiles_table[i+1] - 
								s->images[scale].tiles_table[i];

	unsigned char* tile = (unsigned char*)alloca(tilesize);
		
	fseek(s->file, s->images[scale].tiles_table[i], SEEK_SET);
	fread(tile, tilesize, 1, s->file);
	
	if (s->type == OZF_STREAM_ENCRYPTED)
	{
		if (s->images[scale].encryption_depth == -1)
			ozf_decode1(tile, tilesize, s->key);
		else
			ozf_decode1(tile, s->images[scale].encryption_depth, s->key);
	}
	
	if (!(tile[0] == 0x78 && tile[1] == 0xda))  // zlib signature
	{
		logstream_write("ozf: zlib signature verification failed\n");
		return;
	}
		
	unsigned long	decompressed_size = OZF_TILE_WIDTH * OZF_TILE_HEIGHT;
	unsigned char*	decompressed = (unsigned char*)alloca(decompressed_size);
		
	long n = ozf_decompress_tile((Bytef*)decompressed, (uLongf*)&decompressed_size,
			(const Bytef*)tile, (uLong)tilesize);
								
	unsigned char*	foo = data;
	unsigned char*	palette = (unsigned char*)s->images[scale].header.palette;
	
	for(j = 0; j < OZF_TILE_WIDTH * OZF_TILE_HEIGHT; j++)
	{
		unsigned char c = decompressed[j];
		
		// flipping image vertical
		int tile_y = (OZF_TILE_WIDTH - 1) - (j / OZF_TILE_WIDTH);
		int tile_x = j % OZF_TILE_WIDTH;
		int tile_z = tile_y * OZF_TILE_WIDTH + tile_x;
				
		unsigned char r = palette[c*4 + 2];
		unsigned char g = palette[c*4 + 1];
		unsigned char b = palette[c*4 + 0];
		unsigned char a = 255;
		
		// applying bgr -> rgba
		data[tile_z * 4 + 0] = r; // r
		data[tile_z * 4 + 1] = g; // g
		data[tile_z * 4 + 2] = b; // b
		data[tile_z * 4 + 3] = a; // a
	}
}
예제 #15
0
/*--------------------------------------------------------------------------*/
void ozf_init_raw_stream(ozf_stream* stream)
{
	ozf_stream* s = stream;

	unsigned long offset;
	unsigned long scales_table_offset;
	int i, j;
	
	logstream_write("ozf: processing raw stream\n");

	offset = 0;

	s->ozf2 = (ozf2_header*)malloc(sizeof(ozf2_header));
	
	fseek(s->file, offset, SEEK_SET);
	
	fread(&s->ozf2->magic, sizeof(short), 1, s->file); 
	fread(&s->ozf2->dummy1, sizeof(long), 1, s->file);
	fread(&s->ozf2->dummy2, sizeof(long), 1, s->file);
	fread(&s->ozf2->dummy3, sizeof(long), 1, s->file);
	fread(&s->ozf2->dummy4, sizeof(long), 1, s->file);

	fread(&s->ozf2->width, sizeof(long), 1, s->file);
	fread(&s->ozf2->height, sizeof(long), 1, s->file);

	fread(&s->ozf2->depth, sizeof(short), 1, s->file);
	fread(&s->ozf2->bpp, sizeof(short), 1, s->file);

	fread(&s->ozf2->dummy5, sizeof(long), 1, s->file);

	fread(&s->ozf2->memsiz, sizeof(long), 1, s->file); 

	fread(&s->ozf2->dummy6, sizeof(long), 1, s->file); 
	fread(&s->ozf2->dummy7, sizeof(long), 1, s->file); 
	fread(&s->ozf2->dummy8, sizeof(long), 1, s->file); 
	fread(&s->ozf2->version, sizeof(long), 1, s->file); 
	
	logstream_write("ozf: decoded ozf2 header: \n");
	logstream_write("\twidth:\t%d\n", s->ozf2->width);
	logstream_write("\theight:\t%d\n", s->ozf2->height);
	logstream_write("\tdepth:\t%d\n", s->ozf2->depth);
	logstream_write("\tbpp:\t%d\n", s->ozf2->bpp);

	offset = s->size - sizeof(long);
	
	fseek(s->file, offset, SEEK_SET);
	fread(&scales_table_offset, sizeof(long), 1, s->file);
	
	logstream_write("ozf: scales table starts at: %d\n", scales_table_offset);

 	s->scales = (s->size - scales_table_offset - sizeof(long)) / sizeof(long);

	logstream_write("ozf: scales total: %d\n", s->scales);

	s->scales_table = 
		(unsigned long*)malloc(s->scales * sizeof(unsigned long));
		
	s->images = 
		(ozf_image*)malloc(s->scales * sizeof(ozf_image));

	fseek(s->file, scales_table_offset, SEEK_SET);
	fread(s->scales_table, s->scales * sizeof(long), 1, s->file);
	
	for (i = 0; i < s->scales; i++)
	{
		unsigned char* tile;
	
		logstream_write("ozf: scale %d header starts at: %d\n", i, s->scales_table[i]);

		fseek(s->file, s->scales_table[i], SEEK_SET);
		
		fread(&s->images[i].header.width, sizeof(long), 1, s->file);
		fread(&s->images[i].header.height, sizeof(long), 1, s->file);
		fread(&s->images[i].header.xtiles, sizeof(short), 1, s->file);
		fread(&s->images[i].header.ytiles, sizeof(short), 1, s->file);
		fread(s->images[i].header.palette, sizeof(long)*256, 1, s->file);

		logstream_write("ozf: \twidth:\t%d\n", s->images[i].header.width);
		logstream_write("ozf: \theight:\t%d\n", s->images[i].header.height);
		logstream_write("ozf: \ttiles per x:\t%d\n", s->images[i].header.xtiles);
		logstream_write("ozf: \ttiles per y:\t%d\n", s->images[i].header.ytiles);
	
		s->images[i].tiles = s->images[i].header.xtiles * s->images[i].header.ytiles + 1;
		
		s->images[i].tiles_table = 
			(unsigned long*)malloc(s->images[i].tiles * sizeof(long));
		
		fread(s->images[i].tiles_table, s->images[i].tiles * sizeof(long), 1, s->file);
		
	}
}
예제 #16
0
/*--------------------------------------------------------------------------*/
void ozf_init_encrypted_stream(ozf_stream* stream)
{
	ozf_stream* s = stream;
	unsigned char bytes_per_infoblock;
	unsigned long offset;
	unsigned long scales_table_offset;
	int i, j;
	
	logstream_write("ozf: processing encrypted stream\n");

	fseek(s->file, OZFX3_MAGIC_OFFSET_0, SEEK_SET);
	fread(&bytes_per_infoblock, 1, 1, s->file);

	logstream_write("ozf: bytes per info block: %d\n", bytes_per_infoblock);

	offset =	OZFX3_MAGIC_OFFSET_1 + bytes_per_infoblock - 
				OZFX3_MAGIC_BLOCKLENGTH_0 + sizeof(long);

	s->ozf3 = (ozf3_header*)malloc(sizeof(ozf3_header));
	
	fseek(s->file, offset, SEEK_SET);
	
	fread(&s->ozf3->size, sizeof(long), 1, s->file);
	fread(&s->ozf3->width, sizeof(long), 1, s->file);
	fread(&s->ozf3->height, sizeof(long), 1, s->file);
	fread(&s->ozf3->depth, sizeof(short), 1, s->file);
	fread(&s->ozf3->bpp, sizeof(short), 1, s->file);
	
	ozf_decode1((unsigned char*)s->ozf3, sizeof(ozf3_header), s->key);

	logstream_write("ozf: decoded ozf3 header: \n");
	logstream_write("\tsize:\t%d\n", s->ozf3->size);
	logstream_write("\twidth:\t%d\n", s->ozf3->width);
	logstream_write("\theight:\t%d\n", s->ozf3->height);
	logstream_write("\tdepth:\t%d\n", s->ozf3->depth);
	logstream_write("\tbpp:\t%d\n", s->ozf3->bpp);

	offset = s->size - sizeof(long);
	
	fseek(s->file, offset, SEEK_SET);
	fread(&scales_table_offset, sizeof(long), 1, s->file);
	
	ozf_decode1((unsigned char*)&scales_table_offset, sizeof(long), s->key);

	logstream_write("ozf: scales table starts at: %d\n", scales_table_offset);

 	s->scales = (s->size - scales_table_offset - sizeof(long)) / sizeof(long);

	logstream_write("ozf: scales total: %d\n", s->scales);

	s->scales_table = 
		(unsigned long*)malloc(s->scales * sizeof(unsigned long));
		
	s->images = 
		(ozf_image*)malloc(s->scales * sizeof(ozf_image));

	fseek(s->file, scales_table_offset, SEEK_SET);
	fread(s->scales_table, s->scales * sizeof(long), 1, s->file);
	
	for (i = 0; i < s->scales; i++)
	{
		unsigned char* tile;
	
		ozf_decode1((unsigned char*)&s->scales_table[i], sizeof(long), s->key);

		logstream_write("ozf: scale %d header starts at: %d\n", i, s->scales_table[i]);

		fseek(s->file, s->scales_table[i], SEEK_SET);
		
		fread(&s->images[i].header.width, sizeof(long), 1, s->file);
		fread(&s->images[i].header.height, sizeof(long), 1, s->file);
		fread(&s->images[i].header.xtiles, sizeof(short), 1, s->file);
		fread(&s->images[i].header.ytiles, sizeof(short), 1, s->file);
		fread(s->images[i].header.palette, sizeof(long)*256, 1, s->file);
		
		ozf_decode1((unsigned char*)&s->images[i].header.width, sizeof(long), s->key);
		ozf_decode1((unsigned char*)&s->images[i].header.height, sizeof(long), s->key);
		ozf_decode1((unsigned char*)&s->images[i].header.xtiles, sizeof(short), s->key);
		ozf_decode1((unsigned char*)&s->images[i].header.ytiles, sizeof(short), s->key);

		logstream_write("ozf: \twidth:\t%d\n", s->images[i].header.width);
		logstream_write("ozf: \theight:\t%d\n", s->images[i].header.height);
		logstream_write("ozf: \ttiles per x:\t%d\n", s->images[i].header.xtiles);
		logstream_write("ozf: \ttiles per y:\t%d\n", s->images[i].header.ytiles);

		ozf_decode1((unsigned char*)s->images[i].header.palette, 1024, s->key);
	
		s->images[i].tiles = s->images[i].header.xtiles * s->images[i].header.ytiles + 1;
		
		s->images[i].tiles_table = 
			(unsigned long*)malloc(s->images[i].tiles * sizeof(long));
		
		fread(s->images[i].tiles_table, s->images[i].tiles * sizeof(long), 1, s->file);
		
		for (j = 0; j < s->images[i].tiles; j++)
		{
			unsigned long* p = &s->images[i].tiles_table[j];
			
			ozf_decode1((unsigned char*)p, sizeof(long), s->key);
			
		}
						
		unsigned long tilesize =	s->images[i].tiles_table[1] - 
									s->images[i].tiles_table[0];

		tile = (unsigned char*)malloc(tilesize);
		
		fseek(s->file, s->images[i].tiles_table[0], SEEK_SET);
		fread(tile, tilesize, 1, s->file);
											
		s->images[i].encryption_depth = 
			ozf_get_encyption_depth(tile, tilesize, s->key);
					
		free(tile);									

		logstream_write("ozf: \tencryption depth:\t%d\n", s->images[i].encryption_depth);
	}

}