bitmaps.c

Sample code for use on smp 863x processor.

	profile->PixelAspectRatio.Y = 1;
	profile->Width = gif_info->width = gif_info->gif_hdr->SWidth;
	profile->Height = gif_info->height = gif_info->gif_hdr->SHeight;
	return RM_OK;
}
static  RMstatus gif_get_palette(RMuint32 *palette, struct RMgifInfo *gif_info)
{
	RMuint32 row;

	if (!gif_info)
		return RM_ERROR;

	if (!gif_info->gif_hdr)
		return RM_ERROR;

	if (!gif_info->gif_hdr->SColorMap) {
		RMDBGLOG((ENABLE, "no global color map\n"));

		if (gif_info->gif_hdr->Image.ColorMap) {
			RMDBGLOG((ENABLE, "using local color map\n"));

			for(row = 0; row < 256; row++){
				palette[row] = (gif_info->alpha<<24) & 0xff000000;
				palette[row] |= (gif_info->gif_hdr->Image.ColorMap->Colors[row].Red)<<16;
				palette[row] |= (gif_info->gif_hdr->Image.ColorMap->Colors[row].Green)<<8;
				palette[row] |=  gif_info->gif_hdr->Image.ColorMap->Colors[row].Blue;
			}
			return RM_OK;
		}

		fprintf(stderr, "gif without color map, revert to grayscale palette\n");

		for(row = 0; row < 256; row++) {
			palette[row] = (gif_info->alpha<<24) & 0xff000000;
			palette[row] |= (255 - row) << 16;
			palette[row] |= (255 - row) << 8;
			palette[row] |= 255 - row;
		}

		return RM_OK;
	}

	for(row = 0; row < 256; row++){
		palette[row] = (gif_info->alpha<<24) & 0xff000000;
		palette[row] |= (gif_info->gif_hdr->SColorMap->Colors[row].Red)<<16;
		palette[row] |= (gif_info->gif_hdr->SColorMap->Colors[row].Green)<<8;
		palette[row] |=  gif_info->gif_hdr->SColorMap->Colors[row].Blue;
	}
	return RM_OK;
}


static RMstatus gif_to_raw(RMuint8 *luma, struct RMgifInfo *gif_info)
{
	GifRecordType rtype;
	RMuint32 interlacedOffset[] = { 0, 4, 2, 1 };
	RMuint32 interlacedJumps[] = { 8, 8, 4, 2 };
	RMuint32 row, i, j;

	// read image record type
	rtype = UNDEFINED_RECORD_TYPE;
	DGifGetRecordType(gif_info->gif_hdr, &rtype);
	while(rtype != IMAGE_DESC_RECORD_TYPE){
		DGifGetRecordType(gif_info->gif_hdr, &rtype);
	}
	
	// read image data
	if(DGifGetImageDesc(gif_info->gif_hdr) == GIF_ERROR){
		DGifCloseFile(gif_info->gif_hdr);
		return RM_ERROR;
	}

	
	if(gif_info->gif_hdr->Image.Interlace){
		row = gif_info->gif_hdr->Image.Top;

		for(i = 0;  i < 4;  ++i) {
			for (j = row + interlacedOffset[i]; j < row + gif_info->height;  j+= interlacedJumps[i]){
	                   	if(DGifGetLine(gif_info->gif_hdr, luma + (j * gif_info->width), gif_info->width ) == GIF_ERROR){
					DGifCloseFile(gif_info->gif_hdr);
					return RM_ERROR;
				}
			}
		 }
	}
	else{
		for(j = 0;  j < gif_info->height;  j++) {
			if(DGifGetLine(gif_info->gif_hdr, luma + (j * gif_info->width), gif_info->width ) == GIF_ERROR){
				DGifCloseFile(gif_info->gif_hdr);
				return RM_ERROR;
			}
		}
	}
		
	return RM_OK;
}

static void gif_cleanup(struct RMgifInfo *gif_info)
{
	DGifCloseFile(gif_info->gif_hdr);
}



