예제 #1
0
void jffs_swap_inode(struct jffs_raw_inode *i)
{
  i->magic    = LONG_SWAP(i->magic);
  i->ino      = LONG_SWAP(i->ino);
  i->pino     = LONG_SWAP(i->pino);
  i->version  = LONG_SWAP(i->version);
  i->mode     = LONG_SWAP(i->mode);
  i->uid      = WORD_SWAP(i->uid);
  i->gid      = WORD_SWAP(i->gid);
  i->atime    = LONG_SWAP(i->atime);
  i->mtime    = LONG_SWAP(i->mtime);
  i->ctime    = LONG_SWAP(i->ctime);
  i->offset   = LONG_SWAP(i->offset);
  i->dsize    = LONG_SWAP(i->dsize);
  i->rsize    = LONG_SWAP(i->rsize);
  i->nsize    = BYTE_SWAP(i->nsize);
  i->nlink    = BYTE_SWAP(i->nlink);
#if 0 /* damn bit fields, lucky its a byte */
  i->spare    = BYTE_SWAP(i->spare : 6);
  i->rename   = BYTE_SWAP(i->rename : 1);
  i->deleted  = BYTE_SWAP(i->deleted : 1);
#endif
  i->accurate = BYTE_SWAP(i->accurate);
  i->dchksum  = LONG_SWAP(i->dchksum);
  i->nchksum  = WORD_SWAP(i->nchksum);
  i->chksum   = WORD_SWAP(i->chksum);
}
예제 #2
0
static int read_inode_bitmap (struct super_block * sb,
			      unsigned long block_group,
			      unsigned int bitmap_nr)
{
	struct ext2_group_desc * gdp;
	struct buffer_head * bh;
	int retval = 0;
	int bs = BYTE_SWAP(sb->u.ext2_sb.s_byte_swapped);

	gdp = get_group_desc (sb, block_group, NULL);
	bh = bread (sb->s_dev, e_swab (bs, gdp->bg_inode_bitmap),
		    sb->s_blocksize);
	if (!bh) {
		ext2_error (sb, "read_inode_bitmap",
			    "Cannot read inode bitmap - "
			    "block_group = %lu, inode_bitmap = %lu",
			    block_group,
			    (unsigned long) e_swab (bs, gdp->bg_inode_bitmap));
		retval = -EIO;
	}
	/*
	 * On IO error, just leave a zero in the superblock's block pointer for
	 * this group.  The IO will be retried next time.
	 */
	sb->u.ext2_sb.s_inode_bitmap_number[bitmap_nr] = block_group;
	sb->u.ext2_sb.s_inode_bitmap[bitmap_nr] = bh;
	return retval;
}
예제 #3
0
static void do_byteswap(unsigned char *buf, int len)
{
    unsigned short wVal, *ptr;
    int i=0;

    while (len > 0) {
        len -= 2;
        ptr = (unsigned short *)&buf[2*i];
        wVal = *ptr;
        *ptr = BYTE_SWAP( wVal );
        i++;
    }
}
예제 #4
0
unsigned long ext2_count_free_inodes (struct super_block * sb)
{
#ifdef EXT2FS_DEBUG
	struct ext2_super_block * es;
	unsigned long desc_count, bitmap_count, x;
	int bitmap_nr;
	struct ext2_group_desc * gdp;
	int i, bs;

	lock_super (sb);
	es = sb->u.ext2_sb.s_es;
	bs = BYTE_SWAP(sb->u.ext2_sb.s_byte_swapped);
	desc_count = 0;
	bitmap_count = 0;
	gdp = NULL;
	for (i = 0; i < sb->u.ext2_sb.s_groups_count; i++) {
		gdp = get_group_desc (sb, i, NULL);
		desc_count += e_swab (bs, gdp->bg_free_inodes_count);
		bitmap_nr = load_inode_bitmap (sb, i);
		if (bitmap_nr < 0)
			continue;
		
		x = ext2_count_free (sb->u.ext2_sb.s_inode_bitmap[bitmap_nr],
				     EXT2_INODES_PER_GROUP(sb) / 8);
		printk ("group %d: stored = %d, counted = %lu\n",
			i, e_swab (bs, gdp->bg_free_inodes_count), x);
		bitmap_count += x;
	}
	printk("ext2_count_free_inodes: stored = %lu, computed = %lu, %lu\n",
		e_swab (bs, es->s_free_inodes_count), desc_count, bitmap_count);
	unlock_super (sb);
	return desc_count;
#else
	return e_swab (BYTE_SWAP(sb->u.ext2_sb.s_byte_swapped),
		       sb->u.ext2_sb.s_es->s_free_inodes_count);
#endif
}
예제 #5
0
static int nmi_wlan_parse_info_frame(uint8_t *info, int size)
{
	nmi_mac_cfg_t *pd = (nmi_mac_cfg_t *)&g_mac;
	uint32_t wid, len;
	int type = NMI_CFG_RSP_STATUS;

	wid = info[0] | (info[1] << 8);
#if 0
#ifdef BIG_ENDIAN
	wid = BYTE_SWAP(wid);
#endif
#endif

	len = info[2];
	PRINT_INFO(GENERIC_DBG,"Status Len = %d Id= %d\n",len,wid);
	if ((len == 1) && (wid == WID_STATUS)) {
		pd->mac_status = info[3];
		type = NMI_CFG_RSP_STATUS;
	}

	return type;
}
예제 #6
0
void ext2_check_inodes_bitmap (struct super_block * sb)
{
	struct ext2_super_block * es;
	unsigned long desc_count, bitmap_count, x;
	int bitmap_nr;
	struct ext2_group_desc * gdp;
	int i, bs;

	lock_super (sb);
	bs = BYTE_SWAP(sb->u.ext2_sb.s_byte_swapped);
	es = sb->u.ext2_sb.s_es;
	desc_count = 0;
	bitmap_count = 0;
	gdp = NULL;
	for (i = 0; i < sb->u.ext2_sb.s_groups_count; i++) {
		gdp = get_group_desc (sb, i, NULL);
		desc_count += e_swab (bs, gdp->bg_free_inodes_count);
		bitmap_nr = load_inode_bitmap (sb, i);
		if (bitmap_nr < 0)
			continue;
		
		x = ext2_count_free (sb->u.ext2_sb.s_inode_bitmap[bitmap_nr],
				     EXT2_INODES_PER_GROUP(sb) / 8);
		if (e_swab (bs, gdp->bg_free_inodes_count) != x)
			ext2_error (sb, "ext2_check_inodes_bitmap",
				    "Wrong free inodes count in group %d, "
				    "stored = %d, counted = %lu", i,
				    e_swab (bs, gdp->bg_free_inodes_count), x);
		bitmap_count += x;
	}
	if (e_swab (bs, es->s_free_inodes_count) != bitmap_count)
		ext2_error (sb, "ext2_check_inodes_bitmap",
			    "Wrong free inodes count in super block, "
			    "stored = %lu, counted = %lu",
			    (unsigned long) e_swab (bs, es->s_free_inodes_count),
			    bitmap_count);
	unlock_super (sb);
}
예제 #7
0
파일: grav.c 프로젝트: burnsba/grav_map
int main(int argc , char *argv[])
{
	// bitmap file and header information
	bitmap* bmp = new_bitmap();
	
	// RGB pixel data
	bitmap_pixel pixel;
	
	// current column out of all possible columns in output
	uint32_t current_output_column = 0;
	
	// current row out of all possible rows in output
	uint32_t current_output_row = 0;
	
	// current read position of the source line; should
	// only vary from 0 to number of columns in row.
	uint32_t source_row_x = 0;
	
	// starting output position of the bitmap pixel data
	uint32_t file_offset = bmp->bitmap_file_header.fileoffset_to_pixelarray;
	
	// value read from input source
	int16_t read_value;
	
	#ifdef DEBUG
	int16_t min_read = 0;
	int16_t max_read = 0;
	print_bitmap_info(bmp);
	printf("OUTPUT_ROW_BYTES: %u\n", OUTPUT_ROW_BYTES);
	printf("OUTPUT_ROW_BYTES_WITHOUT_PADDING: %u\n", OUTPUT_ROW_BYTES_WITHOUT_PADDING);
	printf("OUTPUT_RAW_SINGLE_UNITS: %u\n", OUTPUT_RAW_SINGLE_UNITS);
	#endif
	
	FILE* output_file = fopen(OUTPUT_FILE_PATH,"wb+");
	FILE* input_file = fopen(INPUT_FILE_PATH, "r");
	
	// Done with the bitmap information, write that to output. All remaining
	// pixel data comes afterwards which doesn't depend on any of the header
	// information.
	fwrite(bmp, 1, sizeof(bitmap), output_file);
	free(bmp);
	
	// for each output that needs to be written ...
	int i=0;
	while(i < OUTPUT_RAW_SINGLE_UNITS)
	{
		// If this is the end of the row, write the bitmap padding,
		// advance the row, and reset the column position. Additionally,
		// since no data was read from the source, don't increment counter.
		if (current_output_column + PIXEL_BYTES > OUTPUT_ROW_BYTES_WITHOUT_PADDING)
		{
			write_bitmap_row_padding(output_file);

			current_output_column = 0;
			current_output_row += INVERSE_SCALE;
			source_row_x = 0;

			continue;
		}
		
		// seek to next altimetry reading
		fseek(input_file, (current_output_row * NLON) + source_row_x, 0);
		
		// read value
		fread(&read_value, 1, 2, input_file);
		
		// fix endieness
		read_value = BYTE_SWAP(read_value);
		
		// convert to RGB value
		z_to_pixel(read_value, &pixel);

		// write to output
		bitmap_write_pixel(output_file, pixel);

		// increment counters
		source_row_x += INVERSE_SCALE;		
		current_output_column += PIXEL_BYTES;
		i++;
		
		#ifdef DEBUG
		if (read_value < min_read)
		{
			min_read = read_value;
		}
		if (read_value > max_read)
		{
			max_read = read_value;
		}
		#endif
	}
	
	// write last padding pixels (if necessary)
	if (current_output_column > OUTPUT_ROW_BYTES_WITHOUT_PADDING)
	{
		write_bitmap_row_padding(output_file);
	}
	
	fclose(output_file);
	fclose(input_file);
	
	#ifdef DEBUG
	printf("min value read: %d\n", min_read);
	printf("max value read: %d\n", max_read);
	#endif
	
	return 0;
}
예제 #8
0
byte *gltLoadTGA(const char *file, int *iWidth, int *iHeight, int *iComponents, int *eFormat)
{
	FILE		*pFile;			// File pointer
	TGAHEADER	tgaHeader;		// TGA file header
	unsigned long	lImageSize;		// Size in bytes of image
	short		sDepth;			// Pixel depth;
	byte		*pBits;          // Pointer to bits

	// Default/Failed values
	*iWidth = 0;
	*iHeight = 0;
#ifndef DIRECTX
	*eFormat = GL_BGR_EXT;
	*iComponents = GL_RGB8;
#endif

	// Attempt to open the file
	pFile = fopen(file, "rb");
	if(pFile == NULL)
		return NULL;

	// Read in header (binary)
	fread(&tgaHeader, 18/* sizeof(TGAHEADER)*/, 1, pFile);

	// Do byte swap for big vs little endian
	#ifdef __APPLE__
		BYTE_SWAP(tgaHeader.colorMapStart);
		BYTE_SWAP(tgaHeader.colorMapLength);
		BYTE_SWAP(tgaHeader.xstart);
		BYTE_SWAP(tgaHeader.ystart);
		BYTE_SWAP(tgaHeader.width);
		BYTE_SWAP(tgaHeader.height);
	#endif


	// Get width, height, and depth of texture
	*iWidth = tgaHeader.width;
	*iHeight = tgaHeader.height;
	sDepth = tgaHeader.bits / 8;
    
	if(tgaHeader.bits != 8 && tgaHeader.bits != 24 && tgaHeader.bits != 32)
		return NULL;

	lImageSize = tgaHeader.width * tgaHeader.height * sDepth;

	pBits = new byte [lImageSize * sizeof(byte)];
	if(pBits == NULL)
		return NULL;

	if(fread(pBits, lImageSize, 1, pFile) != 1)
	{
		delete [] pBits;
		return NULL;
	}
	fclose(pFile);

	// Set OpenGL format expected
#ifndef DIRECTX
	switch(sDepth)
	{
	case 3:     // Most likely case
		*eFormat = GL_BGR_EXT;
		*iComponents = GL_RGB8;
		break;
	case 4:
		*eFormat = GL_BGRA_EXT;
		*iComponents = GL_RGBA8;
		break;
	case 1:
		*eFormat = GL_LUMINANCE;
		*iComponents = GL_LUMINANCE8;
		break;
	};
#else
	switch(sDepth)
	{
	case 3:
		*eFormat = 3;
		*iComponents = 3;
		break;
	case 4:
		*eFormat = 4;
		*iComponents = 4;
		break;
	case 1:
		*eFormat = 1;
		*iComponents = 1;
		break;
	};

	//directx does not support 24 bit bitmaps conver to 32bit
	if (*eFormat == 3)
	{
		byte *pNewBits;

		*eFormat = 4;
		*iComponents = 4;
		pNewBits = tga_24to32(tgaHeader.width, tgaHeader.height, pBits);
		delete [] pBits;
		return pNewBits;
	}
#endif
	return pBits;
}
예제 #9
0
//	Loads the texture from the specified file and stores it in iTexture. Note
//	that we're using the GLAUX library here, which is generally discouraged,
//	but in this case spares us having to write a bitmap loading routine.
void LoadTexture(char *filename, GLuint &texture)
{
	#pragma pack(1)
	struct TGAHEADER
	{
		GLbyte	identsize;              // Size of ID field that follows header (0)
		GLbyte	colorMapType;           // 0 = None, 1 = paletted
		GLbyte	imageType;              // 0 = none, 1 = indexed, 2 = rgb, 3 = grey, +8=rle
		unsigned short	colorMapStart;  // First colour map entry
		unsigned short	colorMapLength; // Number of colors
		unsigned char 	colorMapBits;   // bits per palette entry
		unsigned short	xstart;         // image x origin
		unsigned short	ystart;         // image y origin
		unsigned short	width;          // width in pixels
		unsigned short	height;         // height in pixels
		GLbyte	bits;                   // bits per pixel (8 16, 24, 32)
		GLbyte	descriptor;             // image descriptor
	};
	#pragma pack(8)

	#define BYTE_SWAP(x) x = ((x) >> 8) + ((x) << 8)


	FILE *pFile;				// File pointer
	TGAHEADER tgaHeader;		// TGA file header
	unsigned lImageSize;		// Size in bytes of image
	short sDepth;				// Pixel depth;
	GLbyte	*pBits = NULL;      // Pointer to bits
	char fullPathName[256];
	
	GLint iWidth;
	GLint iHeight;
	GLint iComponents;
	GLenum eFormat;
    
    // Default/Failed values
    eFormat = GL_RGBA;
    iComponents = GL_RGB8;

	texture = 0;
	
	#ifdef _MSC_VER		
		sprintf (fullPathName, "%s", filename);
	#else
		sprintf (fullPathName, "../../../%s", filename);
	#endif	
	
    // Attempt to open the fil
    pFile = fopen(fullPathName, "rb");
    if(pFile == NULL) {
		return;
	}
    
	  _ASSERTE (sizeof (TGAHEADER) == 18);
    // Read in header (binary) // sizeof(TGAHEADER) = 18
    fread(&tgaHeader, 18, 1, pFile);
    
    // Do byte swap for big vs little endian
	#ifndef _M_IX86
		BYTE_SWAP(tgaHeader.colorMapStart);
		BYTE_SWAP(tgaHeader.colorMapLength);
		BYTE_SWAP(tgaHeader.xstart);
		BYTE_SWAP(tgaHeader.ystart);
		BYTE_SWAP(tgaHeader.width);
		BYTE_SWAP(tgaHeader.height);
	#endif


        
    // Get width, height, and depth of texture
    iWidth = tgaHeader.width;
    iHeight = tgaHeader.height;
    sDepth = tgaHeader.bits / 8;

    
    // Put some validity checks here. Very simply, I only understand
    // or care about 8, 24, or 32 bit targa's.
    if(tgaHeader.bits != 8 && tgaHeader.bits != 24 && tgaHeader.bits != 32) {
		fclose(pFile);
		return;
	}


    // Calculate size of image buffer
    lImageSize = tgaHeader.width * tgaHeader.height * sDepth;
    
    // Allocate memory and check for success
    pBits = (GLbyte *)malloc(lImageSize * sizeof(GLbyte));
    if(pBits == NULL) {
		fclose(pFile);
		return;
	}


    
    // Read in the bits
    // Check for read error. This should catch RLE or other 
    // weird formats that I don't want to recognize
    if(fread(pBits, lImageSize, 1, pFile) != 1)  {
		fclose(pFile);
        free(pBits);
        return;
   }

    
    // Set OpenGL format expected
	#ifdef _M_IX86
		switch(sDepth)
		{
			case 3:     // Most likely case
				eFormat = GL_RGB;
				iComponents = GL_RGB8;
				break;
			case 4:
				eFormat = GL_BGRA_EXT;
				iComponents = GL_RGBA8;
				break;
			case 1:
				eFormat = GL_LUMINANCE;
				iComponents = GL_LUMINANCE8;
				break;
		};
	#else
		switch(sDepth)
		{
			case 3:     // Most likely case
				eFormat = GL_RGBA;
				iComponents = GL_RGB8;
				break;
			case 4:
				eFormat = GL_BGRA;
				iComponents = GL_RGBA8;
				break;
			case 1:
				eFormat = GL_LUMINANCE;
				iComponents = GL_LUMINANCE8;
				break;
		};	
	#endif
        

	glGenTextures(1, &texture);
	glBindTexture(GL_TEXTURE_2D, texture);
			
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	glTexImage2D(GL_TEXTURE_2D, 0, iComponents, iWidth, iHeight, 0, eFormat, GL_UNSIGNED_BYTE, pBits);

    // Done with File
    fclose(pFile);
	free(pBits);        

} 
예제 #10
0
static void nmi_wlan_parse_response_frame(uint8_t *info, int size)
{
	uint32_t wid, len=0, i;
	static int seq = 0;

	while (size>0) {
		i = 0;
		wid = info[0] | (info[1] << 8);
#ifdef BIG_ENDIAN
		wid = BYTE_SWAP(wid);
#endif
		PRINT_INFO(GENERIC_DBG,"Processing response for %d seq %d\n",wid,seq++);
		switch ((wid >> 12) & 0x7) {
		case WID_CHAR:
			do {
				if (g_cfg_byte[i].id == WID_NIL)
					break;

				if (g_cfg_byte[i].id == wid) {
					g_cfg_byte[i].val = info[3];
					break;
				} 
				i++;
			} while (1);
			len = 2;
			break;
		case WID_SHORT:
			do {
				if (g_cfg_hword[i].id == WID_NIL)
					break;

				if (g_cfg_hword[i].id == wid) {
#ifdef BIG_ENDIAN
					g_cfg_hword[i].val = (info[3]<<8)|(info[4]);
#else
					g_cfg_hword[i].val = info[3]|(info[4]<<8);
#endif
					break;
				} 
				i++;
			} while (1);
			len = 3;
			break;
		case WID_INT:
			do {
				if (g_cfg_word[i].id == WID_NIL)
					break;

				if (g_cfg_word[i].id == wid) {
#ifdef BIG_ENDIAN
					g_cfg_word[i].val = (info[3]<<24)|(info[4]<<16)|(info[5]<<8)|(info[6]);
#else
					g_cfg_word[i].val = info[3]|(info[4]<<8)|(info[5]<<16)|(info[6]<<24);
#endif
					break;
				} 
				i++;
			} while (1);
			len = 5;
			break;
		case WID_STR:
			do {
				if (g_cfg_str[i].id == WID_NIL)
					break;

				if (g_cfg_str[i].id == wid) {
					if(wid == WID_SITE_SURVEY_RESULTS)
					{
						static int toggle = 0;
						PRINT_INFO(GENERIC_DBG,"Site survey results received[%d]\n",
								size);

						PRINT_INFO(GENERIC_DBG,"Site survey results value[%d]toggle[%d]\n",size,toggle);
						i += toggle;
						toggle ^= 1;
					}
					memcpy(g_cfg_str[i].str, &info[2], (info[2]+1));
					break;
				} 
				i++;
			} while (1);
			len = 1+info[2];
			break;
		default:
			break;
		}
		size -= (2 + len);
		info += (2 + len);
	}

	return;
}
예제 #11
0
파일: LoadTGA.c 프로젝트: rAseri/opengl
////////////////////////////////////////////////////////////////////
// Allocate memory and load targa bits. Returns pointer to new buffer,
// height, and width of texture, and the OpenGL format of data.
// Call free() on buffer when finished!
// This only works on pretty vanilla targas... 8, 24, or 32 bit color
// only, no palettes, no RLE encoding.
GLbyte *gltLoadTGA(const char *szFileName, GLint *iWidth, GLint *iHeight, GLint *iComponents, GLenum *eFormat)
{
	FILE *pFile;			// File pointer
	TGAHEADER tgaHeader;		// TGA file header
	unsigned long lImageSize;		// Size in bytes of image
	short sDepth;			// Pixel depth;
	GLbyte	*pBits = NULL;          // Pointer to bits

	// Default/Failed values
	*iWidth = 0;
	*iHeight = 0;
	*eFormat = GL_BGR_EXT;
	*iComponents = GL_RGB8;

	// Attempt to open the fil
	pFile = fopen(szFileName, "rb");
	if (pFile == NULL)
		return NULL;

	// Read in header (binary)
	fread(&tgaHeader, 18/* sizeof(TGAHEADER)*/, 1, pFile);

	// Do byte swap for big vs little endian
#ifdef __APPLE__
	BYTE_SWAP(tgaHeader.colorMapStart);
	BYTE_SWAP(tgaHeader.colorMapLength);
	BYTE_SWAP(tgaHeader.xstart);
	BYTE_SWAP(tgaHeader.ystart);
	BYTE_SWAP(tgaHeader.width);
	BYTE_SWAP(tgaHeader.height);
#endif


	// Get width, height, and depth of texture
	*iWidth = tgaHeader.width;
	*iHeight = tgaHeader.height;
	sDepth = tgaHeader.bits / 8;

	// Put some validity checks here. Very simply, I only understand
	// or care about 8, 24, or 32 bit targa's.
	if (tgaHeader.bits != 8 && tgaHeader.bits != 24 && tgaHeader.bits != 32)
		return NULL;

	// Calculate size of image buffer
	lImageSize = tgaHeader.width * tgaHeader.height * sDepth;

	// Allocate memory and check for success
	pBits = malloc(lImageSize * sizeof(GLbyte));
	if (pBits == NULL)
		return NULL;

	// Read in the bits
	// Check for read error. This should catch RLE or other 
	// weird formats that I don't want to recognize
	if (fread(pBits, lImageSize, 1, pFile) != 1)
	{
		free(pBits);
		return NULL;
	}

	// Set OpenGL format expected
	switch (sDepth)
	{
	case 3:     // Most likely case
		*eFormat = GL_BGR_EXT;
		*iComponents = GL_RGB8;
		break;
	case 4:
		*eFormat = GL_BGRA_EXT;
		*iComponents = GL_RGBA8;
		break;
	case 1:
		*eFormat = GL_LUMINANCE;
		*iComponents = GL_LUMINANCE8;
		break;
	};


	// Done with File
	fclose(pFile);

	// Return pointer to image data
	return pBits;
}
예제 #12
0
////////////////////////////////////////////////////////////////////
// Capture the current viewport and save it as a targa file.
// Be sure and call SwapBuffers for double buffered contexts or
// glFinish for single buffered contexts before calling this function.
// Returns 0 if an error occurs, or 1 on success.
GLint gltWriteTGA(const char *szFileName)
{
	FILE *pFile;                // File pointer
	TGAHEADER tgaHeader;        // TGA file header
	unsigned long lImageSize;   // Size in bytes of image
	GLbyte    *pBits = NULL;      // Pointer to bits
	GLint iViewport[4];         // Viewport in pixels
	GLint lastBuffer;          // Storage for the current read buffer setting
    
	// Get the viewport dimensions
	glGetIntegerv(GL_VIEWPORT, iViewport);

	// How big is the image going to be (targas are tightly packed)
	lImageSize = iViewport[2] * 3 * iViewport[3];    

	// Allocate block. If this doesn't work, go home
	pBits = (GLbyte *)malloc(lImageSize);
	if(pBits == NULL)
		return 0;

	// Read bits from color buffer
	glPixelStorei(GL_PACK_ALIGNMENT, 1);
	glPixelStorei(GL_PACK_ROW_LENGTH, 0);
	glPixelStorei(GL_PACK_SKIP_ROWS, 0);
	glPixelStorei(GL_PACK_SKIP_PIXELS, 0);
    
	// Get the current read buffer setting and save it. Switch to
	// the front buffer and do the read operation. Finally, restore
	// the read buffer state
	glGetIntegerv(GL_READ_BUFFER, &lastBuffer);
	glReadBuffer(GL_FRONT);
	glReadPixels(0, 0, iViewport[2], iViewport[3], GL_BGR_EXT, GL_UNSIGNED_BYTE, pBits);
	glReadBuffer(lastBuffer);
    
	// Initialize the Targa header
	tgaHeader.identsize = 0;
	tgaHeader.colorMapType = 0;
	tgaHeader.imageType = 2;
	tgaHeader.colorMapStart = 0;
	tgaHeader.colorMapLength = 0;
	tgaHeader.colorMapBits = 0;
	tgaHeader.xstart = 0;
	tgaHeader.ystart = 0;
	tgaHeader.width = iViewport[2];
	tgaHeader.height = iViewport[3];
	tgaHeader.bits = 24;
	tgaHeader.descriptor = 0;
    
	// Do byte swap for big vs little endian
	#ifdef __APPLE__
	BYTE_SWAP(tgaHeader.colorMapStart);
	BYTE_SWAP(tgaHeader.colorMapLength);
	BYTE_SWAP(tgaHeader.xstart);
	BYTE_SWAP(tgaHeader.ystart);
	BYTE_SWAP(tgaHeader.width);
	BYTE_SWAP(tgaHeader.height);
	#endif
    
	// Attempt to open the file
	pFile = fopen(szFileName, "wb");
	if(pFile == NULL)
	{
		free(pBits);    // Free buffer and return error
		return 0;
	}
    
	// Write the header
	fwrite(&tgaHeader, sizeof(TGAHEADER), 1, pFile);
    
	// Write the image data
	fwrite(pBits, lImageSize, 1, pFile);
              
	// Free temporary buffer and close the file
	free(pBits);    
	fclose(pFile);
    
	// Success!
	return 1;
}
예제 #13
0
/*
 * There are two policies for allocating an inode.  If the new inode is
 * a directory, then a forward search is made for a block group with both
 * free space and a low directory-to-inode ratio; if that fails, then of
 * the groups with above-average free space, that group with the fewest
 * directories already is chosen.
 *
 * For other inodes, search forward from the parent directory\'s block
 * group to find a free inode.
 */
struct inode * ext2_new_inode (const struct inode * dir, int mode, int * err)
{
	struct super_block * sb;
	struct buffer_head * bh;
	struct buffer_head * bh2;
	int i, j, avefreei;
	struct inode * inode;
	int bitmap_nr;
	int bs;
	struct ext2_group_desc * gdp;
	struct ext2_group_desc * tmp;
	struct ext2_super_block * es;

	if (!dir || !(inode = get_empty_inode ()))
	{
		*err=-ENOMEM;
		return NULL;
	}
	sb = dir->i_sb;
	inode->i_sb = sb;
	inode->i_flags = sb->s_flags;
	lock_super (sb);
	bs = BYTE_SWAP(sb->u.ext2_sb.s_byte_swapped);
	es = sb->u.ext2_sb.s_es;
repeat:
	gdp = NULL; i=0;
	
	*err = -ENOSPC;
	if (S_ISDIR(mode)) {
		avefreei = e_swab (bs, es->s_free_inodes_count) /
			sb->u.ext2_sb.s_groups_count;
/* I am not yet convinced that this next bit is necessary.
		i = dir->u.ext2_i.i_block_group;
		for (j = 0; j < sb->u.ext2_sb.s_groups_count; j++) {
			tmp = get_group_desc (sb, i, &bh2);
			if ((e_swab (bs, tmp->bg_used_dirs_count) << 8) < 
			    e_swab (bs, tmp->bg_free_inodes_count)) {
				gdp = tmp;
				break;
			}
			else
			i = ++i % sb->u.ext2_sb.s_groups_count;
		}
*/
		if (!gdp) {
			for (j = 0; j < sb->u.ext2_sb.s_groups_count; j++) {
				tmp = get_group_desc (sb, j, &bh2);
				if (e_swab (bs, tmp->bg_free_inodes_count) &&
					e_swab (bs, tmp->bg_free_inodes_count) >= avefreei) {
					if (!gdp || 
					    (e_swab (bs, tmp->bg_free_blocks_count) >
					     e_swab (bs, gdp->bg_free_blocks_count))) {
						i = j;
						gdp = tmp;
					}
				}
			}
		}
	}
	else 
	{
		/*
		 * Try to place the inode in its parent directory
		 */
		i = dir->u.ext2_i.i_block_group;
		tmp = get_group_desc (sb, i, &bh2);
		if (tmp->bg_free_inodes_count)
			gdp = tmp;
		else
		{
			/*
			 * Use a quadratic hash to find a group with a
			 * free inode
			 */
			for (j = 1; j < sb->u.ext2_sb.s_groups_count; j <<= 1) {
				i += j;
				if (i >= sb->u.ext2_sb.s_groups_count)
					i -= sb->u.ext2_sb.s_groups_count;
				tmp = get_group_desc (sb, i, &bh2);
				if (tmp->bg_free_inodes_count) {
					gdp = tmp;
					break;
				}
			}
		}
		if (!gdp) {
			/*
			 * That failed: try linear search for a free inode
			 */
			i = dir->u.ext2_i.i_block_group + 1;
			for (j = 2; j < sb->u.ext2_sb.s_groups_count; j++) {
				if (++i >= sb->u.ext2_sb.s_groups_count)
					i = 0;
				tmp = get_group_desc (sb, i, &bh2);
				if (tmp->bg_free_inodes_count) {
					gdp = tmp;
					break;
				}
			}
		}
	}