RMstatus RMOpenBitmapFile(RMascii *filename, struct RMBitmapFileInfo *bfi, struct RMBitmapFileOptions *opts, struct DCCOSDProfile  *profile )
{
	
	RMascii *file_ext = &(filename[strlen(filename) - 4]);
	RMfile fp;
	RMstatus status;


	if (! RMMemcmp(file_ext, "gray", 4) || ! RMMemcmp(file_ext, "grey", 4)) {
		bfi->file_format = RMBitmap_TestPattern;
		bfi->info.tp.pattern = 1; // gray zig-zag pattern, 16 by 16 fields
		bfi->info.tp.width = 512;
		bfi->info.tp.height = 384;
		bfi->info.tp.force_rgb = opts->force_rgb;
		bfi->info.tp.alpha = opts->alpha;
		if (bfi->info.tp.force_rgb) {
			profile->ColorSpace = EMhwlibColorSpace_RGB_0_255;
			profile->SamplingMode = EMhwlibSamplingMode_444;
			profile->ColorMode = EMhwlibColorMode_TrueColor;
		} else {
			profile->ColorSpace = EMhwlibColorSpace_YUV_601_0_255;
			profile->SamplingMode = EMhwlibSamplingMode_420;
			profile->ColorMode = EMhwlibColorMode_VideoNonInterleaved;
		}
		profile->ColorFormat = EMhwlibColorFormat_32BPP;
		profile->PixelAspectRatio.X = 1;
		profile->PixelAspectRatio.Y = 1;
		profile->Width = bfi->info.tp.width;
		profile->Height = bfi->info.tp.height;
		return RM_OK;
	}
	else if (! RMMemcmp(file_ext, "yrgb", 4)) {
		bfi->file_format = RMBitmap_TestPattern;
		bfi->info.tp.pattern = 2; // gray/red/green/blue zig-zag pattern, 16 by 16 fields
		bfi->info.tp.width = 512;
		bfi->info.tp.height = 384;
		bfi->info.tp.force_rgb = opts->force_rgb;
		bfi->info.tp.alpha = opts->alpha;
		if (bfi->info.tp.force_rgb) {
			profile->ColorSpace = EMhwlibColorSpace_RGB_0_255;
			profile->SamplingMode = EMhwlibSamplingMode_444;
			profile->ColorMode = EMhwlibColorMode_TrueColor;
		} else {
			profile->ColorSpace = EMhwlibColorSpace_YUV_601_0_255;
			profile->SamplingMode = EMhwlibSamplingMode_420;
			profile->ColorMode = EMhwlibColorMode_VideoNonInterleaved;
		}
		profile->ColorFormat = EMhwlibColorFormat_32BPP;
		profile->PixelAspectRatio.X = 1;
		profile->PixelAspectRatio.Y = 1;
		profile->Width = bfi->info.tp.width;
		profile->Height = bfi->info.tp.height;
		return RM_OK;
	}
	else if (! RMMemcmp(file_ext, "rst1", 4)) {
		//struct EMhwlibTVFormatDigital fmt;
		
		//err = RUAGetProperty(dcc_info->pRUA, DispDigitalOut, RMDispDigitalOutPropertyID_TVFormat, &fmt, sizeof(fmt));
		bfi->file_format = RMBitmap_TestPattern;
		bfi->info.tp.pattern = (! RMMemcmp(file_ext, "rst2", 4)) ? 3 : 4; // vertical burst pattern, bit 2 always zero(3) or one(4)
		//bfi->info.tp.width = fmt.ActiveWidth;
		//bfi->info.tp.height = fmt.ActiveHeight;
		bfi->info.tp.width = 1440;
		bfi->info.tp.height = 480;
		bfi->info.tp.force_rgb = TRUE;
		bfi->info.tp.alpha = opts->alpha;
		profile->ColorSpace = EMhwlibColorSpace_RGB_0_255;
		profile->SamplingMode = EMhwlibSamplingMode_444;
		profile->ColorMode = EMhwlibColorMode_TrueColor;
		profile->ColorFormat = EMhwlibColorFormat_32BPP;
		profile->PixelAspectRatio.X = 1;
		profile->PixelAspectRatio.Y = 1;
		profile->Width = bfi->info.tp.width;
		profile->Height = bfi->info.tp.height;
		return RM_OK;
	}
	else if ( (! RMMemcmp(file_ext, "rst2", 4)) || (! RMMemcmp(file_ext, "rst3", 4)) ) {
		//struct EMhwlibTVFormatDigital fmt;
		
		//err = RUAGetProperty(dcc_info->pRUA, DispDigitalOut, RMDispDigitalOutPropertyID_TVFormat, &fmt, sizeof(fmt));
		bfi->file_format = RMBitmap_TestPattern;
		bfi->info.tp.pattern = (! RMMemcmp(file_ext, "rst2", 4)) ? 3 : 4; // vertical burst pattern, bit 2 always zero(3) or one(4)
		//bfi->info.tp.width = fmt.ActiveWidth;
		//bfi->info.tp.height = fmt.ActiveHeight;
		bfi->info.tp.width = 1920;
		bfi->info.tp.height = 1080;
		bfi->info.tp.force_rgb = TRUE;
		bfi->info.tp.alpha = opts->alpha;
		profile->ColorSpace = EMhwlibColorSpace_RGB_0_255;
		profile->SamplingMode = EMhwlibSamplingMode_444;
		profile->ColorMode = EMhwlibColorMode_TrueColor;
		profile->ColorFormat = EMhwlibColorFormat_32BPP;
		profile->PixelAspectRatio.X = 1;
		profile->PixelAspectRatio.Y = 1;
		profile->Width = bfi->info.tp.width;
		profile->Height = bfi->info.tp.height;
		return RM_OK;
	}
	else if ( RMCompareAsciiCaseInsensitively(file_ext, ".bmp")) 
		bfi->file_format = RMBitmap_BMP_Format;
	else if ( (RMCompareAsciiCaseInsensitively(file_ext, ".jpg")) || (RMCompareAsciiCaseInsensitively(file_ext, "jpeg")) )
		bfi->file_format = RMBitmap_JPG_Format;
	else if ( RMCompareAsciiCaseInsensitively(file_ext, ".gif")) 
		bfi->file_format = RMBitmap_GIF_Format;
	else if ( RMCompareAsciiCaseInsensitively(file_ext, ".yuv")) 
		bfi->file_format = RMBitmap_YUV_Format;
	else if ( RMCompareAsciiCaseInsensitively(file_ext, ".png")) 
		bfi->file_format = RMBitmap_PNG_Format;
	else{
		RMDBGLOG((ENABLE, "Filename '%s' has wrong file extension '%s'\n", filename, file_ext));
		return RM_ERROR;
	}

	/* open the stream */
	fp = open_stream(filename, RM_FILE_OPEN_READ, 0);
	if (fp == NULL) {
		RMDBGLOG((ENABLE, "Cannot open file %s\n", filename));
		return RM_ERROR;
	}
	if(bfi->file_format == RMBitmap_JPG_Format){
		JXFORM_CODE transform1, transform2;
		transform1 = transform2 = JXFORM_NONE;
		switch(opts->orientation){
		case FRTop_FCLeft:
			break;
		case FRTop_FCRight:
			transform1 = JXFORM_FLIP_H;
			break;
		case FRBottom_FCRight:
			transform1 = JXFORM_ROT_180;
			break;
		case FRBottom_FCLeft:
			transform1 = JXFORM_FLIP_V;
			break;
		case FRLeft_FCTop:
			transform1 = JXFORM_ROT_270;
			transform2 = JXFORM_FLIP_V;
			break;
		case FRRight_FCTop:
			transform1 = JXFORM_ROT_90;
			break;
		case FRLeft_FCBottom:
			transform1 = JXFORM_ROT_270;
			break;
		case FRRight_FCBottom:
			transform1 = JXFORM_ROT_90;
			transform2 = JXFORM_FLIP_V;
			break;
		}
		if(transform1 != JXFORM_NONE){
			RMint64 size;
			RMfile mem_fp;
			RMSizeOfOpenFile(fp, &size);
			size += 1024;/*when rotating, files can get bigger*/
			mem_fp = RMCreateMemoryFile(size); 
			jpeg_flip_rotate(fp, mem_fp, transform1);
			RMSeekFile(mem_fp, 0, RM_FILE_SEEK_START);
			RMCloseFile(fp);
			fp = mem_fp;
			if(transform2 != JXFORM_NONE){
				mem_fp = RMCreateMemoryFile(size); 
				jpeg_flip_rotate(fp, mem_fp, transform2);
				RMSeekFile(mem_fp, 0, RM_FILE_SEEK_START);
				RMCloseFile(fp); /*free file with transform 1*/
				fp = mem_fp;
			}
		}
	}
					      
	switch(bfi->file_format){
	case RMBitmap_BMP_Format:
		bfi->info.bmp.fp = fp;
		if(opts != NULL)
			bfi->info.bmp.alpha = opts->alpha;
		else
			bfi->info.bmp.alpha = 0x80;

 		status = open_bmp_file(&(bfi->info.bmp), profile);
		if (status != RM_OK)
			RMCloseFile(fp);
		return status;

	
	case RMBitmap_JPG_Format:
		bfi->info.jpg.fp = fp;
		if(opts != NULL){
			bfi->info.jpg.force_rgb = opts->force_rgb;
			bfi->info.jpg.alpha = opts->alpha;
		}
		else{
			bfi->info.jpg.force_rgb = TRUE;
			bfi->info.jpg.alpha = 0x80;
		}
		status = open_jpg_file(&(bfi->info.jpg), profile);
		if (status != RM_OK)
			RMCloseFile(fp);
		return status;

	case RMBitmap_GIF_Format:
		bfi->info.gif.fp = fp;
		if(opts != NULL)
			bfi->info.gif.alpha = opts->alpha;
		else
			bfi->info.gif.alpha = 0x80;

 		status = open_gif_file(&(bfi->info.gif), profile);
		if (status != RM_OK)
			RMCloseFile(fp);
		return status;

	case RMBitmap_PNG_Format:
		bfi->info.png.fp = fp;
		if(opts != NULL)
			bfi->info.png.alpha = opts->alpha;
		else
			bfi->info.png.alpha = 0x80;

 		status = open_png_file(&(bfi->info.png), profile);
		if (status != RM_OK)
			RMCloseFile(fp);
		return status;


	case RMBitmap_YUV_Format:
		bfi->info.yuv.fp = fp;
		status = open_yuv_file(&(bfi->info.yuv), profile);
		if (status != RM_OK)
			RMCloseFile(fp);
		return status;
	
	case RMBitmap_TestPattern:
		return RM_ERROR;
	}
	return RM_ERROR;
}

RMstatus RMBitmapToRaw(RMuint8 *luma, RMuint8 *chroma, struct RMBitmapFileInfo *bfi)
{

	switch(bfi->file_format){
	case RMBitmap_BMP_Format:
		return bmp_to_raw(luma, &(bfi->info.bmp));
	case RMBitmap_JPG_Format:
		return jpg_to_raw(luma, chroma, &(bfi->info.jpg));
	case RMBitmap_GIF_Format:
		return gif_to_raw(luma, &(bfi->info.gif));
	case RMBitmap_PNG_Format:
		return png_to_raw(luma, &(bfi->info.png));
	case RMBitmap_YUV_Format:
		return yuv_to_raw(luma, &(bfi->info.yuv));
	case RMBitmap_TestPattern:
		switch (bfi->info.tp.pattern) {
		default:
		case 1:
			if (bfi->info.tp.force_rgb) {
				create_gray_fields_RGB(bfi->info.tp.width, bfi->info.tp.height, luma, bfi->info.tp.alpha);
			} else {
				create_gray_fields_420(bfi->info.tp.width, bfi->info.tp.height, luma, chroma);
			}
			break;
		case 2:
			if (bfi->info.tp.force_rgb) {
				create_grayrgb_fields_RGB(bfi->info.tp.width, bfi->info.tp.height, luma, bfi->info.tp.alpha);
			} else {
				create_grayrgb_fields_420(bfi->info.tp.width, bfi->info.tp.height, luma, chroma);
			}
			break;
		case 3:
			bfi->info.tp.force_rgb = TRUE;
			create_burst_bit2_fields_RGB(bfi->info.tp.width, bfi->info.tp.height, luma, bfi->info.tp.alpha);
			break;
		case 4:
			bfi->info.tp.force_rgb = TRUE;
			create_burst_bit2_1_fields_RGB(bfi->info.tp.width, bfi->info.tp.height, luma, bfi->info.tp.alpha);
			break;
		}
		return RM_OK;
	}
	return RM_ERROR;
}
RMstatus RMBitmapGetPalette(RMuint32 *palette, struct RMBitmapFileInfo *bfi)
{
	switch(bfi->file_format){
	case RMBitmap_BMP_Format:
		return bmp_get_palette(palette, &(bfi->info.bmp));
	case RMBitmap_PNG_Format:
		return png_get_palette(palette, &(bfi->info.png));
	case RMBitmap_GIF_Format:
		return gif_get_palette(palette, &(bfi->info.gif));
	case RMBitmap_JPG_Format:
	case RMBitmap_YUV_Format:
	case RMBitmap_TestPattern:
		return RM_ERROR;
	}
	return RM_ERROR;
}