	if (!gdp) {
		unlock_super (sb);
		iput(inode);
		return NULL;
	}
	bitmap_nr = load_inode_bitmap (sb, i);
	if (bitmap_nr < 0) {
		unlock_super (sb);
		iput(inode);
		*err = -EIO;
		return NULL;
	}
	
	bh = sb->u.ext2_sb.s_inode_bitmap[bitmap_nr];
	if ((j = ext2_find_first_zero_bit ((unsigned long *) bh->b_data,
				      EXT2_INODES_PER_GROUP(sb))) <
	    EXT2_INODES_PER_GROUP(sb)) {
		if (ext2_set_bit (j, bh->b_data)) {
			ext2_warning (sb, "ext2_new_inode",
				      "bit already set for inode %d", j);
			goto repeat;
		}
		mark_buffer_dirty(bh, 1);
		if (sb->s_flags & MS_SYNCHRONOUS) {
			ll_rw_block (WRITE, 1, &bh);
			wait_on_buffer (bh);
		}
	} else {
		if (gdp->bg_free_inodes_count != 0) {
			ext2_error (sb, "ext2_new_inode",
				    "Free inodes count corrupted in group %d",
				    i);
			unlock_super (sb);
			iput (inode);
			return NULL;
		}
		goto repeat;
	}
	j += i * EXT2_INODES_PER_GROUP(sb) + 1;
	if (j < EXT2_FIRST_INO(sb) || j > e_swab (bs, es->s_inodes_count)) {
		ext2_error (sb, "ext2_new_inode",
			    "reserved inode or inode > inodes count - "
			    "block_group = %d,inode=%d", i, j);
		unlock_super (sb);
		iput (inode);
		return NULL;
	}
	e_set_swab (bs, gdp->bg_free_inodes_count,
		    e_swab (bs, gdp->bg_free_inodes_count) - 1);
	if (S_ISDIR(mode))
		e_set_swab (bs, gdp->bg_used_dirs_count,
			    e_swab (bs, gdp->bg_used_dirs_count) + 1);
	mark_buffer_dirty(bh2, 1);
	e_set_swab (bs, es->s_free_inodes_count,
		    e_swab (bs, es->s_free_inodes_count) - 1);
	mark_buffer_dirty(sb->u.ext2_sb.s_sbh, 1);
	sb->s_dirt = 1;
	inode->i_mode = mode;
	inode->i_sb = sb;
	inode->i_count = 1;
	inode->i_nlink = 1;
	inode->i_dev = sb->s_dev;
	inode->i_uid = current->fsuid;
	if (test_opt (sb, GRPID))
		inode->i_gid = dir->i_gid;
	else if (dir->i_mode & S_ISGID) {
		inode->i_gid = dir->i_gid;
		if (S_ISDIR(mode))
			mode |= S_ISGID;
	} else
		inode->i_gid = current->fsgid;
	inode->i_dirt = 1;
	inode->i_ino = j;
	inode->i_blksize = PAGE_SIZE;	/* This is the optimal IO size (for stat), not the fs block size */
	inode->i_blocks = 0;
	inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
	inode->u.ext2_i.i_new_inode = 1;
	inode->u.ext2_i.i_flags = dir->u.ext2_i.i_flags;
	if (S_ISLNK(mode))
		inode->u.ext2_i.i_flags &= ~(EXT2_IMMUTABLE_FL | EXT2_APPEND_FL);
	inode->u.ext2_i.i_faddr = 0;
	inode->u.ext2_i.i_frag_no = 0;
	inode->u.ext2_i.i_frag_size = 0;
	inode->u.ext2_i.i_file_acl = 0;
	inode->u.ext2_i.i_dir_acl = 0;
	inode->u.ext2_i.i_dtime = 0;
	inode->u.ext2_i.i_block_group = i;
	inode->i_op = NULL;
	if (inode->u.ext2_i.i_flags & EXT2_SYNC_FL)
		inode->i_flags |= MS_SYNCHRONOUS;
	insert_inode_hash(inode);
	inc_inode_version (inode, gdp, mode);