void RMBitmapSetSourceWindow(struct EMhwlibDisplayWindow *window, struct RMBitmapFileInfo *bfi)
{
	window->X = 0;
	window->Y = 0;
	window->XPositionMode = EMhwlibDisplayWindowPositionMode_FrontEdgeToBorder;
	window->YPositionMode = EMhwlibDisplayWindowPositionMode_FrontEdgeToBorder;
	window->XMode = EMhwlibDisplayWindowValueMode_Fixed;
	window->YMode = EMhwlibDisplayWindowValueMode_Fixed;
	window->WidthMode = EMhwlibDisplayWindowValueMode_Fixed;
	window->HeightMode = EMhwlibDisplayWindowValueMode_Fixed;
	
	switch(bfi->file_format){
	case RMBitmap_BMP_Format:
		window->Width = bfi->info.bmp.width;
		window->Height = bfi->info.bmp.height;
		break;
	case RMBitmap_JPG_Format:
		window->Width = bfi->info.jpg.width;
		window->Height = bfi->info.jpg.height;
		break;
	case RMBitmap_GIF_Format:
		window->Width = bfi->info.gif.width;
		window->Height = bfi->info.gif.height;
		break;
	case RMBitmap_PNG_Format:
		window->Width = bfi->info.png.width;
		window->Height = bfi->info.png.height;
		break;
	case RMBitmap_YUV_Format:
		window->Width = bfi->info.yuv.width;
		window->Height = bfi->info.yuv.height;
		break;
	case RMBitmap_TestPattern:
		window->Width = bfi->info.tp.width;
		window->Height = bfi->info.tp.height;
		break;
	}
}


void RMCloseBitmapFile(struct RMBitmapFileInfo *bfi)
{
	RMfile fp = (RMfile)NULL;
	RMstatus err;
	switch(bfi->file_format){
	case RMBitmap_BMP_Format:
		fp = bfi->info.bmp.fp;
		break;
	case RMBitmap_JPG_Format:
		jpg_cleanup(&(bfi->info.jpg));
		fp = bfi->info.jpg.fp;
		break;
	case RMBitmap_GIF_Format:
		gif_cleanup(&(bfi->info.gif));
		fp = bfi->info.gif.fp;
		break;
	case RMBitmap_PNG_Format:
		png_cleanup(&(bfi->info.png));
		fp = bfi->info.png.fp;
		break;
	case RMBitmap_YUV_Format:
		fp = bfi->info.yuv.fp;
		break;
	default:
		return;
	}

	err = RMCloseFile(fp);
	if(RMFAILED(err)){
		RMDBGLOG((ENABLE, "Error closing bitmap file\n"));
	}
}