	unlock_super (sb);
	if (sb->dq_op) {
		sb->dq_op->initialize (inode, -1);
		if (sb->dq_op->alloc_inode (inode, 1)) {
			sb->dq_op->drop (inode);
			inode->i_nlink = 0;
			iput (inode);
			*err = -EDQUOT;
			return NULL;
		}
		inode->i_flags |= S_WRITE;
	}
	ext2_debug ("allocating inode %lu\n", inode->i_ino);

	*err = 0;
	return inode;
}
예제 #14
0
void ext2_free_inode (struct inode * inode)
{
	struct super_block * sb;
	struct buffer_head * bh;
	struct buffer_head * bh2;
	unsigned long block_group;
	unsigned long bit;
	int bitmap_nr;
	int bs;
	struct ext2_group_desc * gdp;
	struct ext2_super_block * es;

	if (!inode)
		return;
	if (!inode->i_dev) {
		printk ("ext2_free_inode: inode has no device\n");
		return;
	}
	if (inode->i_count > 1) {
		printk ("ext2_free_inode: inode has count=%ld\n",
			inode->i_count);
		return;
	}
	if (inode->i_nlink) {
		printk ("ext2_free_inode: inode has nlink=%d\n",
			inode->i_nlink);
		return;
	}
	sb = inode->i_sb;
	if (!sb) {
		printk("ext2_free_inode: inode on nonexistent device\n");
		return;
	}

	ext2_debug ("freeing inode %lu\n", inode->i_ino);

	/* We need to kill quota references now, before grabbing the
	 * superblock lock because writing the quota out to disk
	 * may need to lock the superblock as well.
	 *
	 * It is safe to do this early instead of the original
	 * places because we cannot be here in ext2_free_inode
	 * if any other references to this inode exist at all.
	 *
	 * Based upon a 2.1.x fix by Bill Hawes.   --DaveM
	 */
	if (sb->dq_op) {
		sb->dq_op->free_inode (inode, 1);
		if (IS_WRITABLE (inode))
			sb->dq_op->drop(inode);
	}

	lock_super (sb);
	bs = BYTE_SWAP(inode->i_sb->u.ext2_sb.s_byte_swapped);
	if (inode->i_ino < EXT2_FIRST_INO(sb) ||
	    inode->i_ino > e_swab (bs, sb->u.ext2_sb.s_es->s_inodes_count)) {
		ext2_error (sb, "free_inode",
			    "reserved inode or nonexistent inode");
		unlock_super (sb);
		return;
	}
	es = sb->u.ext2_sb.s_es;
	block_group = (inode->i_ino - 1) / EXT2_INODES_PER_GROUP(sb);
	bit = (inode->i_ino - 1) % EXT2_INODES_PER_GROUP(sb);
	bitmap_nr = load_inode_bitmap (sb, block_group);
	if (bitmap_nr < 0) {
		unlock_super (sb);
		return;
	}
	
	bh = sb->u.ext2_sb.s_inode_bitmap[bitmap_nr];
	if (!ext2_clear_bit (bit, bh->b_data))
		ext2_warning (sb, "ext2_free_inode",
			      "bit already cleared for inode %lu", inode->i_ino);
	else {
		gdp = get_group_desc (sb, block_group, &bh2);
		e_set_swab (bs, gdp->bg_free_inodes_count,
			    e_swab (bs, gdp->bg_free_inodes_count) + 1);
		if (S_ISDIR(inode->i_mode))
			e_set_swab (bs, gdp->bg_used_dirs_count,
				    e_swab (bs, gdp->bg_used_dirs_count) - 1);
		mark_buffer_dirty(bh2, 1);
		e_set_swab (bs, es->s_free_inodes_count,
			    e_swab (bs, es->s_free_inodes_count) + 1);
		mark_buffer_dirty(sb->u.ext2_sb.s_sbh, 1);
		inode->i_dirt = 0;
	}
	mark_buffer_dirty(bh, 1);
	if (sb->s_flags & MS_SYNCHRONOUS) {
		ll_rw_block (WRITE, 1, &bh);
		wait_on_buffer (bh);
	}
	sb->s_dirt = 1;
	clear_inode (inode);
	unlock_super (sb);
}